diff --git a/.github/scripts/firebase/README.md b/.github/scripts/firebase/README.md
new file mode 100644
index 000000000..f5b8e549a
--- /dev/null
+++ b/.github/scripts/firebase/README.md
@@ -0,0 +1,50 @@
+# Firebase GitHub Secrets Scripts
+
+This directory contains scripts for managing Firebase service account secrets used by GitHub Actions workflows.
+
+## Scripts
+
+### setup-github-secrets.sh
+
+Automates the creation and configuration of Firebase service accounts and GitHub repository secrets.
+
+**What it does:**
+- Creates service accounts in Google Cloud projects (if they don't exist)
+- Grants required IAM permissions for Firebase deployments
+- Generates service account keys
+- Creates/updates GitHub repository secrets
+- Cleans up sensitive key files
+
+**Usage:**
+```bash
+./.github/scripts/firebase/setup-github-secrets.sh
+```
+
+### verify-github-secrets.sh
+
+Verifies that Firebase service accounts and GitHub secrets are properly configured.
+
+**What it checks:**
+- Prerequisites (gcloud, gh, jq installations)
+- Authentication status (Google Cloud and GitHub)
+- Firebase project accessibility
+- Service account existence and permissions
+- GitHub secret configuration
+
+**Usage:**
+```bash
+./.github/scripts/firebase/verify-github-secrets.sh
+```
+
+## Required Permissions
+
+To run these scripts, you need:
+- Admin access to Firebase projects (`komodo-defi-sdk` and `komodo-playground`)
+- Write access to GitHub repository secrets
+- Google Cloud CLI (`gcloud`) authenticated
+- GitHub CLI (`gh`) authenticated
+
+## Related Documentation
+
+For detailed setup instructions and troubleshooting, see:
+[Firebase Deployment Setup Guide](../../../docs/firebase/firebase-deployment-setup.md)
diff --git a/.github/scripts/firebase/setup-github-secrets.sh b/.github/scripts/firebase/setup-github-secrets.sh
new file mode 100755
index 000000000..9a1bf3c54
--- /dev/null
+++ b/.github/scripts/firebase/setup-github-secrets.sh
@@ -0,0 +1,260 @@
+#!/bin/bash
+
+# Setup Firebase GitHub Secrets Script
+# This script automates the creation and configuration of Firebase service accounts
+# and GitHub secrets for the Komodo DeFi SDK Flutter project
+
+set -e  # Exit on error
+
+# Color codes for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Configuration
+GITHUB_REPO="KomodoPlatform/komodo-defi-sdk-flutter"
+SDK_PROJECT_ID="komodo-defi-sdk"
+PLAYGROUND_PROJECT_ID="komodo-playground"
+SDK_SERVICE_ACCOUNT_NAME="github-actions-deploy"
+PLAYGROUND_SERVICE_ACCOUNT_NAME="github-actions-deploy"
+
+# Function to print colored output
+print_status() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+print_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+print_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+print_warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+# Function to check if a command exists
+check_command() {
+    if ! command -v $1 &> /dev/null; then
+        print_error "$1 is not installed. Please install it first."
+        return 1
+    fi
+    return 0
+}
+
+# Function to check if user is authenticated with gcloud
+check_gcloud_auth() {
+    if ! gcloud auth list --filter=status:ACTIVE --format="value(account)" | grep -q .; then
+        print_error "Not authenticated with gcloud. Please run: gcloud auth login"
+        return 1
+    fi
+    return 0
+}
+
+# Function to check if user is authenticated with gh
+check_gh_auth() {
+    if ! gh auth status &> /dev/null; then
+        print_error "Not authenticated with GitHub CLI. Please run: gh auth login"
+        return 1
+    fi
+    return 0
+}
+
+# Function to create service account if it doesn't exist
+create_service_account_if_needed() {
+    local project_id=$1
+    local service_account_name=$2
+    local service_account_email="${service_account_name}@${project_id}.iam.gserviceaccount.com"
+    
+    print_status "Checking if service account ${service_account_email} exists..."
+    
+    if gcloud iam service-accounts describe "${service_account_email}" --project="${project_id}" &> /dev/null; then
+        print_status "Service account already exists"
+    else
+        print_status "Creating service account..."
+        gcloud iam service-accounts create "${service_account_name}" \
+            --display-name="GitHub Actions Deploy" \
+            --description="Service account for GitHub Actions Firebase deployments" \
+            --project="${project_id}"
+        print_success "Service account created"
+    fi
+}
+
+# Function to grant necessary permissions to service account
+grant_permissions() {
+    local project_id=$1
+    local service_account_email=$2
+    
+    print_status "Granting permissions to ${service_account_email}..."
+    
+    # Array of roles to grant
+    local roles=(
+        "roles/firebase.hosting.admin"
+        "roles/firebase.rules.admin"
+        "roles/iam.serviceAccountTokenCreator"
+    )
+    
+    for role in "${roles[@]}"; do
+        print_status "Granting ${role}..."
+        gcloud projects add-iam-policy-binding "${project_id}" \
+            --member="serviceAccount:${service_account_email}" \
+            --role="${role}" \
+            --quiet &> /dev/null || true
+    done
+    
+    print_success "Permissions granted"
+}
+
+# Function to generate service account key
+generate_service_account_key() {
+    local project_id=$1
+    local service_account_name=$2
+    local key_file=$3
+    local service_account_email="${service_account_name}@${project_id}.iam.gserviceaccount.com"
+    
+    print_status "Generating service account key for ${service_account_email}..."
+    
+    gcloud iam service-accounts keys create "${key_file}" \
+        --iam-account="${service_account_email}" \
+        --project="${project_id}"
+    
+    print_success "Service account key generated: ${key_file}"
+}
+
+# Function to create or update GitHub secret
+create_github_secret() {
+    local secret_name=$1
+    local key_file=$2
+    
+    print_status "Creating/updating GitHub secret: ${secret_name}..."
+    
+    # Check if running in GitHub Actions or local
+    if [ -n "$GITHUB_REPOSITORY" ]; then
+        # Running in GitHub Actions
+        gh secret set "${secret_name}" < "${key_file}" --repo "${GITHUB_REPOSITORY}"
+    else
+        # Running locally
+        gh secret set "${secret_name}" < "${key_file}" --repo "${GITHUB_REPO}"
+    fi
+    
+    print_success "GitHub secret ${secret_name} created/updated"
+}
+
+# Main execution
+main() {
+    print_status "Starting Firebase GitHub secrets setup..."
+    
+    # Step 1: Check prerequisites
+    print_status "Checking prerequisites..."
+    
+    if ! check_command "gcloud"; then
+        print_error "Please install Google Cloud SDK: https://cloud.google.com/sdk/docs/install"
+        exit 1
+    fi
+    
+    if ! check_command "gh"; then
+        print_error "Please install GitHub CLI: https://cli.github.com/manual/installation"
+        exit 1
+    fi
+    
+    if ! check_gcloud_auth; then
+        exit 1
+    fi
+    
+    if ! check_gh_auth; then
+        exit 1
+    fi
+    
+    print_success "All prerequisites met"
+    
+    # Step 2: Set up komodo-defi-sdk project
+    print_status "Setting up komodo-defi-sdk project..."
+    
+    # Set the project
+    gcloud config set project "${SDK_PROJECT_ID}" --quiet
+    
+    # Create service account if needed
+    create_service_account_if_needed "${SDK_PROJECT_ID}" "${SDK_SERVICE_ACCOUNT_NAME}"
+    
+    # Grant permissions
+    grant_permissions "${SDK_PROJECT_ID}" "${SDK_SERVICE_ACCOUNT_NAME}@${SDK_PROJECT_ID}.iam.gserviceaccount.com"
+    
+    # Generate key
+    SDK_KEY_FILE="komodo-defi-sdk-key.json"
+    generate_service_account_key "${SDK_PROJECT_ID}" "${SDK_SERVICE_ACCOUNT_NAME}" "${SDK_KEY_FILE}"
+    
+    # Create GitHub secret
+    create_github_secret "FIREBASE_SERVICE_ACCOUNT_KOMODO_DEFI_SDK" "${SDK_KEY_FILE}"
+    
+    # Step 3: Set up komodo-playground project
+    print_status "Setting up komodo-playground project..."
+    
+    # Set the project
+    gcloud config set project "${PLAYGROUND_PROJECT_ID}" --quiet
+    
+    # Create service account if needed
+    create_service_account_if_needed "${PLAYGROUND_PROJECT_ID}" "${PLAYGROUND_SERVICE_ACCOUNT_NAME}"
+    
+    # Grant permissions
+    grant_permissions "${PLAYGROUND_PROJECT_ID}" "${PLAYGROUND_SERVICE_ACCOUNT_NAME}@${PLAYGROUND_PROJECT_ID}.iam.gserviceaccount.com"
+    
+    # Generate key
+    PLAYGROUND_KEY_FILE="komodo-playground-key.json"
+    generate_service_account_key "${PLAYGROUND_PROJECT_ID}" "${PLAYGROUND_SERVICE_ACCOUNT_NAME}" "${PLAYGROUND_KEY_FILE}"
+    
+    # Create GitHub secret
+    create_github_secret "FIREBASE_SERVICE_ACCOUNT_KOMODO_PLAYGROUND" "${PLAYGROUND_KEY_FILE}"
+    
+    # Step 4: Clean up sensitive files
+    print_status "Cleaning up sensitive files..."
+    
+    if [ -f "${SDK_KEY_FILE}" ]; then
+        rm -f "${SDK_KEY_FILE}"
+        print_success "Removed ${SDK_KEY_FILE}"
+    fi
+    
+    if [ -f "${PLAYGROUND_KEY_FILE}" ]; then
+        rm -f "${PLAYGROUND_KEY_FILE}"
+        print_success "Removed ${PLAYGROUND_KEY_FILE}"
+    fi
+    
+    # Step 5: Verify setup
+    print_status "Verifying setup..."
+    
+    # Check if secrets exist
+    if gh secret list --repo "${GITHUB_REPO}" | grep -q "FIREBASE_SERVICE_ACCOUNT_KOMODO_DEFI_SDK"; then
+        print_success "FIREBASE_SERVICE_ACCOUNT_KOMODO_DEFI_SDK secret exists"
+    else
+        print_error "FIREBASE_SERVICE_ACCOUNT_KOMODO_DEFI_SDK secret not found"
+    fi
+    
+    if gh secret list --repo "${GITHUB_REPO}" | grep -q "FIREBASE_SERVICE_ACCOUNT_KOMODO_PLAYGROUND"; then
+        print_success "FIREBASE_SERVICE_ACCOUNT_KOMODO_PLAYGROUND secret exists"
+    else
+        print_error "FIREBASE_SERVICE_ACCOUNT_KOMODO_PLAYGROUND secret not found"
+    fi
+    
+    print_success "Firebase GitHub secrets setup completed!"
+    print_status "You can now test the deployment by creating a pull request or pushing to the dev branch."
+}
+
+# Display banner
+echo "================================================"
+echo "Firebase GitHub Secrets Setup Script"
+echo "================================================"
+echo
+
+# Confirm before proceeding
+read -p "This script will set up Firebase service accounts and GitHub secrets. Continue? (y/N) " -n 1 -r
+echo
+if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+    print_warning "Setup cancelled"
+    exit 0
+fi
+
+# Run main function
+main
diff --git a/.github/scripts/firebase/verify-github-secrets.sh b/.github/scripts/firebase/verify-github-secrets.sh
new file mode 100755
index 000000000..91d430736
--- /dev/null
+++ b/.github/scripts/firebase/verify-github-secrets.sh
@@ -0,0 +1,255 @@
+#!/bin/bash
+
+# Verify Firebase GitHub Secrets Script (Updated)
+# This script checks the current status of Firebase service accounts and GitHub secrets
+# Updated to check for the actual service accounts in use
+
+set -e  # Exit on error
+
+# Color codes for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Configuration
+GITHUB_REPO="KomodoPlatform/komodo-defi-sdk-flutter"
+SDK_PROJECT_ID="komodo-defi-sdk"
+PLAYGROUND_PROJECT_ID="komodo-playground"
+# Updated to use the actual service account names
+SDK_SERVICE_ACCOUNT_NAME="github-action-839744467"
+PLAYGROUND_SERVICE_ACCOUNT_NAME="github-action-839744467"
+
+# Function to print colored output
+print_status() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+print_success() {
+    echo -e "${GREEN}[✓]${NC} $1"
+}
+
+print_error() {
+    echo -e "${RED}[✗]${NC} $1"
+}
+
+print_warning() {
+    echo -e "${YELLOW}[!]${NC} $1"
+}
+
+# Function to check if a command exists
+check_command() {
+    if command -v $1 &> /dev/null; then
+        print_success "$1 is installed"
+        return 0
+    else
+        print_error "$1 is not installed"
+        return 1
+    fi
+}
+
+# Function to check gcloud authentication
+check_gcloud_auth() {
+    if gcloud auth list --filter=status:ACTIVE --format="value(account)" | grep -q .; then
+        local account=$(gcloud auth list --filter=status:ACTIVE --format="value(account)" | head -n1)
+        print_success "Authenticated with gcloud as: ${account}"
+        return 0
+    else
+        print_error "Not authenticated with gcloud"
+        return 1
+    fi
+}
+
+# Function to check GitHub CLI authentication
+check_gh_auth() {
+    if gh auth status &> /dev/null; then
+        print_success "Authenticated with GitHub CLI"
+        return 0
+    else
+        print_error "Not authenticated with GitHub CLI"
+        return 1
+    fi
+}
+
+# Function to check if service account exists
+check_service_account() {
+    local project_id=$1
+    local service_account_name=$2
+    local service_account_email="${service_account_name}@${project_id}.iam.gserviceaccount.com"
+    
+    if gcloud iam service-accounts describe "${service_account_email}" --project="${project_id}" &> /dev/null; then
+        print_success "Service account exists: ${service_account_email}"
+        return 0
+    else
+        print_error "Service account does not exist: ${service_account_email}"
+        return 1
+    fi
+}
+
+# Function to check service account permissions
+check_permissions() {
+    local project_id=$1
+    local service_account_email=$2
+    
+    print_status "Checking permissions for ${service_account_email}..."
+    
+    # Get the IAM policy for the project
+    local policy=$(gcloud projects get-iam-policy "${project_id}" --format=json 2>/dev/null)
+    
+    # Updated required roles - only checking for the essential ones
+    local required_roles=(
+        "roles/firebasehosting.admin"
+    )
+    
+    # Optional but recommended roles
+    local optional_roles=(
+        "roles/firebase.rules.admin"
+        "roles/iam.serviceAccountTokenCreator"
+        "roles/firebaseauth.admin"
+    )
+    
+    local missing_required=()
+    local missing_optional=()
+    
+    # Check required roles
+    for role in "${required_roles[@]}"; do
+        if echo "${policy}" | jq -e ".bindings[] | select(.role == \"${role}\") | .members[] | select(. == \"serviceAccount:${service_account_email}\")" &> /dev/null; then
+            print_success "  Has required permission: ${role}"
+        else
+            print_error "  Missing required permission: ${role}"
+            missing_required+=("${role}")
+        fi
+    done
+    
+    # Check optional roles
+    for role in "${optional_roles[@]}"; do
+        if echo "${policy}" | jq -e ".bindings[] | select(.role == \"${role}\") | .members[] | select(. == \"serviceAccount:${service_account_email}\")" &> /dev/null; then
+            print_success "  Has optional permission: ${role}"
+        else
+            print_warning "  Missing optional permission: ${role}"
+            missing_optional+=("${role}")
+        fi
+    done
+    
+    if [ ${#missing_required[@]} -eq 0 ]; then
+        return 0
+    else
+        return 1
+    fi
+}
+
+# Function to check GitHub secret
+check_github_secret() {
+    local secret_name=$1
+    
+    # Check if running in GitHub Actions or local
+    local repo="${GITHUB_REPOSITORY:-${GITHUB_REPO}}"
+    
+    if gh secret list --repo "${repo}" 2>/dev/null | grep -q "^${secret_name}"; then
+        local updated=$(gh secret list --repo "${repo}" | grep "^${secret_name}" | awk '{print $2}')
+        print_success "GitHub secret exists: ${secret_name} (Updated: ${updated})"
+        return 0
+    else
+        print_error "GitHub secret does not exist: ${secret_name}"
+        return 1
+    fi
+}
+
+# Function to check Firebase project
+check_firebase_project() {
+    local project_id=$1
+    
+    if gcloud projects describe "${project_id}" &> /dev/null; then
+        print_success "Firebase project exists: ${project_id}"
+        return 0
+    else
+        print_error "Firebase project does not exist or you don't have access: ${project_id}"
+        return 1
+    fi
+}
+
+# Main verification
+main() {
+    local all_checks_passed=true
+    
+    echo "================================================"
+    echo "Firebase GitHub Secrets Verification (Updated)"
+    echo "================================================"
+    echo
+    
+    # Check prerequisites
+    print_status "Checking prerequisites..."
+    echo
+    
+    check_command "gcloud" || all_checks_passed=false
+    check_command "gh" || all_checks_passed=false
+    check_command "jq" || all_checks_passed=false
+    echo
+    
+    # Check authentication
+    print_status "Checking authentication..."
+    echo
+    
+    check_gcloud_auth || all_checks_passed=false
+    check_gh_auth || all_checks_passed=false
+    echo
+    
+    # Check Firebase projects
+    print_status "Checking Firebase projects..."
+    echo
+    
+    check_firebase_project "${SDK_PROJECT_ID}" || all_checks_passed=false
+    check_firebase_project "${PLAYGROUND_PROJECT_ID}" || all_checks_passed=false
+    echo
+    
+    # Check komodo-defi-sdk setup
+    print_status "Checking komodo-defi-sdk setup..."
+    echo
+    
+    if check_service_account "${SDK_PROJECT_ID}" "${SDK_SERVICE_ACCOUNT_NAME}"; then
+        check_permissions "${SDK_PROJECT_ID}" "${SDK_SERVICE_ACCOUNT_NAME}@${SDK_PROJECT_ID}.iam.gserviceaccount.com" || all_checks_passed=false
+    else
+        all_checks_passed=false
+    fi
+    echo
+    
+    # Check komodo-playground setup
+    print_status "Checking komodo-playground setup..."
+    echo
+    
+    if check_service_account "${PLAYGROUND_PROJECT_ID}" "${PLAYGROUND_SERVICE_ACCOUNT_NAME}"; then
+        check_permissions "${PLAYGROUND_PROJECT_ID}" "${PLAYGROUND_SERVICE_ACCOUNT_NAME}@${PLAYGROUND_PROJECT_ID}.iam.gserviceaccount.com" || all_checks_passed=false
+    else
+        all_checks_passed=false
+    fi
+    echo
+    
+    # Check GitHub secrets
+    print_status "Checking GitHub secrets..."
+    echo
+    
+    check_github_secret "FIREBASE_SERVICE_ACCOUNT_KOMODO_DEFI_SDK" || all_checks_passed=false
+    check_github_secret "FIREBASE_SERVICE_ACCOUNT_KOMODO_PLAYGROUND" || all_checks_passed=false
+    echo
+    
+    # Summary
+    echo "================================================"
+    echo "Summary:"
+    echo
+    print_status "Service Accounts in use:"
+    echo "  - SDK: github-action-839744467@komodo-defi-sdk.iam.gserviceaccount.com"
+    echo "  - Playground: github-action-839744467@komodo-playground.iam.gserviceaccount.com"
+    echo
+    
+    if [ "${all_checks_passed}" = true ]; then
+        print_success "All required checks passed! Firebase secrets are properly configured."
+        print_warning "Note: Some optional permissions may be missing but the setup should work fine."
+    else
+        print_error "Some required checks failed. Please review the errors above."
+    fi
+    echo "================================================"
+}
+
+# Run main function
+main
diff --git a/.github/workflows/firebase-hosting-merge.yml b/.github/workflows/firebase-hosting-merge.yml
index ecfd371dd..e8e0fa4b5 100644
--- a/.github/workflows/firebase-hosting-merge.yml
+++ b/.github/workflows/firebase-hosting-merge.yml
@@ -89,5 +89,6 @@ jobs:
           channelId: live
           projectId: komodo-defi-sdk
           entryPoint: ./packages/komodo_defi_sdk/example
+          target: kdf-sdk
         env:
           FIREBASE_CLI_EXPERIMENTS: webframeworks
diff --git a/.github/workflows/firebase-hosting-pull-request.yml b/.github/workflows/firebase-hosting-pull-request.yml
index b96dd9c8d..3e464fd0d 100644
--- a/.github/workflows/firebase-hosting-pull-request.yml
+++ b/.github/workflows/firebase-hosting-pull-request.yml
@@ -95,5 +95,6 @@ jobs:
           firebaseServiceAccount: ${{ secrets.FIREBASE_SERVICE_ACCOUNT_KOMODO_DEFI_SDK }}
           projectId: komodo-defi-sdk
           entryPoint: ./packages/komodo_defi_sdk/example
+          target: kdf-sdk
         env:
           FIREBASE_CLI_EXPERIMENTS: webframeworks
diff --git a/.gitignore b/.gitignore
index 1e5f69a64..d5991c115 100644
--- a/.gitignore
+++ b/.gitignore
@@ -114,6 +114,11 @@ macos/Frameworks/*
 key.txt
 .firebaserc
 firebase.json
+# Exception for Firebase config in example and playground apps
+!packages/komodo_defi_sdk/example/.firebaserc
+!packages/komodo_defi_sdk/example/firebase.json
+!playground/.firebaserc
+!playground/firebase.json
 *_combined.txt
 # /packages/komodo_defi_framework/web/kdf
 
diff --git a/ACTIVATION_PARAMS_REFACTORING_PLAN.md b/ACTIVATION_PARAMS_REFACTORING_PLAN.md
new file mode 100644
index 000000000..ab9ae103a
--- /dev/null
+++ b/ACTIVATION_PARAMS_REFACTORING_PLAN.md
@@ -0,0 +1,750 @@
+## Activation Parameters Architecture Refactoring Plan
+
+### Purpose
+
+Create a clean, extensible, and type‑safe activation parameters architecture for all supported protocols (UTXO, ZHTLC, ETH/ERC, Tendermint, etc.), with a unified approach to serialization, first‑class user configuration, persistence, and explicit state management for user interaction and timeouts.
+
+### Scope
+
+- No backward compatibility constraints. Design a clean architecture and migrate the SDK internals accordingly.
+- Follow OOP principles and the relevant design patterns (Strategy, Repository, State, Factory, Builder).
+- Follow BLoC naming conventions for any bloc code.
+- Use `freezed` for type‑safe configuration schemas, and the existing JSON utilities from `json_type_utils.dart` for parsing/serialization helpers.
+- Use `AssetId` in all public SDK APIs.
+
+## 1) Architecture Design
+
+### 1.1 Class Hierarchy (clean split of protocol concerns)
+
+- Activation parameters WILL be protocol‑specific. The base class must only contain protocol‑agnostic fields.
+  - Move ZHTLC‑specific fields out of the base class into `ZhtlcActivationParams`.
+  - Keep ETH/ERC specific serialization in its subclass.
+  - Keep UTXO extensions in its subclass.
+
+Proposed structure:
+
+```mermaid
+classDiagram
+  class RpcRequestParams { <<interface>> }
+  class ActivationParams {
+    +int? requiredConfirmations
+    +bool requiresNotarization
+    +PrivateKeyPolicy? privKeyPolicy
+    +int? minAddressesNumber
+    +ScanPolicy? scanPolicy
+    +int? gapLimit
+    +ActivationMode? mode
+    +JsonMap toRpcParams()
+  }
+
+  class UtxoActivationParams {
+    +bool? txHistory
+    +int? txVersion
+    +int? txFee
+    +int? dustAmount
+    +int? pubtype
+    +int? p2shtype
+    +int? wiftype
+    +int? overwintered
+    +override JsonMap toRpcParams()
+  }
+
+  class ZhtlcActivationParams {
+    +String? zcashParamsPath
+    +int? scanBlocksPerIteration
+    +int? scanIntervalMs
+    +override JsonMap toRpcParams()
+  }
+
+  class EthActivationParams {
+    +List<EthNode> nodes
+    +String swapContractAddress
+    +String? fallbackSwapContract
+    +List<Erc20TokenRequest> erc20Tokens
+    +bool? txHistory
+    +override JsonMap toRpcParams()
+  }
+
+  RpcRequestParams <|.. ActivationParams
+  ActivationParams <|-- UtxoActivationParams
+  ActivationParams <|-- ZhtlcActivationParams
+  ActivationParams <|-- EthActivationParams
+```
+
+Key rules:
+
+- Base `ActivationParams` contains only protocol‑agnostic fields.
+- Each subclass is solely responsible for its protocol‑specific fields and serialization.
+- `toRpcParams()` follows a consistent pattern: base JSON merged with subclass JSON using `deepMerge` (from `json_type_utils.dart`).
+
+### 1.2 Serialization Strategy (consistent approach)
+
+- Introduce a small utility to normalize private key policy serialization across protocols while respecting API expectations.
+- ETH/ERC requires JSON object form; other protocols use PascalCase enum string.
+
+```dart
+class PrivKeyPolicySerializer {
+  static dynamic toRpc(PrivateKeyPolicy policy, {required CoinSubClass protocol}) {
+    if (protocol == CoinSubClass.eth || protocol == CoinSubClass.erc20) {
+      return policy.toJson(); // object form
+    }
+    return policy.pascalCaseName; // legacy PascalCase string
+  }
+}
+```
+
+Usage pattern in `toRpcParams()`:
+
+- Base class sets all protocol‑agnostic fields EXCEPT `priv_key_policy`.
+- Subclasses set `priv_key_policy` via `PrivKeyPolicySerializer.toRpc(policy, protocol: ...)` and merge their own fields.
+
+This keeps the approach consistent while producing the protocol‑specific shape needed by the KDF API.
+
+### 1.3 User Configuration Framework
+
+Goals:
+
+- Users can pre‑configure activation options per `AssetId`.
+- If configuration exists, use automatically.
+- Otherwise, enter an explicit “awaiting user action” state with a 60s timeout, then fallback (defaults) or fail gracefully.
+
+Components:
+
+- Configuration models (freezed) per protocol
+- Repository abstraction for persistence
+- Service for orchestration (read‑or‑request‑then‑persist)
+- BLoC for state management and UI handoff (awaiting user input / timeout)
+
+```mermaid
+classDiagram
+  class ActivationConfigRepository { <<interface>>
+    +Future<TConfig?> getConfig<TConfig>(AssetId id)
+    +Future<void> saveConfig<TConfig>(AssetId id, TConfig config)
+  }
+
+  class KeyValueStore { <<interface>>
+    +Future<JsonMap?> get(String key)
+    +Future<void> set(String key, JsonMap value)
+  }
+
+  class ActivationConfigService {
+    +Future<TConfig?> getOrRequest<TConfig>(AssetId id, Duration timeout)
+  }
+
+  ActivationConfigRepository <|.. JsonActivationConfigRepository
+  JsonActivationConfigRepository --> KeyValueStore
+  ActivationConfigService --> ActivationConfigRepository
+```
+
+Example freezed config for ZHTLC:
+
+```dart
+@freezed
+class ZhtlcUserConfig with _$ZhtlcUserConfig {
+  const factory ZhtlcUserConfig({
+    required String zcashParamsPath,
+    @Default(1000) int scanBlocksPerIteration,
+    @Default(0) int scanIntervalMs,
+  }) = _ZhtlcUserConfig;
+
+  factory ZhtlcUserConfig.fromJson(Map<String, dynamic> json) => _$$ZhtlcUserConfigFromJson(json);
+}
+```
+
+Repository example (JSON‑backed):
+
+```dart
+class JsonActivationConfigRepository implements ActivationConfigRepository {
+  JsonActivationConfigRepository(this.store);
+  final KeyValueStore store;
+
+  String _key(AssetId id) => 'activation_config:${id.id}';
+
+  @override
+  Future<TConfig?> getConfig<TConfig>(AssetId id) async {
+    final data = await store.get(_key(id));
+    if (data == null) return null;
+    // Use a registry/mapper for different configs
+    return ActivationConfigMapper.decode<TConfig>(data);
+  }
+
+  @override
+  Future<void> saveConfig<TConfig>(AssetId id, TConfig config) async {
+    final json = ActivationConfigMapper.encode(config);
+    await store.set(_key(id), json);
+  }
+}
+```
+
+### 1.4 Persistence Layer Design
+
+- `KeyValueStore` abstraction for portability (Flutter, CLI, web):
+  - Default: in‑memory (SDK core dependency‑free)
+  - Optional adapters: `shared_preferences` (Flutter), `localstorage` (web), file‑based JSON (CLI)
+- `ActivationConfigRepository` uses `KeyValueStore` and a `ActivationConfigMapper` to encode/decode typed configs.
+- Stored shape is `JsonMap` compatible with `jsonEncode`/`jsonDecode`.
+
+### 1.5 State Management System
+
+- Introduce a dedicated BLoC to manage the read‑or‑request flow with timeout.
+- Naming follows BLoC conventions: Events end with `Event`, States end with `State`, Bloc ends with `Bloc`.
+
+States:
+
+- `ActivationConfigInitialState`
+- `ActivationConfigCheckingState`
+- `ActivationConfigAwaitingInputState` (includes `deadlineAt`, optional suggested defaults)
+- `ActivationConfigReadyState<TConfig>` (contains the resolved config)
+- `ActivationConfigTimeoutState`
+- `ActivationConfigFailureState`
+
+Events:
+
+- `ActivationConfigRequestedEvent(AssetId assetId)`
+- `ActivationConfigSubmittedEvent<TConfig>(TConfig config)`
+- `ActivationConfigCancelledEvent()`
+- `ActivationConfigTimeoutEvent()`
+
+Timeout policy:
+
+- Default 60 seconds. On timeout: if required fields missing, fail; otherwise use defaults.
+
+ActivationProgress integration (type‑safe):
+
+- Avoid using `additionalInfo` for control‑flow signals. Use typed fields or dedicated events/states.
+- When entering the awaiting state, emit a standard `ActivationProgress` message with `currentStep: ActivationStep.planning` for display, while the control signal is represented by the BLoC state `ActivationConfigAwaitingInputState`.
+
+### 1.6 Integration Points (SDK)
+
+- `KomodoDefiSdk` gains an `ActivationConfigService` dependency (optionally provided) used by activation strategies.
+- `ZhtlcActivationStrategy` reads persisted config or requests it before calling RPC `enable_zhtlc::init`.
+- `UtxoActivationStrategy`, `Eth*` strategies can opt‑in to the same pattern as needed.
+
+### 1.7 KDF API alignment: endpoints and JSON shapes
+
+The design must match the KDF API contract for activation tasks across protocols.
+
+- Common task flow per protocol:
+
+  - `task::enable_<protocol>::init` — starts activation with `{ ticker, activation_params }`
+  - `task::enable_<protocol>::status` — polls activation status with `{ task_id, forget_if_finished }`
+  - `task::enable_<protocol>::user_action` — optional, awaited user input (protocol‑specific)
+  - `task::enable_<protocol>::cancel` — optional, cancels activation task
+
+- Base request envelope includes `mmrpc: "2.0"`, `method`, and `params`.
+
+- Activation mode and rpc_data serialization:
+
+  - `mode.rpc` is one of `Electrum`, `Native`, `Light`.
+  - `mode.rpc_data` differs by mode:
+    - Electrum: `servers: [ActivationServer...]`
+    - Light (ZHTLC):
+      - `light_wallet_d_servers: [String]` (ZHTLC only)
+      - `electrum_servers: [ActivationServer...]` (note: key name differs from Electrum)
+      - `sync_params`: one of:
+        - `"earliest"`
+        - `{ "height": <int> }`
+        - `{ "date": <unix_timestamp> }`
+        - The SDK parser also supports legacy `<int>` and heuristics, but requests should use the documented shapes above.
+
+- Activation server shape (as produced by `ActivationServers.toJsonRequest()`):
+
+  - `{ "url": <string>, "ws_url": <string?>, "protocol": <string>, "disable_cert_verification": <bool> }`
+
+- ZHTLC init example (shape):
+
+```json
+{
+  "mmrpc": "2.0",
+  "method": "task::enable_z_coin::init",
+  "params": {
+    "ticker": "ZEC",
+    "activation_params": {
+      "required_confirmations": 1,
+      "requires_notarization": false,
+      "priv_key_policy": "ContextPrivKey",
+      "min_addresses_number": 20,
+      "scan_policy": "do_not_scan",
+      "gap_limit": 20,
+      "mode": {
+        "rpc": "Light",
+        "rpc_data": {
+          "light_wallet_d_servers": ["https://lightd.example"],
+          "electrum_servers": [
+            {
+              "url": "ssl://electrum.example:50002",
+              "protocol": "TCP",
+              "disable_cert_verification": false
+            }
+          ],
+          "sync_params": "earliest"
+        }
+      },
+      "zcash_params_path": "/path/to/zcash-params",
+      "scan_blocks_per_iteration": 1000,
+      "scan_interval_ms": 0
+    }
+  }
+}
+```
+
+- UTXO init example (shape):
+
+```json
+{
+  "mmrpc": "2.0",
+  "method": "task::enable_utxo::init",
+  "params": {
+    "ticker": "KMD",
+    "activation_params": {
+      "required_confirmations": 1,
+      "requires_notarization": false,
+      "priv_key_policy": "ContextPrivKey",
+      "mode": {
+        "rpc": "Electrum",
+        "rpc_data": {
+          "servers": [
+            {
+              "url": "ssl://electrum.kmd:50002",
+              "protocol": "TCP",
+              "disable_cert_verification": false
+            }
+          ]
+        }
+      },
+      "tx_history": true,
+      "txversion": 4,
+      "txfee": 1000,
+      "dust_amount": 1000,
+      "pubtype": 60,
+      "p2shtype": 85,
+      "wiftype": 188,
+      "overwintered": 1
+    }
+  }
+}
+```
+
+- ETH/ERC init example (shape):
+
+```json
+{
+  "mmrpc": "2.0",
+  "method": "task::enable_eth::init",
+  "params": {
+    "ticker": "ETH",
+    "activation_params": {
+      "required_confirmations": 1,
+      "requires_notarization": false,
+      "priv_key_policy": { "type": "ContextPrivKey" },
+      "nodes": [{ "url": "https://rpc.example", "chain_id": 1 }],
+      "swap_contract_address": "0x...",
+      "fallback_swap_contract": "0x...",
+      "erc20_tokens_requests": [{ "ticker": "USDC" }],
+      "tx_history": true
+    }
+  }
+}
+```
+
+- Status and user action endpoints (examples):
+  - `task::enable_z_coin::status`/`user_action`/`cancel` (ZHTLC)
+  - `task::enable_utxo::status` (UTXO)
+  - `task::enable_eth::status` (ETH/ERC)
+  - `task::enable_qtum::status`/`user_action` (QTUM)
+  - All status endpoints accept `{ "task_id": <int>, "forget_if_finished": <bool> }`.
+  - ZHTLC `user_action` accepts `{ "task_id": <int>, "action_type": <string>, "pin": <string?>, "passphrase": <string?> }`.
+
+## 2) Implementation Details
+
+### 2.1 Base and Subclass Edits
+
+Edits in `packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/activation_params.dart`:
+
+- Remove ZHTLC‑specific fields from base: `zcashParamsPath`, `scanBlocksPerIteration`, `scanIntervalMs`.
+- Ensure base `toRpcParams()` only includes protocol‑agnostic fields.
+
+Edits in `.../zhtlc_activation_params.dart`:
+
+- Keep ZHTLC‑specific fields and override `toRpcParams()` to add:
+  - `zcash_params_path`
+  - `scan_blocks_per_iteration`
+  - `scan_interval_ms`
+- Ensure `mode` is constructed with `ActivationModeType.lightWallet`.
+
+Edits in `.../utxo_activation_params.dart`:
+
+- No structural change required; already uses `deepMerge` properly.
+
+Edits in `.../eth_activation_params.dart`:
+
+- Keep override for `priv_key_policy` as JSON object.
+- Optionally route through `PrivKeyPolicySerializer` for consistency.
+
+PrivKey policy serialization utility:
+
+```dart
+extension ActivationParamsRpc on ActivationParams {
+  JsonMap toBaseRpc(Asset asset) {
+    final JsonMap base = {
+      if (requiredConfirmations != null) 'required_confirmations': requiredConfirmations,
+      'requires_notarization': requiresNotarization,
+      if (minAddressesNumber != null) 'min_addresses_number': minAddressesNumber,
+      if (scanPolicy != null) 'scan_policy': scanPolicy!.value,
+      if (gapLimit != null) 'gap_limit': gapLimit,
+      if (mode != null) 'mode': mode!.toJsonRequest(),
+    };
+    final protocol = asset.protocol.subClass; // CoinSubClass
+    return base.deepMerge({
+      'priv_key_policy': PrivKeyPolicySerializer.toRpc(
+        (privKeyPolicy ?? const PrivateKeyPolicy.contextPrivKey()),
+        protocol: protocol,
+      ),
+    });
+  }
+}
+```
+
+Then subclasses perform:
+
+```dart
+@override
+JsonMap toRpcParamsFor(Asset asset) => toBaseRpc(asset).deepMerge({
+  // protocol‑specific fields
+});
+```
+
+Note: If changing method signature is undesirable, keep `toRpcParams()` and pass required protocol context via constructor or a `withContext` builder that captures `Asset`.
+
+### 2.2 User Configuration (freezed types)
+
+ZHTLC config (required and optional fields):
+
+```dart
+@freezed
+class ZhtlcUserConfig with _$ZhtlcUserConfig {
+  const factory ZhtlcUserConfig({
+    required String zcashParamsPath,
+    @Default(1000) int scanBlocksPerIteration,
+    @Default(0) int scanIntervalMs,
+  }) = _ZhtlcUserConfig;
+
+  factory ZhtlcUserConfig.fromJson(JsonMap json) => _$$ZhtlcUserConfigFromJson(json);
+}
+```
+
+Mapper registry (simplified):
+
+```dart
+abstract class ActivationConfigMapper {
+  static JsonMap encode(Object config) {
+    if (config is ZhtlcUserConfig) return config.toJson();
+    throw UnsupportedError('Unsupported config type: ${config.runtimeType}');
+  }
+
+  static T decode<T>(JsonMap json) {
+    if (T == ZhtlcUserConfig) return ZhtlcUserConfig.fromJson(json) as T;
+    throw UnsupportedError('Unsupported type for decode: $T');
+  }
+}
+```
+
+Service orchestration (timeout handling):
+
+```dart
+class ActivationConfigService {
+  ActivationConfigService(this.repo);
+  final ActivationConfigRepository repo;
+
+  Future<ZhtlcUserConfig?> getZhtlcOrRequest(AssetId id, {Duration timeout = const Duration(seconds: 60)}) async {
+    final existing = await repo.getConfig<ZhtlcUserConfig>(id);
+    if (existing != null) return existing;
+
+    // Emit BLoC awaiting state externally; wait for submission or timeout
+    final completer = Completer<ZhtlcUserConfig?>();
+    _awaitingControllers[id] = completer;
+
+    try {
+      final result = await completer.future.timeout(timeout, onTimeout: () => null);
+      if (result == null) return null; // timeout: signal caller to fallback/fail
+      await repo.saveConfig(id, result);
+      return result;
+    } finally {
+      _awaitingControllers.remove(id);
+    }
+  }
+
+  // Called by UI when user submits config
+  void submitZhtlc(AssetId id, ZhtlcUserConfig config) {
+    _awaitingControllers[id]?.complete(config);
+  }
+
+  final Map<AssetId, Completer<ZhtlcUserConfig?>> _awaitingControllers = {};
+}
+```
+
+### 2.3 BLoC for User Configuration
+
+Events:
+
+```dart
+abstract class ActivationConfigEvent {}
+class ActivationConfigRequestedEvent extends ActivationConfigEvent {
+  ActivationConfigRequestedEvent(this.assetId);
+  final AssetId assetId;
+}
+class ActivationConfigSubmittedEvent<T> extends ActivationConfigEvent {
+  ActivationConfigSubmittedEvent(this.assetId, this.config);
+  final AssetId assetId; final T config;
+}
+class ActivationConfigTimeoutEvent extends ActivationConfigEvent {}
+class ActivationConfigCancelledEvent extends ActivationConfigEvent {}
+```
+
+States:
+
+```dart
+abstract class ActivationConfigState {}
+class ActivationConfigInitialState extends ActivationConfigState {}
+class ActivationConfigCheckingState extends ActivationConfigState {}
+class ActivationConfigAwaitingInputState extends ActivationConfigState {
+  ActivationConfigAwaitingInputState({required this.assetId, required this.deadlineAt, required this.requiredFields, this.defaults = const {}});
+  final AssetId assetId; final DateTime deadlineAt; final List<String> requiredFields; final JsonMap defaults;
+}
+class ActivationConfigReadyState<T> extends ActivationConfigState {
+  ActivationConfigReadyState(this.assetId, this.config);
+  final AssetId assetId; final T config;
+}
+class ActivationConfigTimeoutState extends ActivationConfigState {}
+class ActivationConfigFailureState extends ActivationConfigState { ActivationConfigFailureState(this.message); final String message; }
+```
+
+Bloc:
+
+```dart
+class ActivationConfigBloc extends Bloc<ActivationConfigEvent, ActivationConfigState> {
+  ActivationConfigBloc(this.service) : super(ActivationConfigInitialState()) {
+    on<ActivationConfigRequestedEvent>(_onRequested);
+    on<ActivationConfigSubmittedEvent>(_onSubmitted);
+    on<ActivationConfigTimeoutEvent>((_, emit) => emit(ActivationConfigTimeoutState()));
+    on<ActivationConfigCancelledEvent>((_, emit) => emit(ActivationConfigFailureState('Cancelled')));
+  }
+
+  final ActivationConfigService service;
+
+  Future<void> _onRequested(ActivationConfigRequestedEvent e, Emitter emit) async {
+    emit(ActivationConfigCheckingState());
+    // ZHTLC example; add branching by protocol if needed
+    final result = await service.getZhtlcOrRequest(e.assetId);
+    if (result == null) {
+      emit(ActivationConfigAwaitingInputState(
+        assetId: e.assetId,
+        deadlineAt: DateTime.now().add(const Duration(seconds: 60)),
+        requiredFields: const ['zcashParamsPath'],
+        defaults: {'scanBlocksPerIteration': 1000, 'scanIntervalMs': 0},
+      ));
+      return;
+    }
+    emit(ActivationConfigReadyState<ZhtlcUserConfig>(e.assetId, result));
+  }
+
+  Future<void> _onSubmitted(ActivationConfigSubmittedEvent e, Emitter emit) async {
+    if (e.config is ZhtlcUserConfig) {
+      service.submitZhtlc(e.assetId, e.config as ZhtlcUserConfig);
+      emit(ActivationConfigReadyState<ZhtlcUserConfig>(e.assetId, e.config as ZhtlcUserConfig));
+    } else {
+      emit(ActivationConfigFailureState('Unsupported config type'));
+    }
+  }
+}
+```
+
+### 2.4 Proper Use of JSON Utilities
+
+- Use `JsonMap` (`Map<String, dynamic>`) and `deepMerge` to compose RPC params.
+- Use `.value<T>()` / `.valueOrNull<T>()` for safe JSON extraction.
+- Use `jsonEncode/jsonDecode` helpers and `tryParseJson` when handling dynamic inputs.
+
+## 3) SDK Integration
+
+### 3.1 KomodoDefiSdk integration
+
+Add a configurable dependency for activation configuration:
+
+```dart
+class KomodoDefiSdk {
+  KomodoDefiSdk({required this.apiClient, ActivationConfigService? activationConfigService})
+    : activationConfigService = activationConfigService ?? ActivationConfigService(JsonActivationConfigRepository(InMemoryKeyValueStore()));
+
+  final ApiClient apiClient;
+  final ActivationConfigService activationConfigService;
+}
+```
+
+Pass the service down to activation strategies via the existing strategy factory.
+
+### 3.2 ZHTLC Strategy changes
+
+- Before constructing `ZhtlcActivationParams`, get the user config or request it.
+- On timeout, either:
+  - If `zcashParamsPath` is still missing, emit an error `ActivationProgress` and abort, or
+  - If only optional fields are missing, use defaults and proceed.
+
+Sketch:
+
+```dart
+final config = await sdk.activationConfigService.getZhtlcOrRequest(asset.id);
+if (config == null || config.zcashParamsPath.trim().isEmpty) {
+  yield ActivationProgress.error(message: 'Zcash params path required');
+  return;
+}
+
+final params = ZhtlcActivationParams.fromConfigJson(protocol.config).copyWith(
+  zcashParamsPath: config.zcashParamsPath,
+  scanBlocksPerIteration: config.scanBlocksPerIteration,
+  scanIntervalMs: config.scanIntervalMs,
+  privKeyPolicy: privKeyPolicy,
+);
+// Start the task and use the SDK's task shepherd to poll:
+final stream = client.rpc.zhtlc
+    .enableZhtlcInit(ticker: asset.id.id, params: params)
+    .watch<TaskStatusResponse>(
+      getTaskStatus: (taskId) => client.rpc.zhtlc.enableZhtlcStatus(
+        taskId,
+        forgetIfFinished: false,
+      ),
+      isTaskComplete: (s) => s.status == 'Ok' || s.status == 'Error',
+      cancelTask: (taskId) => client.rpc.zhtlc.enableZhtlcCancel(taskId: taskId),
+      pollingInterval: const Duration(milliseconds: 500),
+    );
+```
+
+### 3.3 AssetId extension for available user configurations
+
+Expose what configurable settings are available for a given asset/protocol for building UI. Do not depend on `additionalInfo` in `ActivationProgress` for this; use this typed API instead:
+
+```dart
+class ActivationSettingDescriptor {
+  ActivationSettingDescriptor({
+    required this.key,
+    required this.label,
+    required this.type, // 'path' | 'number' | 'string' | 'boolean' | 'select'
+    this.required = false,
+    this.defaultValue,
+    this.helpText,
+  });
+  final String key; final String label; final String type;
+  final bool required; final Object? defaultValue; final String? helpText;
+}
+
+extension AssetIdActivationSettings on AssetId {
+  List<ActivationSettingDescriptor> activationSettings() {
+    switch (protocolSubClass) { // implement based on your AssetId
+      case CoinSubClass.zhtlc:
+        return [
+          ActivationSettingDescriptor(
+            key: 'zcashParamsPath',
+            label: 'Zcash parameters path',
+            type: 'path',
+            required: true,
+            helpText: 'Folder containing Zcash parameters',
+          ),
+          ActivationSettingDescriptor(
+            key: 'scanBlocksPerIteration',
+            label: 'Blocks per scan iteration',
+            type: 'number',
+            defaultValue: 1000,
+          ),
+          ActivationSettingDescriptor(
+            key: 'scanIntervalMs',
+            label: 'Scan interval (ms)',
+            type: 'number',
+            defaultValue: 0,
+          ),
+        ];
+      default:
+        return const [];
+    }
+  }
+}
+```
+
+### 3.4 Example usage
+
+```dart
+final sdk = KomodoDefiSdk(apiClient: apiClient);
+
+// UI listens to a typed BLoC for control flow (awaiting input),
+// and separately renders ActivationProgress for user‑visible status.
+
+activationConfigBloc.add(ActivationConfigRequestedEvent(assetId));
+
+final sub = activationConfigBloc.stream.listen((state) {
+  if (state is ActivationConfigAwaitingInputState) {
+    // Present typed form derived from AssetId.activationSettings()
+    // On submit:
+    activationConfigBloc.add(
+      ActivationConfigSubmittedEvent(assetId, zhtlcConfig),
+    );
+  }
+});
+
+await for (final progress in sdk.activate(assetId)) {
+  // Render progress.userMessage and progress.progressDetails
+}
+```
+
+## 4) Migration Strategy (no backward compatibility required)
+
+Order of work:
+
+1. Introduce new user configuration types and persistence
+   - Add `ZhtlcUserConfig` (freezed) and repository/service skeletons
+   - Add `KeyValueStore` interface and in‑memory default
+2. Extract ZHTLC fields from base `ActivationParams`
+   - Remove `zcashParamsPath`, `scanBlocksPerIteration`, `scanIntervalMs` from base
+   - Ensure `ZhtlcActivationParams` owns and serializes these
+3. Normalize serialization approach
+   - Add `PrivKeyPolicySerializer`
+   - Route ETH/ERC and others accordingly
+4. Wire SDK integration
+   - Extend `KomodoDefiSdk` with `ActivationConfigService`
+   - Update `ZhtlcActivationStrategy` to request config before activation
+5. Add `AssetId.activationSettings()` extension
+6. Implement BLoC for configuration flow (optional for SDK core, shipped in `komodo_ui` or example app)
+7. Update and/or add tests
+   - Unit tests for mappers, repository, serializer, and `toRpcParams()` across protocols
+   - Strategy integration test for ZHTLC with and without pre‑saved config; timeout path
+8. Documentation and examples
+   - Document new APIs and include example usage
+9. Remove dead/legacy code paths from base class
+
+Suggested Conventional Commits sequence:
+
+- feat(core): add activation config repository and in‑memory store [[freezed models]]
+- refactor(rpc): move ZHTLC fields from ActivationParams into ZhtlcActivationParams
+- feat(rpc): add PrivKeyPolicySerializer and unify serialization usage
+- feat(sdk): integrate ActivationConfigService into KomodoDefiSdk and ZHTLC strategy
+- feat(types): add AssetId.activationSettings() extension
+- test(core): add unit tests for repo/mapper/serializer and protocol params
+- docs: add activation parameters architecture and usage examples
+
+## 5) Risks and Mitigations
+
+- Risk: ETH/ERC serialization divergence. Mitigation: centralize via `PrivKeyPolicySerializer` and test per protocol.
+- Risk: Platform persistence. Mitigation: keep `KeyValueStore` abstract; provide adapters outside core.
+- Risk: User flow complexity. Mitigation: explicit BLoC states (typed control) and `ActivationProgress` (display only); documented timeout/default behavior.
+- Risk: Mode/rpc_data mismatch. Mitigation: enforce `ActivationMode.toJsonRequest()` rules:
+  - Electrum uses `servers`, Light uses `electrum_servers` and optional `light_wallet_d_servers` and `sync_params`.
+  - Tests assert exact key names per mode.
+
+## 6) Acceptance Criteria
+
+- Base `ActivationParams` has no ZHTLC‑specific fields.
+- All subclasses merge their RPC params via `deepMerge` and follow the same serialization approach.
+- ZHTLC requires user config for `zcashParamsPath`; optional fields default as specified.
+- User configuration is persisted and reused on subsequent activations.
+- Missing config triggers an “awaiting user action” state with a 60s timeout.
+- Integration demonstrates `KomodoDefiSdk` + `AssetId.activationSettings()` and typed BLoC usage (no reliance on `additionalInfo` for control logic).
+- `mode.rpc_data` uses `servers` for Electrum and `electrum_servers` for Light; includes `light_wallet_d_servers` and `sync_params` for ZHTLC where applicable.
+- All activation `init` requests use `{ ticker, activation_params }` and match the KDF API shapes above.
diff --git a/docs/firebase/firebase-deployment-setup.md b/docs/firebase/firebase-deployment-setup.md
new file mode 100644
index 000000000..88e2549b0
--- /dev/null
+++ b/docs/firebase/firebase-deployment-setup.md
@@ -0,0 +1,232 @@
+# Firebase GitHub Secrets Setup
+
+This document provides instructions for setting up Firebase GitHub secrets using the automated scripts or manual process.
+
+## Overview
+
+The Komodo DeFi SDK Flutter project uses Firebase Hosting for deploying two web applications:
+
+1. **SDK Example** - Deployed to `komodo-defi-sdk` Firebase project
+2. **Playground** - Deployed to `komodo-playground` Firebase project
+
+GitHub Actions workflows require service account credentials to deploy to these Firebase projects.
+
+## Prerequisites
+
+### Required Tools
+
+- **Google Cloud SDK (gcloud)** - [Installation Guide](https://cloud.google.com/sdk/docs/install)
+- **GitHub CLI (gh)** - [Installation Guide](https://cli.github.com/manual/installation)
+- **jq** (for verification script) - JSON processor
+
+### Required Access
+
+- Admin access to both Firebase projects:
+  - `komodo-defi-sdk`
+  - `komodo-playground`
+- Write access to the GitHub repository secrets
+
+## Automated Setup
+
+We provide scripts to automate the entire setup process:
+
+### 1. Setup Script
+
+Run the setup script to create service accounts and configure GitHub secrets:
+
+```bash
+./.github/scripts/firebase/setup-github-secrets.sh
+```
+
+This script will:
+
+- Check all prerequisites
+- Create service accounts (if they don't exist)
+- Grant necessary IAM permissions
+- Generate service account keys
+- Create/update GitHub repository secrets
+- Clean up sensitive key files
+
+### 2. Verification Script
+
+Verify your setup is correct:
+
+```bash
+./.github/scripts/firebase/verify-github-secrets.sh
+```
+
+This script will check:
+
+- Tool installations
+- Authentication status
+- Service account existence
+- IAM permissions
+- GitHub secrets existence
+
+## Manual Setup
+
+If you prefer to set up manually or need to troubleshoot:
+
+### Step 1: Authenticate with Google Cloud
+
+```bash
+gcloud auth login
+gcloud auth application-default login
+```
+
+### Step 2: Create Service Accounts
+
+For komodo-defi-sdk:
+
+```bash
+gcloud config set project komodo-defi-sdk
+gcloud iam service-accounts create github-actions-deploy \
+    --display-name="GitHub Actions Deploy" \
+    --description="Service account for GitHub Actions Firebase deployments"
+```
+
+For komodo-playground:
+
+```bash
+gcloud config set project komodo-playground
+gcloud iam service-accounts create github-actions-deploy \
+    --display-name="GitHub Actions Deploy" \
+    --description="Service account for GitHub Actions Firebase deployments"
+```
+
+### Step 3: Grant Permissions
+
+For each project, grant the required roles:
+
+```bash
+# Set project (komodo-defi-sdk or komodo-playground)
+PROJECT_ID="komodo-defi-sdk"  # or "komodo-playground"
+SERVICE_ACCOUNT_EMAIL="github-actions-deploy@${PROJECT_ID}.iam.gserviceaccount.com"
+
+# Grant roles
+gcloud projects add-iam-policy-binding ${PROJECT_ID} \
+    --member="serviceAccount:${SERVICE_ACCOUNT_EMAIL}" \
+    --role="roles/firebase.hosting.admin"
+
+gcloud projects add-iam-policy-binding ${PROJECT_ID} \
+    --member="serviceAccount:${SERVICE_ACCOUNT_EMAIL}" \
+    --role="roles/firebase.rules.admin"
+
+gcloud projects add-iam-policy-binding ${PROJECT_ID} \
+    --member="serviceAccount:${SERVICE_ACCOUNT_EMAIL}" \
+    --role="roles/iam.serviceAccountTokenCreator"
+```
+
+### Step 4: Generate Service Account Keys
+
+For komodo-defi-sdk:
+
+```bash
+gcloud iam service-accounts keys create komodo-defi-sdk-key.json \
+    --iam-account="github-actions-deploy@komodo-defi-sdk.iam.gserviceaccount.com" \
+    --project="komodo-defi-sdk"
+```
+
+For komodo-playground:
+
+```bash
+gcloud iam service-accounts keys create komodo-playground-key.json \
+    --iam-account="github-actions-deploy@komodo-playground.iam.gserviceaccount.com" \
+    --project="komodo-playground"
+```
+
+### Step 5: Create GitHub Secrets
+
+```bash
+# Authenticate with GitHub CLI
+gh auth login
+
+# Create secrets
+gh secret set FIREBASE_SERVICE_ACCOUNT_KOMODO_DEFI_SDK \
+    < komodo-defi-sdk-key.json \
+    --repo KomodoPlatform/komodo-defi-sdk-flutter
+
+gh secret set FIREBASE_SERVICE_ACCOUNT_KOMODO_PLAYGROUND \
+    < komodo-playground-key.json \
+    --repo KomodoPlatform/komodo-defi-sdk-flutter
+```
+
+### Step 6: Clean Up Key Files
+
+⚠️ **IMPORTANT**: Delete the key files after creating GitHub secrets:
+
+```bash
+rm -f komodo-defi-sdk-key.json
+rm -f komodo-playground-key.json
+```
+
+## Testing the Setup
+
+After setting up the secrets, you can test the deployment:
+
+1. **Create a Pull Request** - This triggers the PR preview workflow
+2. **Push to `dev` branch** - This triggers the merge deployment workflow
+
+Check the GitHub Actions tab in the repository to monitor the deployment status.
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Authentication Errors**
+
+   - Ensure you're logged in: `gcloud auth login` and `gh auth login`
+   - Check you have the correct permissions in both Google Cloud and GitHub
+
+2. **Service Account Permission Errors**
+
+   - Verify all three required roles are granted
+   - Wait a few minutes for IAM changes to propagate
+
+3. **GitHub Secret Errors**
+   - Ensure the entire JSON key file content is copied
+   - Check for any extra whitespace or formatting issues
+
+### Debugging Commands
+
+Check current gcloud configuration:
+
+```bash
+gcloud config list
+gcloud auth list
+```
+
+List service accounts:
+
+```bash
+gcloud iam service-accounts list --project=komodo-defi-sdk
+gcloud iam service-accounts list --project=komodo-playground
+```
+
+Check IAM bindings:
+
+```bash
+gcloud projects get-iam-policy komodo-defi-sdk
+gcloud projects get-iam-policy komodo-playground
+```
+
+List GitHub secrets:
+
+```bash
+gh secret list --repo KomodoPlatform/komodo-defi-sdk-flutter
+```
+
+## Security Best Practices
+
+1. **Never commit service account keys** to the repository
+2. **Delete local key files** immediately after use
+3. **Rotate keys periodically** for security
+4. **Use least privilege** - only grant necessary permissions
+5. **Monitor usage** through Google Cloud Console
+
+## Additional Resources
+
+- [Firebase Admin SDK Service Accounts](https://firebase.google.com/docs/admin/setup#initialize-sdk)
+- [GitHub Encrypted Secrets](https://docs.github.com/en/actions/security-guides/encrypted-secrets)
+- [Google Cloud IAM Documentation](https://cloud.google.com/iam/docs)
+- [Firebase Hosting GitHub Action](https://github.com/FirebaseExtended/action-hosting-deploy)
diff --git a/docs/tech_debt/Activation_and_ZHTLC_Tech_Debt.md b/docs/tech_debt/Activation_and_ZHTLC_Tech_Debt.md
new file mode 100644
index 000000000..65027d3e3
--- /dev/null
+++ b/docs/tech_debt/Activation_and_ZHTLC_Tech_Debt.md
@@ -0,0 +1,119 @@
+## Tech Debt Report: Activation and ZHTLC
+
+### Context and scope
+
+- New components introduced: `ActivationConfigService`, `HiveActivationConfigRepository`, `ZhtlcActivationStrategy`, `SharedActivationCoordinator`, wiring in `bootstrap.dart`, UI prompts in example.
+- Primary concerns: activation orchestration, ZHTLC activation/config, persistence, concurrency, and UI flow.
+
+### Design pattern alignment (good)
+
+- Strategy: protocol-specific activation strategies (e.g., `ZhtlcActivationStrategy`) selected via `ActivationStrategyFactory`.
+- Factory: `ActivationStrategyFactory` composes per-protocol activators.
+- Repository: `ActivationConfigRepository` and `HiveActivationConfigRepository`.
+- Mediator/Coordinator: `SharedActivationCoordinator` synchronizes activation across managers.
+- Observer: activation progress streams, failed/pending streams.
+- Mutex: `ActivationManager`’s `Mutex` for critical sections.
+
+### Tech-debt inventory
+
+- Architecture and flow
+
+  - Primary/child grouping bug in `ActivationManager`
+
+    - Risk: child asset may be treated as group primary, confusing strategy selection and completion bookkeeping.
+    - Reference: `packages/komodo_defi_sdk/lib/src/activation/activation_manager.dart` (`_groupByPrimary`).
+    - Refactoring: Ensure true primary resolution for group key and members.
+
+  - Duplication of activation orchestration
+
+    - Both `ActivationManager` and `SharedActivationCoordinator` track activation state and deduplication.
+    - Refactoring: Make Coordinator the single entrypoint (Facade); slim `ActivationManager` to strategy runner.
+
+  - Flutter-only dependency in SDK bootstrap
+    - `Hive.initFlutter()` in SDK couples core to Flutter.
+    - Refactoring: Inject `ActivationConfigRepository` via DI; provide Flutter Hive impl at app layer.
+
+- API/serialization consistency
+
+  - `priv_key_policy` serialization not centralized
+
+    - Base emits PascalCase string; EVM needs JSON object.
+    - Refactoring: Use `PrivKeyPolicySerializer` consistently in base or subclasses; add tests.
+
+  - ZHTLC parameter extraction
+    - `ZhtlcActivationParams` correctly owns `zcash_params_path` and scan tuning (good).
+
+- Config, persistence, and UI flow
+
+  - Service/UI coupling without a formal BLoC
+
+    - Example pre-prompts and saves config; strategy also awaits service completer.
+    - Refactoring: Introduce `ActivationConfigBloc`; UI uses descriptors; strategies pull via service only.
+
+  - Activation settings descriptors unused in UI
+
+    - Add dynamic form generation using `AssetId.activationSettings()`.
+
+  - Repository granularity
+
+    - Single map per wallet entry can cause coarse updates.
+    - Consider per-asset keys or transactional update helper.
+
+  - Zcash params path UX
+    - Provide platform helpers or discovery to reduce user friction.
+
+- Concurrency and timing
+
+  - Coin availability backoff short and hard-coded
+
+    - Make policy configurable; add metrics.
+
+  - No public cancellation API
+    - Add `cancelActivation(assetId)` on Coordinator; propagate.
+
+- Naming and API
+
+  - Legacy RPC method name for ZHTLC is acceptable but document it clearly.
+
+- Code quality
+  - `ActivationProgressDetails.toJson` optional-field serialization bug; fix with conditional inserts.
+  - Outdated TODO in `ZhtlcActivationStrategy` re: sync mode; update.
+
+### Recommendations
+
+- Unify activation orchestration in `SharedActivationCoordinator`; treat it as Facade/Mediator.
+- Fix `_groupByPrimary` to always use true primary; add tests.
+- Normalize `priv_key_policy` serialization using `PrivKeyPolicySerializer`; add per-protocol tests.
+- Decouple persistence from SDK; inject `ActivationConfigRepository` and remove direct `Hive.initFlutter()` from core.
+- Implement `ActivationConfigBloc` and adopt `ActivationSettingDescriptor` in UI.
+- Expose `cancelActivation(assetId)` and configurable coin-availability wait.
+- Add unit/integration tests and structured logs around activation timing.
+
+### Prioritized action plan
+
+1. Correctness: fix `toJson`, fix grouping, update ZHTLC TODO.
+2. Architecture: coordinator as single entrypoint; cancellation + wait policy.
+3. Serialization: apply serializer; tests.
+4. Config/Persistence: BLoC + descriptors; DI for repository.
+5. Tests/Docs: coverage + documentation.
+
+### Suggested conventional commits
+
+- fix(types): correct ActivationProgressDetails.toJson optional fields
+- fix(activation): ensure \_groupByPrimary uses true primary asset
+- refactor(activation): centralize orchestration in SharedActivationCoordinator
+- feat(activation): add cancelActivation and configurable availability wait
+- refactor(rpc): use PrivKeyPolicySerializer across protocols; add tests
+- feat(config): add ActivationConfigBloc and adopt ActivationSettingDescriptor in example UI
+- refactor(sdk): inject ActivationConfigRepository via bootstrap; remove direct Hive.initFlutter dependency
+- docs: update ZHTLC activation docs and RPC naming notes
+- test(activation): add ZHTLC activation flow tests
+
+### Acceptance criteria
+
+- Single activation Facade with deduplication and coin-availability guard.
+- Correct grouping semantics; passing tests.
+- Consistent `priv_key_policy` serialization per protocol; tests pass.
+- ZHTLC config via BLoC; UI built from descriptors.
+- SDK no longer depends on Flutter for persistence wiring.
+- Cancellation and availability wait are configurable and documented.
diff --git a/docs/tech_debt/PR227_ZHTLC_Tech_Debt.md b/docs/tech_debt/PR227_ZHTLC_Tech_Debt.md
new file mode 100644
index 000000000..02e898bc4
--- /dev/null
+++ b/docs/tech_debt/PR227_ZHTLC_Tech_Debt.md
@@ -0,0 +1,139 @@
+# Tech Debt: PR #227 – ZHTLC Activation Fixes
+
+Date: 2025-10-02  
+PR: https://github.com/KomodoPlatform/komodo-defi-sdk-flutter/pull/227  
+Head commit: 1af4278
+
+This document compiles AI review findings into actionable tech-debt items with severity, impact, and recommended fixes. Items are grouped by concern.
+
+## Build/Web-Safety
+
+- [CRITICAL] Remove `dart:io` and `Platform.*` usage in web-visible factory
+  - Files: `packages/komodo_defi_sdk/lib/src/zcash_params/zcash_params_downloader_factory.dart` (import at top, branches at ~49–71, ~121–130)
+  - Problem: Unconditional `import 'dart:io';` and `Platform.*` branching break web/wasm builds.
+  - Impact: Web builds fail at compile time.
+  - Fix:
+    - Replace `dart:io` import with `package:flutter/foundation.dart`.
+    - Use `kIsWeb` and `defaultTargetPlatform`/`TargetPlatform` for branching.
+    - Ensure `detectPlatform()` is web-safe and does not reference `Platform.*`.
+    - If a dedicated `WebZcashParamsDownloader` exists, prefer it on `kIsWeb`.
+    - Example branching:
+      ```dart
+      import 'package:flutter/foundation.dart';
+      // ...
+      if (kIsWeb) {
+        return WebZcashParamsDownloader(/* ... */);
+      }
+      final platform = defaultTargetPlatform;
+      if (platform == TargetPlatform.windows) { /* windows */ }
+      else if (platform == TargetPlatform.iOS || platform == TargetPlatform.android) { /* mobile */ }
+      else { /* unix-like (macOS, linux, fuchsia) */ }
+      ```
+
+## Mobile Storage Policy
+
+- [MAJOR] Store Zcash params under Application Support, not Documents
+  - File: `packages/komodo_defi_sdk/lib/src/zcash_params/platforms/mobile_zcash_params_downloader.dart` (header comment ~14–20; path resolution ~120–131)
+  - Problem: Using Documents risks iCloud/backup violations on iOS and exposes internal assets to users.
+  - Impact: Policy violations, user-visible clutter.
+  - Fix:
+    - Update comments to reference Application Support.
+    - Use `getApplicationSupportDirectory()` and join `ZcashParams`.
+    - Ensure directory exists before use (create recursively if missing).
+    - Example:
+      ```dart
+      final supportDir = await getApplicationSupportDirectory();
+      final paramsDir = Directory(path.join(supportDir.path, 'ZcashParams'));
+      if (!(await paramsDir.exists())) {
+        await paramsDir.create(recursive: true);
+      }
+      return paramsDir.path;
+      ```
+
+## Networking/Resilience
+
+- [MAJOR] Add timeout to remote HEAD probe to prevent hangs
+  - File: `packages/komodo_defi_sdk/lib/src/zcash_params/services/zcash_params_download_service.dart` (~311–319)
+  - Problem: `_httpClient.head` is awaited without a timeout; if the server stalls, activation hangs.
+  - Impact: Stalled activation; poor UX.
+  - Fix:
+    - Wrap in `.timeout(...)`; reuse `config.downloadTimeout` if available; otherwise a bounded default.
+    - Catch `TimeoutException`, log at least at `fine`/`warning`, and return `null` for size.
+    - Example:
+      ```dart
+      try {
+        final response = await _httpClient
+            .head(Uri.parse(url))
+            .timeout(config.downloadTimeout);
+        // ... handle 200 + content-length ...
+      } on TimeoutException {
+        _logger.warning('HEAD timeout for $url');
+        return null;
+      }
+      ```
+
+## Null-Safety/Defensive Coding
+
+- [CRITICAL] Guard nullable `zcashParamsPath` before `.trim()`
+  - File: `packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/zhtlc_activation_strategy.dart` (~55–85)
+  - Problem: `userConfig.zcashParamsPath.trim()` dereferences nullable; throws before friendly progress is emitted.
+  - Impact: Activation crashes instead of returning error progress.
+  - Fix:
+    - Sanitize into a local: `final zcashParamsPath = userConfig?.zcashParamsPath?.trim();`
+    - If null/empty: yield error `ActivationProgress` with `ActivationStep.error` and return.
+    - Pass the sanitized `zcashParamsPath` into `params.copyWith(...)`.
+
+## URL Handling
+
+- [MAJOR] Percent-encode file URLs; fix test expectations
+  - Files:
+    - `packages/komodo_defi_sdk/lib/src/zcash_params/models/zcash_params_config.dart` (method building URLs ~152–159)
+    - `packages/komodo_defi_sdk/test/zcash_params/models/zcash_params_config_test.dart` (URL with spaces ~497–503)
+  - Problem: URLs with spaces are not encoded; test expects unencoded URL.
+  - Impact: Invalid URLs and brittle tests.
+  - Fix:
+    - Build with `Uri.parse(baseUrl).resolve(fileName).toString()`.
+    - Update tests to expect `%20`-encoded spaces.
+
+## Tests/Determinism
+
+- [MAJOR] Avoid host-dependent APPDATA assumptions in Windows downloader tests
+  - File: `packages/komodo_defi_sdk/test/zcash_params/platforms/windows_zcash_params_downloader_test.dart` (~47–57, also ~60–80)
+  - Problem: Tests assume `APPDATA` missing; on Windows CI this becomes flaky/non-deterministic.
+  - Impact: Intermittent CI failures.
+  - Fix:
+    - Inject an `environmentProvider` into `WindowsZcashParamsDownloader` (e.g., `Map<String, String> Function()`).
+    - Stub in tests with/without `APPDATA` to assert behavior deterministically.
+
+- [MAJOR] Fix invalid string multiplication in Dart test
+  - File: `packages/komodo_defi_sdk/test/zcash_params/models/zcash_params_config_test.dart` (~491–495)
+  - Problem: Uses Python-style `'string' * 10`; invalid in Dart.
+  - Impact: Test compilation error.
+  - Fix:
+    - Construct repeated string via `List.filled(10, 'very-long-file-name').join() + '.params'` (or similar).
+
+## Nice-to-Have Enhancements
+
+- [MINOR] Logging for timeouts and failures in size probe
+  - Context: Same HEAD probe fix above.
+  - Suggestion: Log at `warning` on timeout/network errors to aid telemetry.
+
+- [MINOR] Ensure directory creation in mobile path getter
+  - Context: Same mobile support path fix above.
+  - Suggestion: Create the `ZcashParams` directory if missing before returning.
+
+---
+
+## Checklist (proposed follow-up PR)
+
+- [ ] Factory: remove `dart:io` import; use `kIsWeb`/`defaultTargetPlatform` in all branches
+- [ ] Factory: web branch returns `WebZcashParamsDownloader` (or define it if missing)
+- [ ] Factory: `detectPlatform()` made web-safe (no `Platform.*`)
+- [ ] Mobile downloader: switch to Application Support; ensure dir exists
+- [ ] Download service: add timeout + handling to HEAD probe
+- [ ] ZHTLC strategy: null-safe trim and sanitized injection of `zcashParamsPath`
+- [ ] URL builder: use `Uri.resolve`; update tests to expect encoded URL
+- [ ] Windows tests: inject env provider and stub `APPDATA`
+- [ ] Dart test: replace string multiplication with `List.filled(...).join()`
+
+Notes: Severity reflects build-breakers (critical), runtime bugs (major), and smaller quality improvements (minor).
\ No newline at end of file
diff --git a/packages/dragon_charts_flutter/.gitignore b/packages/dragon_charts_flutter/.gitignore
index ac5aa9893..6be69aeb4 100644
--- a/packages/dragon_charts_flutter/.gitignore
+++ b/packages/dragon_charts_flutter/.gitignore
@@ -1,29 +1,8 @@
-# Miscellaneous
-*.class
-*.log
-*.pyc
-*.swp
-.DS_Store
-.atom/
-.buildlog/
-.history
-.svn/
-migrate_working_dir/
+# See https://www.dartlang.org/guides/libraries/private-files
 
-# IntelliJ related
-*.iml
-*.ipr
-*.iws
-.idea/
-
-# The .vscode folder contains launch configuration and tasks you configure in
-# VS Code which you may wish to be included in version control, so this line
-# is commented out by default.
-#.vscode/
-
-# Flutter/Dart/Pub related
-# Libraries should not include pubspec.lock, per https://dart.dev/guides/libraries/private-files#pubspeclock.
-/pubspec.lock
-**/doc/api/
+# Files and directories created by pub
 .dart_tool/
+.packages
 build/
+/web/
+pubspec.lock
\ No newline at end of file
diff --git a/packages/dragon_logs/.gitignore b/packages/dragon_logs/.gitignore
index fcceabeb1..6be69aeb4 100644
--- a/packages/dragon_logs/.gitignore
+++ b/packages/dragon_logs/.gitignore
@@ -1,62 +1,8 @@
-# Miscellaneous
-*.class
-*.log
-*.pyc
-*.swp
-.DS_Store
-.atom/
-.idea/
-.vscode/
-*.iml
+# See https://www.dartlang.org/guides/libraries/private-files
 
-# Android related
-**/android/app/build/
-**/android/.gradle/
-**/android/captures/
-**/android/gradle-wrapper.jar
-**/android/local.properties
-**/android/.idea/
-**/android/.directory
-**/android/*/src/main/res/mipmap-*/.DS_Store
-**/android/*/src/main/res/drawable-*/.DS_Store
-**/android/*/src/main/res/drawable-*/.DS_Store
-**/android/*/src/main/res/raw/.DS_Store
-
-# iOS related
-**/ios/.generated/
-**/ios/.idea/
-**/ios/.vagrant/
-**/ios/.sconsign.dblite
-**/ios/.svn/
-**/ios/*xcuserdata
-**/ios/*.moved-aside
-**/ios/*.pbxuser
-**/ios/*.mode1v3
-**/ios/*.mode2v3
-**/ios/*.perspectivev3
-**/ios/Podfile.lock
-**/ios/Pods/
-**/ios/.*.sw?
-**/ios/*.bak
-**/ios/*~
-**/ios/.lock-wscript
-**/ios/Build/
-**/ios/DerivedData/
-**/ios/.DS_Store
-
-# Flutter/Dart related
+# Files and directories created by pub
 .dart_tool/
 .packages
-.pub/
-.pub-cache/
 build/
-**/doc/api/
-.flutter-plugins
-.flutter-plugins-dependencies
-flutter_export_environment.sh
-#Not required for packages
-/pubspec.lock
-
-# Exceptions to above rules.
-!**/ios/**/default.profraw
-
+/web/
+pubspec.lock
\ No newline at end of file
diff --git a/packages/dragon_logs/example/.gitignore b/packages/dragon_logs/example/.gitignore
index 24476c5d1..0ef32f8a6 100644
--- a/packages/dragon_logs/example/.gitignore
+++ b/packages/dragon_logs/example/.gitignore
@@ -31,6 +31,10 @@ migrate_working_dir/
 .pub-cache/
 .pub/
 /build/
+pubspec.lock
+
+# Web related
+lib/generated_plugin_registrant.dart
 
 # Symbolication related
 app.*.symbols
@@ -38,6 +42,9 @@ app.*.symbols
 # Obfuscation related
 app.*.map.json
 
+# Test related
+coverage
+
 # Android Studio will place build artifacts here
 /android/app/debug
 /android/app/profile
diff --git a/packages/dragon_logs/web/favicon.png b/packages/dragon_logs/web/favicon.png
deleted file mode 100644
index 8aaa46ac1..000000000
Binary files a/packages/dragon_logs/web/favicon.png and /dev/null differ
diff --git a/packages/dragon_logs/web/icons/Icon-192.png b/packages/dragon_logs/web/icons/Icon-192.png
deleted file mode 100644
index b749bfef0..000000000
Binary files a/packages/dragon_logs/web/icons/Icon-192.png and /dev/null differ
diff --git a/packages/dragon_logs/web/icons/Icon-512.png b/packages/dragon_logs/web/icons/Icon-512.png
deleted file mode 100644
index 88cfd48df..000000000
Binary files a/packages/dragon_logs/web/icons/Icon-512.png and /dev/null differ
diff --git a/packages/dragon_logs/web/icons/Icon-maskable-192.png b/packages/dragon_logs/web/icons/Icon-maskable-192.png
deleted file mode 100644
index eb9b4d76e..000000000
Binary files a/packages/dragon_logs/web/icons/Icon-maskable-192.png and /dev/null differ
diff --git a/packages/dragon_logs/web/icons/Icon-maskable-512.png b/packages/dragon_logs/web/icons/Icon-maskable-512.png
deleted file mode 100644
index d69c56691..000000000
Binary files a/packages/dragon_logs/web/icons/Icon-maskable-512.png and /dev/null differ
diff --git a/packages/dragon_logs/web/index.html b/packages/dragon_logs/web/index.html
deleted file mode 100644
index e4347359b..000000000
--- a/packages/dragon_logs/web/index.html
+++ /dev/null
@@ -1,59 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <!--
-    If you are serving your web app in a path other than the root, change the
-    href value below to reflect the base path you are serving from.
-
-    The path provided below has to start and end with a slash "/" in order for
-    it to work correctly.
-
-    For more details:
-    * https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base
-
-    This is a placeholder for base href that will be replaced by the value of
-    the `--base-href` argument provided to `flutter build`.
-  -->
-  <base href="$FLUTTER_BASE_HREF">
-
-  <meta charset="UTF-8">
-  <meta content="IE=Edge" http-equiv="X-UA-Compatible">
-  <meta name="description" content="A new Flutter project.">
-
-  <!-- iOS meta tags & icons -->
-  <meta name="apple-mobile-web-app-capable" content="yes">
-  <meta name="apple-mobile-web-app-status-bar-style" content="black">
-  <meta name="apple-mobile-web-app-title" content="dragon_logs">
-  <link rel="apple-touch-icon" href="icons/Icon-192.png">
-
-  <!-- Favicon -->
-  <link rel="icon" type="image/png" href="favicon.png"/>
-
-  <title>dragon_logs</title>
-  <link rel="manifest" href="manifest.json">
-
-  <script>
-    // The value below is injected by flutter build, do not touch.
-    const serviceWorkerVersion = null;
-  </script>
-  <!-- This script adds the flutter initialization JS code -->
-  <script src="flutter.js" defer></script>
-</head>
-<body>
-  <script>
-    window.addEventListener('load', function(ev) {
-      // Download main.dart.js
-      _flutter.loader.loadEntrypoint({
-        serviceWorker: {
-          serviceWorkerVersion: serviceWorkerVersion,
-        },
-        onEntrypointLoaded: function(engineInitializer) {
-          engineInitializer.initializeEngine().then(function(appRunner) {
-            appRunner.runApp();
-          });
-        }
-      });
-    });
-  </script>
-</body>
-</html>
diff --git a/packages/dragon_logs/web/manifest.json b/packages/dragon_logs/web/manifest.json
deleted file mode 100644
index bc508a575..000000000
--- a/packages/dragon_logs/web/manifest.json
+++ /dev/null
@@ -1,35 +0,0 @@
-{
-    "name": "dragon_logs",
-    "short_name": "dragon_logs",
-    "start_url": ".",
-    "display": "standalone",
-    "background_color": "#0175C2",
-    "theme_color": "#0175C2",
-    "description": "A new Flutter project.",
-    "orientation": "portrait-primary",
-    "prefer_related_applications": false,
-    "icons": [
-        {
-            "src": "icons/Icon-192.png",
-            "sizes": "192x192",
-            "type": "image/png"
-        },
-        {
-            "src": "icons/Icon-512.png",
-            "sizes": "512x512",
-            "type": "image/png"
-        },
-        {
-            "src": "icons/Icon-maskable-192.png",
-            "sizes": "192x192",
-            "type": "image/png",
-            "purpose": "maskable"
-        },
-        {
-            "src": "icons/Icon-maskable-512.png",
-            "sizes": "512x512",
-            "type": "image/png",
-            "purpose": "maskable"
-        }
-    ]
-}
\ No newline at end of file
diff --git a/packages/komodo_coin_updates/lib/src/coins_config/config_transform.dart b/packages/komodo_coin_updates/lib/src/coins_config/config_transform.dart
index bef55ac0e..c550fbee3 100644
--- a/packages/komodo_coin_updates/lib/src/coins_config/config_transform.dart
+++ b/packages/komodo_coin_updates/lib/src/coins_config/config_transform.dart
@@ -1,4 +1,4 @@
-import 'package:flutter/foundation.dart';
+import 'package:flutter/foundation.dart' show kIsWeb, kIsWasm;
 import 'package:komodo_defi_types/komodo_defi_type_utils.dart';
 
 /// Defines a transform that can be applied to a single coin configuration.
@@ -26,7 +26,12 @@ class CoinConfigTransformer {
   /// If [transforms] is omitted, a default set is used.
   const CoinConfigTransformer({List<CoinConfigTransform>? transforms})
     : _transforms =
-          transforms ?? const [WssWebsocketTransform(), ParentCoinTransform()];
+          transforms ??
+          const [
+            WssWebsocketTransform(),
+            ZhtlcLightWalletTransform(),
+            ParentCoinTransform(),
+          ];
 
   final List<CoinConfigTransform> _transforms;
 
@@ -240,3 +245,41 @@ class _ParentCoinResolver {
   static bool needsRemapping(String? parentCoin) =>
       _parentCoinMappings.containsKey(parentCoin);
 }
+
+/// Replaces `light_wallet_d_servers` with `light_wallet_d_servers_wss` for ZHTLC coins
+/// on web/wasm platforms to ensure WebSocket compatibility.
+class ZhtlcLightWalletTransform implements CoinConfigTransform {
+  const ZhtlcLightWalletTransform();
+
+  @override
+  /// Determines if the transform should run by checking if this is a ZHTLC coin
+  /// on a web/wasm platform that has both light_wallet_d_servers and light_wallet_d_servers_wss configured.
+  bool needsTransform(JsonMap config) {
+    // Only run on web or wasm platforms
+    if (!kIsWeb && !kIsWasm) return false;
+
+    // Only run for ZHTLC coin type
+    final coinType = config.valueOrNull<String>('type');
+    if (coinType != 'ZHTLC') return false;
+
+    final lightWalletServersWss = config.valueOrNull<List>(
+      'light_wallet_d_servers_wss',
+    );
+
+    return lightWalletServersWss != null && lightWalletServersWss.isNotEmpty;
+  }
+
+  @override
+  /// Replaces the `light_wallet_d_servers` list with the `light_wallet_d_servers_wss` list
+  /// for WebSocket compatibility in web/wasm environments.
+  JsonMap transform(JsonMap config) {
+    // .value used here since the needsTransform check should only allow this to
+    // run if present. No strict type given to checking here since we don't
+    // need to perform operations on the individual elements.
+    final lightWalletServersWss = config.value<List>(
+      'light_wallet_d_servers_wss',
+    );
+
+    return config..['light_wallet_d_servers'] = lightWalletServersWss;
+  }
+}
diff --git a/packages/komodo_coin_updates/pubspec.yaml b/packages/komodo_coin_updates/pubspec.yaml
index 85be0ac45..34cd8f22f 100644
--- a/packages/komodo_coin_updates/pubspec.yaml
+++ b/packages/komodo_coin_updates/pubspec.yaml
@@ -29,7 +29,7 @@ dev_dependencies:
   flutter_test:
     sdk: flutter
   freezed: ^3.0.4
-  hive_ce_generator: ^1.9.2
+  hive_ce_generator: ^1.9.3
   hive_test: ^1.0.1
   index_generator: ^4.0.1
   json_serializable: ^6.7.1
diff --git a/packages/komodo_coins/pubspec.yaml b/packages/komodo_coins/pubspec.yaml
index a4f0b2504..059ab88a6 100644
--- a/packages/komodo_coins/pubspec.yaml
+++ b/packages/komodo_coins/pubspec.yaml
@@ -20,7 +20,7 @@ dependencies:
   komodo_defi_types: ^0.3.2+1
   logging: ^1.3.0
   path: ^1.9.1
-  path_provider: ^2.1.4
+  path_provider: ^2.1.5
 
 dev_dependencies:
   build_runner: ^2.4.14
diff --git a/packages/komodo_defi_framework/lib/komodo_defi_framework.dart b/packages/komodo_defi_framework/lib/komodo_defi_framework.dart
index 1df199485..d4a213afa 100644
--- a/packages/komodo_defi_framework/lib/komodo_defi_framework.dart
+++ b/packages/komodo_defi_framework/lib/komodo_defi_framework.dart
@@ -1,5 +1,6 @@
 import 'dart:async';
 
+import 'package:flutter/foundation.dart';
 import 'package:komodo_defi_framework/src/config/kdf_config.dart';
 import 'package:komodo_defi_framework/src/config/kdf_logging_config.dart';
 import 'package:komodo_defi_framework/src/config/kdf_startup_config.dart';
@@ -67,7 +68,18 @@ class KomodoDefiFramework implements ApiClient {
       _loggerSub = null;
     }
 
-    _loggerSub = _logStream.stream.listen(logCallback);
+    _loggerSub = _logStream.stream.listen(
+      logCallback,
+      onError: (Object error, StackTrace stackTrace) {
+        // Log the error internally but don't propagate it to avoid crashing
+        if (kDebugMode) {
+          print('[KomodoDefiFramework] Error in external logger callback:');
+          print('  Error: $error');
+          print('  Stack trace:\n$stackTrace');
+        }
+      },
+      cancelOnError: false, // Continue listening even if the callback throws
+    );
   }
 
   StreamSubscription<String>? _loggerSub;
@@ -79,7 +91,11 @@ class KomodoDefiFramework implements ApiClient {
 
   Stream<String> get logStream => _logStream.stream;
 
-  void _log(String message) => _logStream.add(message);
+  void _log(String message) {
+    if (!_logStream.isClosed) {
+      _logStream.add(message);
+    }
+  }
 
   //TODO! Figure out best way to handle overlap between startup and host
   //TODO! Handle common KDF operations startup log scanning here or in a
@@ -140,7 +156,8 @@ class KomodoDefiFramework implements ApiClient {
   }
 
   Future<bool> isRunning() async {
-    final running = await _kdfOperations.isRunning() ||
+    final running =
+        await _kdfOperations.isRunning() ||
         await _kdfOperations.version() != null;
     if (!running) {
       _log('KDF is not running.');
@@ -158,8 +175,7 @@ class KomodoDefiFramework implements ApiClient {
   Future<JsonMap> executeRpc(JsonMap request) async {
     final response = (await _kdfOperations.mm2Rpc(
       request..setIfAbsentOrEmpty('userpass', _hostConfig.rpcPassword),
-    ))
-        .ensureJson();
+    )).ensureJson();
     if (KdfLoggingConfig.verboseLogging) {
       _log('RPC response: ${response.toJsonString()}');
     }
@@ -195,9 +211,18 @@ class KomodoDefiFramework implements ApiClient {
   ///
   /// NB! This does not stop the KDF operations or the KDF process.
   Future<void> dispose() async {
-    await _logStream.close();
-
+    // Cancel subscription first before closing the stream
     await _loggerSub?.cancel();
+    _loggerSub = null;
+
+    // Close the log stream
+    if (!_logStream.isClosed) {
+      await _logStream.close();
+    }
+
+    // Dispose of KDF operations to free native resources
+    final operations = _kdfOperations;
+    operations.dispose();
   }
 
   String get operationsName => _kdfOperations.operationsName;
diff --git a/packages/komodo_defi_framework/lib/src/operations/kdf_operations_factory.dart b/packages/komodo_defi_framework/lib/src/operations/kdf_operations_factory.dart
index a9f26b643..ba30f9f8c 100644
--- a/packages/komodo_defi_framework/lib/src/operations/kdf_operations_factory.dart
+++ b/packages/komodo_defi_framework/lib/src/operations/kdf_operations_factory.dart
@@ -3,6 +3,7 @@ import 'package:komodo_defi_framework/src/operations/kdf_operations_interface.da
 import 'package:komodo_defi_framework/src/operations/kdf_operations_remote.dart';
 import 'package:komodo_defi_framework/src/operations/kdf_operations_wasm.dart'
     if (dart.library.io) 'package:komodo_defi_framework/src/operations/kdf_operations_native.dart'
+    if (dart.library.html) 'package:komodo_defi_framework/src/operations/kdf_operations_wasm.dart'
     as local;
 
 IKdfOperations createKdfOperations({
diff --git a/packages/komodo_defi_framework/lib/src/operations/kdf_operations_interface.dart b/packages/komodo_defi_framework/lib/src/operations/kdf_operations_interface.dart
index f6f04878a..98db74469 100644
--- a/packages/komodo_defi_framework/lib/src/operations/kdf_operations_interface.dart
+++ b/packages/komodo_defi_framework/lib/src/operations/kdf_operations_interface.dart
@@ -131,6 +131,9 @@ abstract interface class IKdfOperations {
   /// to start it. This may be reworked in the future to separate these
   /// concerns.
   Future<bool> isAvailable(IKdfHostConfig hostConfig);
+
+  /// Dispose of any resources used by this operations implementation
+  void dispose();
 }
 
 class JsonRpcErrorResponse extends MapBase<String, dynamic>
@@ -139,11 +142,7 @@ class JsonRpcErrorResponse extends MapBase<String, dynamic>
     required int? code,
     required String error,
     required String message,
-  }) : _map = {
-          'code': code,
-          'error': error,
-          'message': message,
-        };
+  }) : _map = {'code': code, 'error': error, 'message': message};
 
   /// Returns null if the response is not an error response,
   /// otherwise returns a [JsonRpcErrorResponse] instance.
@@ -192,14 +191,8 @@ class JsonRpcErrorResponse extends MapBase<String, dynamic>
 }
 
 class ConnectionError extends JsonRpcErrorResponse {
-  ConnectionError(
-    String message, {
-    this.originalException,
-    super.code = -1,
-  }) : super(
-          error: 'ConnectionError',
-          message: message,
-        );
+  ConnectionError(String message, {this.originalException, super.code = -1})
+    : super(error: 'ConnectionError', message: message);
 
   Exception? originalException;
 
diff --git a/packages/komodo_defi_framework/lib/src/operations/kdf_operations_local_executable.dart b/packages/komodo_defi_framework/lib/src/operations/kdf_operations_local_executable.dart
index 4f3bb2ad2..d8d638354 100644
--- a/packages/komodo_defi_framework/lib/src/operations/kdf_operations_local_executable.dart
+++ b/packages/komodo_defi_framework/lib/src/operations/kdf_operations_local_executable.dart
@@ -17,9 +17,9 @@ class KdfOperationsLocalExecutable implements IKdfOperations {
     Duration startupTimeout = const Duration(seconds: 30),
     KdfExecutableFinder? executableFinder,
     this.executableName = 'kdf',
-  })  : _startupTimeout = startupTimeout,
-        _executableFinder =
-            executableFinder ?? KdfExecutableFinder(logCallback: _logCallback);
+  }) : _startupTimeout = startupTimeout,
+       _executableFinder =
+           executableFinder ?? KdfExecutableFinder(logCallback: _logCallback);
 
   factory KdfOperationsLocalExecutable.create({
     required void Function(String) logCallback,
@@ -72,10 +72,9 @@ class KdfOperationsLocalExecutable implements IKdfOperations {
   static final Uri _url = Uri.parse('http://127.0.0.1:7783');
 
   Future<Process> _startKdf(JsonMap params) async {
-    final executablePath =
-        (await _executableFinder.findExecutable(executableName: executableName))
-            ?.absolute
-            .path;
+    final executablePath = (await _executableFinder.findExecutable(
+      executableName: executableName,
+    ))?.absolute.path;
     if (executablePath == null) {
       throw KdfException(
         'KDF executable not found in any of the expected locations. '
@@ -115,11 +114,9 @@ class KdfOperationsLocalExecutable implements IKdfOperations {
       final environment = Map<String, String>.of(Platform.environment)
         ..['MM_COINS_PATH'] = coinsConfigFile.path;
 
-      final newProcess = await Process.start(
-        executablePath,
-        [sensitiveArgs.toJsonString()],
-        environment: environment,
-      );
+      final newProcess = await Process.start(executablePath, [
+        sensitiveArgs.toJsonString(),
+      ], environment: environment);
 
       _logCallback('Launched executable: $executablePath');
       _attachProcessListeners(newProcess, coinsTempDir);
@@ -195,11 +192,9 @@ class KdfOperationsLocalExecutable implements IKdfOperations {
     }
 
     final coinsCount = params.valueOrNull<List<dynamic>>('coins')?.length;
-    _logCallback('Starting KDF with parameters: ${{
-      ...params,
-      'coins': '{{OMITTED $coinsCount ITEMS}}',
-      'log_level': logLevel ?? 3,
-    }.censored().toJsonString()}');
+    _logCallback(
+      'Starting KDF with parameters: ${{...params, 'coins': '{{OMITTED $coinsCount ITEMS}}', 'log_level': logLevel ?? 3}.censored().toJsonString()}',
+    );
 
     try {
       _process = await _startKdf(params);
@@ -247,9 +242,9 @@ class KdfOperationsLocalExecutable implements IKdfOperations {
   Future<StopStatus> kdfStop() async {
     var stopStatus = StopStatus.ok;
     try {
-      stopStatus = await _kdfRemote
-          .kdfStop()
-          .catchError((_) => StopStatus.errorStopping);
+      stopStatus = await _kdfRemote.kdfStop().catchError(
+        (_) => StopStatus.errorStopping,
+      );
 
       if (_process == null || _process?.pid == 0) {
         _logCallback('Process is not running, skipping shutdown.');
@@ -302,4 +297,39 @@ class KdfOperationsLocalExecutable implements IKdfOperations {
       );
     }
   }
+
+  @override
+  void dispose() {
+    // Cancel and clean up subscriptions
+    stdoutSub?.cancel().ignore();
+    stdoutSub = null;
+    stderrSub?.cancel().ignore();
+    stderrSub = null;
+
+    // Gracefully stop the process if running
+    final capturedProcess = _process;
+    if (capturedProcess != null) {
+      _kdfRemote.kdfStop().timeout(const Duration(seconds: 3)).ignore();
+      unawaited(_gracefulProcessShutdown(capturedProcess));
+    }
+
+    // Clean up remote resources
+    _kdfRemote.dispose();
+  }
+
+  Future<void> _gracefulProcessShutdown(Process capturedProcess) async {
+    try {
+      await capturedProcess.exitCode
+          .timeout(const Duration(seconds: 5))
+          .catchError((_) {
+            capturedProcess.kill();
+            return -1; // Return an int to match Future<int>
+          });
+    } finally {
+      // Only set _process = null if it still equals the captured instance
+      if (_process == capturedProcess) {
+        _process = null;
+      }
+    }
+  }
 }
diff --git a/packages/komodo_defi_framework/lib/src/operations/kdf_operations_native.dart b/packages/komodo_defi_framework/lib/src/operations/kdf_operations_native.dart
index 132b1184e..c577f3821 100644
--- a/packages/komodo_defi_framework/lib/src/operations/kdf_operations_native.dart
+++ b/packages/komodo_defi_framework/lib/src/operations/kdf_operations_native.dart
@@ -67,14 +67,41 @@ class KdfOperationsNativeLibrary implements IKdfOperations {
   ) {
     try {
       final message = messagePtr.toDartString();
-      log(message);
+      _safeLog(message, log);
     } catch (e) {
-      final unsignedLength = messagePtr.length;
-      log('Failed to decode log message ($unsignedLength bytes): $e');
+      // Message decoding failed, try manual parsing
+      final unsignedLength = _safeGetLength(messagePtr);
+      _safeLog('Failed to decode log message ($unsignedLength bytes): $e', log);
 
       final manuallyParsedMessage = _tryParseNativeLogMessage(messagePtr, log);
       if (manuallyParsedMessage.isNotEmpty) {
-        log(manuallyParsedMessage);
+        _safeLog(manuallyParsedMessage, log);
+      }
+    }
+  }
+
+  /// Safely gets the length of a pointer, returning -1 if it fails
+  static int _safeGetLength(ffi.Pointer<Utf8> messagePtr) {
+    try {
+      return messagePtr.length;
+    } catch (e) {
+      if (kDebugMode) {
+        print('Failed to get message length: $e');
+      }
+      return -1;
+    }
+  }
+
+  /// Safely invokes the log callback with fallback to debug print
+  static void _safeLog(String message, void Function(String) log) {
+    try {
+      log(message);
+    } catch (e, stackTrace) {
+      // Log callback failed - use debug print as fallback
+      if (kDebugMode) {
+        print('Log callback failed for message: $message');
+        print('Error: $e');
+        print('Stack trace: $stackTrace');
       }
     }
   }
@@ -97,13 +124,13 @@ class KdfOperationsNativeLibrary implements IKdfOperations {
 
         // prevent overflows & infinite loops with a reasonable limit
         if (length >= 32767) {
-          log('Received log message longer than 32767 bytes.');
+          _safeLog('Received log message longer than 32767 bytes.', log);
           return '';
         }
       }
 
       if (length == 0) {
-        log('Received empty log message.');
+        _safeLog('Received empty log message.', log);
         return '';
       }
 
@@ -111,16 +138,17 @@ class KdfOperationsNativeLibrary implements IKdfOperations {
       // flutter devtools from crashing.
       final bytes = messagePtrAsInt.asTypedList(length);
       if (!_isValidUtf8(bytes)) {
-        log('Received invalid UTF-8 log message.');
-        final hexString =
-            bytes.map((b) => b.toRadixString(16).padLeft(2, '0')).join(' ');
-        log('Raw bytes: $hexString');
+        _safeLog('Received invalid UTF-8 log message.', log);
+        final hexString = bytes
+            .map((b) => b.toRadixString(16).padLeft(2, '0'))
+            .join(' ');
+        _safeLog('Raw bytes: $hexString', log);
         return '';
       }
 
       return utf8.decode(bytes);
     } catch (e) {
-      log('Failed to decode log message: $e');
+      _safeLog('Failed to decode log message: $e', log);
     }
 
     return '';
@@ -160,8 +188,10 @@ class KdfOperationsNativeLibrary implements IKdfOperations {
 
   @override
   Future<KdfStartupResult> kdfMain(JsonMap startParams, {int? logLevel}) async {
-    final startParamsPtr =
-        startParams.toJsonString().toNativeUtf8().cast<Utf8>();
+    final startParamsPtr = startParams
+        .toJsonString()
+        .toNativeUtf8()
+        .cast<Utf8>();
     // TODO: Implement log level
 
     final timer = Stopwatch()..start();
@@ -271,12 +301,13 @@ class KdfOperationsNativeLibrary implements IKdfOperations {
       'Symbol mm2_main not found in library',
     );
     final bindings = KomodoDefiFrameworkBindings(dylib);
-    final startParamsPtr =
-        ffi.Pointer<Utf8>.fromAddress(params.startParamsPtrAddress);
+    final startParamsPtr = ffi.Pointer<Utf8>.fromAddress(
+      params.startParamsPtrAddress,
+    );
     final logCallback =
         ffi.Pointer<ffi.NativeFunction<LogCallbackFunction>>.fromAddress(
-      params.logCallbackAddress,
-    );
+          params.logCallbackAddress,
+        );
     return bindings.mm2_main(startParamsPtr, logCallback);
   }
 
@@ -296,10 +327,7 @@ class KdfOperationsNativeLibrary implements IKdfOperations {
 }
 
 class _KdfMainParams {
-  _KdfMainParams(
-    this.startParamsPtrAddress,
-    this.logCallbackAddress,
-  );
+  _KdfMainParams(this.startParamsPtrAddress, this.logCallbackAddress);
   final int startParamsPtrAddress;
   final int logCallbackAddress;
 }
@@ -311,8 +339,8 @@ ffi.DynamicLibrary _loadLibrary() {
       final lib = path == 'PROCESS'
           ? ffi.DynamicLibrary.process()
           : path == 'EXECUTABLE'
-              ? ffi.DynamicLibrary.executable()
-              : ffi.DynamicLibrary.open(path);
+          ? ffi.DynamicLibrary.executable()
+          : ffi.DynamicLibrary.open(path);
       if (lib.providesSymbol('mm2_main')) {
         if (kDebugMode) print('Loaded library at path: $path');
         return lib;
@@ -326,19 +354,9 @@ ffi.DynamicLibrary _loadLibrary() {
 
 List<String> _getLibraryPaths() {
   if (Platform.isMacOS) {
-    return [
-      'kdf',
-      'mm2',
-      'libkdflib.dylib',
-      'PROCESS',
-      'EXECUTABLE',
-    ];
+    return ['kdf', 'mm2', 'libkdflib.dylib', 'PROCESS', 'EXECUTABLE'];
   } else if (Platform.isIOS) {
-    return [
-      'libkdflib.dylib',
-      'PROCESS',
-      'EXECUTABLE',
-    ];
+    return ['libkdflib.dylib', 'PROCESS', 'EXECUTABLE'];
   } else if (Platform.isAndroid) {
     return [
       'libkomodo_defi_framework.so',
diff --git a/packages/komodo_defi_framework/lib/src/operations/kdf_operations_native_stub.dart b/packages/komodo_defi_framework/lib/src/operations/kdf_operations_native_stub.dart
new file mode 100644
index 000000000..d585c5c6d
--- /dev/null
+++ b/packages/komodo_defi_framework/lib/src/operations/kdf_operations_native_stub.dart
@@ -0,0 +1,52 @@
+import 'package:komodo_defi_framework/src/config/kdf_config.dart';
+import 'package:komodo_defi_framework/src/operations/kdf_operations_interface.dart';
+import 'package:komodo_defi_types/komodo_defi_type_utils.dart';
+
+IKdfOperations createLocalKdfOperations({
+  required void Function(String)? logCallback,
+  required LocalConfig config,
+}) {
+  return KdfOperationsNativeLibrary();
+}
+
+class KdfOperationsNativeLibrary implements IKdfOperations {
+  @override
+  String get operationsName => 'Native Library Stub';
+
+  @override
+  Future<bool> isAvailable(IKdfHostConfig hostConfig) async => false;
+
+  @override
+  Future<bool> isRunning() async => false;
+
+  @override
+  Future<KdfStartupResult> kdfMain(
+    JsonMap startParams, {
+    int? logLevel,
+  }) async => KdfStartupResult.spawnError;
+
+  @override
+  Future<MainStatus> kdfMainStatus() async => MainStatus.notRunning;
+
+  @override
+  Future<StopStatus> kdfStop() async => StopStatus.notRunning;
+
+  @override
+  Future<String?> version() async => null;
+
+  @override
+  Future<Map<String, dynamic>> mm2Rpc(Map<String, dynamic> request) async =>
+      throw UnsupportedError(
+        'Native operations not available on this platform',
+      );
+
+  @override
+  Future<void> validateSetup() async {
+    throw UnsupportedError('Native operations not available on this platform');
+  }
+
+  @override
+  void dispose() {
+    // No-op for stub
+  }
+}
diff --git a/packages/komodo_defi_framework/lib/src/operations/kdf_operations_remote.dart b/packages/komodo_defi_framework/lib/src/operations/kdf_operations_remote.dart
index 1850479c8..40de71248 100644
--- a/packages/komodo_defi_framework/lib/src/operations/kdf_operations_remote.dart
+++ b/packages/komodo_defi_framework/lib/src/operations/kdf_operations_remote.dart
@@ -16,18 +16,10 @@ class KdfOperationsRemote implements IKdfOperations {
     required Uri rpcUrl,
     required String userpass,
   }) {
-    return KdfOperationsRemote._(
-      logCallback,
-      rpcUrl,
-      userpass,
-    );
+    return KdfOperationsRemote._(logCallback, rpcUrl, userpass);
   }
 
-  KdfOperationsRemote._(
-    this._logCallback,
-    this._rpcUrl,
-    this._userpass,
-  );
+  KdfOperationsRemote._(this._logCallback, this._rpcUrl, this._userpass);
   final void Function(String) _logCallback;
   final String _userpass;
 
@@ -97,7 +89,8 @@ class KdfOperationsRemote implements IKdfOperations {
 
   @override
   Future<KdfStartupResult> kdfMain(JsonMap startParams, {int? logLevel}) async {
-    const message = 'KDF cannot be started using Remote client. '
+    const message =
+        'KDF cannot be started using Remote client. '
         'Please start the KDF on the remote server manually.';
     _log(message);
 
@@ -114,9 +107,7 @@ class KdfOperationsRemote implements IKdfOperations {
   @override
   Future<StopStatus> kdfStop() async {
     try {
-      final stopResultResponse = await mm2Rpc({
-        'method': 'stop',
-      });
+      final stopResultResponse = await mm2Rpc({'method': 'stop'});
 
       _log('stopResultResponse: $stopResultResponse');
 
@@ -164,17 +155,16 @@ class KdfOperationsRemote implements IKdfOperations {
     try {
       response = await http.post(_baseUrl, body: json.encode(request));
     } on http.ClientException catch (e) {
-      return ConnectionError(
-        e.message,
-        originalException: e,
-      );
+      return ConnectionError(e.message, originalException: e);
     }
 
     if (response.statusCode != 200) {
       return JsonRpcErrorResponse(
         code: response.statusCode,
-        error: {'error': 'HTTP Error', 'status': response.statusCode}
-            .toJsonString(),
+        error: {
+          'error': 'HTTP Error',
+          'status': response.statusCode,
+        }.toJsonString(),
         message: response.body,
       );
     }
@@ -207,4 +197,9 @@ class KdfOperationsRemote implements IKdfOperations {
       return null;
     }
   }
+
+  @override
+  void dispose() {
+    // No-op for remote operations - HTTP client is managed externally
+  }
 }
diff --git a/packages/komodo_defi_framework/lib/src/operations/kdf_operations_wasm.dart b/packages/komodo_defi_framework/lib/src/operations/kdf_operations_wasm.dart
index 5c73fb0fc..1876274cc 100644
--- a/packages/komodo_defi_framework/lib/src/operations/kdf_operations_wasm.dart
+++ b/packages/komodo_defi_framework/lib/src/operations/kdf_operations_wasm.dart
@@ -80,10 +80,9 @@ class KdfOperationsWasm implements IKdfOperations {
     return _startupLock.protect(() async {
       await _ensureLoaded();
 
-      final jsConfig = {
-        'conf': config,
-        'log_level': logLevel ?? 3,
-      }.jsify() as js_interop.JSObject?;
+      final jsConfig =
+          {'conf': config, 'log_level': logLevel ?? 3}.jsify()
+              as js_interop.JSObject?;
 
       try {
         return await _executeKdfMain(jsConfig);
@@ -198,8 +197,10 @@ class KdfOperationsWasm implements IKdfOperations {
     try {
       // Call mm2_stop which may return a Promise or a direct value
       final jsAny = _kdfModule!.callMethod<js_interop.JSAny?>('mm2_stop'.toJS);
-      final status =
-          await parseJsInteropMaybePromise(jsAny, js_maps.mapJsStopResult);
+      final status = await parseJsInteropMaybePromise(
+        jsAny,
+        js_maps.mapJsStopResult,
+      );
 
       // Ensure the node actually stops when we expect success or already stopped
       if (status == StopStatus.ok || status == StopStatus.stoppingAlready) {
@@ -241,8 +242,9 @@ class KdfOperationsWasm implements IKdfOperations {
     request['userpass'] = _config.rpcPassword;
 
     final jsRequest = request.jsify() as js_interop.JSObject?;
-    final jsPromise = _kdfModule!.callMethod('mm2_rpc'.toJS, jsRequest)
-        as js_interop.JSPromise?;
+    final jsPromise =
+        _kdfModule!.callMethod('mm2_rpc'.toJS, jsRequest)
+            as js_interop.JSPromise?;
 
     if (jsPromise == null || jsPromise.isUndefinedOrNull) {
       throw Exception(
@@ -251,21 +253,21 @@ class KdfOperationsWasm implements IKdfOperations {
       );
     }
 
-    final jsResponse = await jsPromise.toDart
-        .then((value) => value)
-        .catchError((Object error) {
-      if (error.toString().contains('RethrownDartError')) {
-        final errorMessage = error.toString().split('\n')[0];
+    final jsResponse = await jsPromise.toDart.then((value) => value).catchError(
+      (Object error) {
+        if (error.toString().contains('RethrownDartError')) {
+          final errorMessage = error.toString().split('\n')[0];
+          throw Exception(
+            'JavaScript error for method ${request['method']}: $errorMessage'
+            '\nRequest: $request',
+          );
+        }
         throw Exception(
-          'JavaScript error for method ${request['method']}: $errorMessage'
+          'Unknown error for method ${request['method']}: $error'
           '\nRequest: $request',
         );
-      }
-      throw Exception(
-        'Unknown error for method ${request['method']}: $error'
-        '\nRequest: $request',
-      );
-    });
+      },
+    );
 
     if (jsResponse == null || jsResponse.isUndefinedOrNull) {
       throw Exception(
@@ -356,10 +358,11 @@ class KdfOperationsWasm implements IKdfOperations {
 
   Future<void> _injectLibrary() async {
     try {
-      _kdfModule = (await js_interop
-              .importModule('./$_kdfJsBootstrapperPath'.toJS)
-              .toDart)
-          .getProperty('kdf'.toJS);
+      _kdfModule =
+          (await js_interop
+                  .importModule('./$_kdfJsBootstrapperPath'.toJS)
+                  .toDart)
+              .getProperty('kdf'.toJS);
 
       _log('KDF library loaded successfully');
     } catch (e) {
@@ -393,6 +396,13 @@ class KdfOperationsWasm implements IKdfOperations {
       throw Exception(message);
     }
   }
+
+  @override
+  void dispose() {
+    // Clean up any resources used by the WASM operations
+    _kdfModule = null;
+    _libraryLoaded = false;
+  }
 }
 
 class KdfPluginWeb {
diff --git a/packages/komodo_defi_framework/pubspec.yaml b/packages/komodo_defi_framework/pubspec.yaml
index 0efceabfd..d847d2e1a 100644
--- a/packages/komodo_defi_framework/pubspec.yaml
+++ b/packages/komodo_defi_framework/pubspec.yaml
@@ -30,7 +30,7 @@ dependencies:
   logging: ^1.3.0
   mutex: ^3.1.0
   path: ^1.9.1
-  path_provider: ^2.1.4
+  path_provider: ^2.1.5
   plugin_platform_interface: ^2.0.2
   web: ^1.1.0
 
diff --git a/packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/activation_params.dart b/packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/activation_params.dart
index 7935a2e82..0beb0e824 100644
--- a/packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/activation_params.dart
+++ b/packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/activation_params.dart
@@ -1,6 +1,7 @@
 import 'package:freezed_annotation/freezed_annotation.dart';
 import 'package:komodo_defi_rpc_methods/src/internal_exports.dart';
 import 'package:komodo_defi_types/komodo_defi_type_utils.dart';
+import 'package:komodo_defi_types/komodo_defi_types.dart';
 
 part 'activation_params.freezed.dart';
 part 'activation_params.g.dart';
@@ -17,10 +18,6 @@ part 'activation_params.g.dart';
 /// - [gapLimit]: Maximum number of empty addresses in a row for HD wallets
 /// - [mode]: Activation mode configuration for QTUM, UTXO & ZHTLC coins
 ///
-/// For ZHTLC coins:
-/// - [zcashParamsPath]: Path to Zcash parameters folder
-/// - [scanBlocksPerIteration]: Number of blocks scanned per iteration (default: 1000)
-/// - [scanIntervalMs]: Interval between scan iterations in ms (default: 0)
 class ActivationParams implements RpcRequestParams {
   const ActivationParams({
     this.requiredConfirmations,
@@ -30,9 +27,6 @@ class ActivationParams implements RpcRequestParams {
     this.scanPolicy,
     this.gapLimit,
     this.mode,
-    this.zcashParamsPath,
-    this.scanBlocksPerIteration,
-    this.scanIntervalMs,
   });
 
   /// Creates [ActivationParams] from configuration JSON
@@ -50,17 +44,11 @@ class ActivationParams implements RpcRequestParams {
         json.valueOrNull<dynamic>('priv_key_policy'),
       ),
       minAddressesNumber: json.valueOrNull<int>('min_addresses_number'),
-      scanPolicy:
-          json.valueOrNull<String>('scan_policy') == null
-              ? null
-              : ScanPolicy.parse(json.value<String>('scan_policy')),
+      scanPolicy: json.valueOrNull<String>('scan_policy') == null
+          ? null
+          : ScanPolicy.parse(json.value<String>('scan_policy')),
       gapLimit: json.valueOrNull<int>('gap_limit'),
       mode: mode,
-      zcashParamsPath: json.valueOrNull<String>('zcash_params_path'),
-      scanBlocksPerIteration: json.valueOrNull<int>(
-        'scan_blocks_per_iteration',
-      ),
-      scanIntervalMs: json.valueOrNull<int>('scan_interval_ms'),
     );
   }
 
@@ -91,18 +79,6 @@ class ActivationParams implements RpcRequestParams {
   /// they will not be identified when scanning.
   final int? gapLimit;
 
-  /// ZHTLC coins only. Path to folder containing Zcash parameters.
-  /// Optional, defaults to standard location.
-  final String? zcashParamsPath;
-
-  /// ZHTLC coins only. Sets the number of scanned blocks per iteration during
-  /// BuildingWalletDb state. Optional, default value is 1000.
-  final int? scanBlocksPerIteration;
-
-  /// ZHTLC coins only. Sets the interval in milliseconds between iterations of
-  /// BuildingWalletDb state. Optional, default value is 0.
-  final int? scanIntervalMs;
-
   @override
   @mustCallSuper
   JsonMap toRpcParams() {
@@ -122,10 +98,6 @@ class ActivationParams implements RpcRequestParams {
       if (scanPolicy != null) 'scan_policy': scanPolicy!.value,
       if (gapLimit != null) 'gap_limit': gapLimit,
       if (mode != null) 'mode': mode!.toJsonRequest(),
-      if (zcashParamsPath != null) 'zcash_params_path': zcashParamsPath,
-      if (scanBlocksPerIteration != null)
-        'scan_blocks_per_iteration': scanBlocksPerIteration,
-      if (scanIntervalMs != null) 'scan_interval_ms': scanIntervalMs,
     };
   }
 
@@ -137,9 +109,6 @@ class ActivationParams implements RpcRequestParams {
     ScanPolicy? scanPolicy,
     int? gapLimit,
     ActivationMode? mode,
-    String? zcashParamsPath,
-    int? scanBlocksPerIteration,
-    int? scanIntervalMs,
   }) {
     return ActivationParams(
       requiredConfirmations:
@@ -153,10 +122,6 @@ class ActivationParams implements RpcRequestParams {
       scanPolicy: scanPolicy ?? this.scanPolicy,
       gapLimit: gapLimit ?? this.gapLimit,
       mode: mode ?? this.mode,
-      zcashParamsPath: zcashParamsPath ?? this.zcashParamsPath,
-      scanBlocksPerIteration:
-          scanBlocksPerIteration ?? this.scanBlocksPerIteration,
-      scanIntervalMs: scanIntervalMs ?? this.scanIntervalMs,
     );
   }
 }
@@ -254,6 +219,22 @@ abstract class PrivateKeyPolicy with _$PrivateKeyPolicy {
   }
 }
 
+/// Utility to normalize PrivateKeyPolicy RPC serialization across protocols.
+///
+/// - For ETH/ERC20 protocols, the API expects a JSON object form.
+/// - For other protocols, the legacy PascalCase string is used.
+class PrivKeyPolicySerializer {
+  static dynamic toRpc(
+    PrivateKeyPolicy policy, {
+    required CoinSubClass protocol,
+  }) {
+    if (evmCoinSubClasses.contains(protocol)) {
+      return policy.toJson();
+    }
+    return policy.pascalCaseName;
+  }
+}
+
 /// Defines the type of activation mode for QTUM, UTXO & ZHTLC coins
 enum ActivationModeType {
   /// Use Electrum servers for activation
@@ -293,10 +274,9 @@ class ActivationMode {
   }) {
     return ActivationMode(
       rpc: type.value,
-      rpcData:
-          type == ActivationModeType.native
-              ? null
-              : ActivationRpcData.fromJson(json),
+      rpcData: type == ActivationModeType.native
+          ? null
+          : ActivationRpcData.fromJson(json),
     );
   }
 
@@ -309,7 +289,10 @@ class ActivationMode {
 
   JsonMap toJsonRequest() => {
     'rpc': rpc,
-    if (rpcData != null) 'rpc_data': rpcData!.toJsonRequest(),
+    if (rpcData != null)
+      'rpc_data': rpcData!.toJsonRequest(
+        forLightWallet: rpc == ActivationModeType.lightWallet.value,
+      ),
   };
 }
 
@@ -382,15 +365,22 @@ class ActivationRpcData {
   /// Creates [ActivationRpcData] from JSON configuration
   factory ActivationRpcData.fromJson(JsonMap json) {
     return ActivationRpcData(
-      lightWalletDServers: json.valueOrNull<List<String>>(
-        'light_wallet_d_servers',
-      ),
+      lightWalletDServers: json
+          .valueOrNull<List<dynamic>>('light_wallet_d_servers')
+          ?.cast<String>(),
+      // The Komodo API uses 'servers' under rpc_data for Electrum mode.
+      // For some legacy ZHTLC examples, 'electrum' may appear at top-level config.
       electrum:
-          json
-              .valueOrNull<JsonList>('electrum')
-              ?.map(ActivationServers.fromJsonConfig)
+          (json.valueOrNull<List<dynamic>>('servers') ??
+                  json.valueOrNull<List<dynamic>>('electrum') ??
+                  json.valueOrNull<List<dynamic>>('electrum_servers') ??
+                  json.valueOrNull<List<dynamic>>('nodes') ??
+                  json.valueOrNull<List<dynamic>>('rpc_urls'))
+              ?.map((e) => ActivationServers.fromJsonConfig(e as JsonMap))
               .toList(),
-      syncParams: json.valueOrNull<dynamic>('sync_params'),
+      syncParams: ZhtlcSyncParams.tryParse(
+        json.valueOrNull<dynamic>('sync_params'),
+      ),
     );
   }
 
@@ -402,29 +392,113 @@ class ActivationRpcData {
 
   /// ZHTLC coins only. Optional, defaults to two days ago. Defines where to start
   /// scanning blockchain data upon initial activation.
-  /// Options:
-  /// - "earliest" (the coin's sapling_activation_height)
-  /// - height (a specific block height)
-  /// - date (a unix timestamp)
-  final dynamic syncParams;
-
-  bool get isEmpty => [lightWalletDServers, electrum, syncParams].every(
-    (element) =>
-        element == null &&
-        (element is List && element.isEmpty ||
-            element is Map && element.isEmpty),
-  );
-
-  JsonMap toJsonRequest() => {
+  ///
+  /// Supported values:
+  /// - Earliest: start from the coin's `sapling_activation_height`
+  /// - Height: start from a specific block height
+  /// - Date: start from a specific unix timestamp
+  final ZhtlcSyncParams? syncParams;
+
+  bool get isEmpty =>
+      (lightWalletDServers == null || lightWalletDServers!.isEmpty) &&
+      (electrum == null || electrum!.isEmpty) &&
+      syncParams == null;
+
+  JsonMap toJsonRequest({bool forLightWallet = false}) => {
     if (lightWalletDServers != null)
       'light_wallet_d_servers': lightWalletDServers,
-    if (electrum != null) ...{
-      'servers': electrum!.map((e) => e.toJsonRequest()).toList(),
-    },
-    if (syncParams != null) 'sync_params': syncParams,
+    if (electrum != null)
+      (forLightWallet ? 'electrum_servers' : 'servers'): electrum!
+          .map((e) => e.toJsonRequest())
+          .toList(),
+    if (syncParams != null) 'sync_params': syncParams!.toJsonRequest(),
   };
 }
 
+/// ZHTLC sync parameters shape for KDF API
+class ZhtlcSyncParams {
+  ZhtlcSyncParams._internal({this.height, this.date, this.isEarliest = false})
+    : assert(
+        (isEarliest ? 1 : 0) +
+                (height != null ? 1 : 0) +
+                (date != null ? 1 : 0) ==
+            1,
+        'Exactly one of earliest, height or date must be provided',
+      );
+
+  /// Start from coin's `sapling_activation_height`
+  factory ZhtlcSyncParams.earliest() =>
+      ZhtlcSyncParams._internal(isEarliest: true);
+
+  /// Start from a specific block height
+  factory ZhtlcSyncParams.height(int height) =>
+      ZhtlcSyncParams._internal(height: height);
+
+  /// Start from a specific unix timestamp
+  factory ZhtlcSyncParams.date(int unixTimestamp) =>
+      ZhtlcSyncParams._internal(date: unixTimestamp);
+
+  final int? height;
+  final int? date;
+  final bool isEarliest;
+
+  /// Best-effort parser supporting all documented and legacy shapes:
+  /// - "earliest"
+  /// - { "height": <int> }
+  /// - { "date": <int> }
+  /// - <int> (heuristic: < 1e9 => height, otherwise date)
+  static ZhtlcSyncParams? tryParse(dynamic value) {
+    if (value == null) return null;
+
+    if (value is String) {
+      if (value.toLowerCase() == 'earliest') {
+        return ZhtlcSyncParams.earliest();
+      }
+      // Unknown string value
+      return null;
+    }
+
+    if (value is int) {
+      // Heuristic: timestamps are typically >= 1,000,000,000 (10-digit seconds)
+      if (value >= 1000000000) {
+        return ZhtlcSyncParams.date(value);
+      }
+      return ZhtlcSyncParams.height(value);
+    }
+
+    if (value is Map) {
+      final map = value;
+      final dynamic heightVal = map['height'];
+      final dynamic dateVal = map['date'];
+
+      if (heightVal is int) {
+        return ZhtlcSyncParams.height(heightVal);
+      }
+      if (dateVal is int) {
+        return ZhtlcSyncParams.date(dateVal);
+      }
+      if ((map['earliest'] == true) ||
+          (map['type'] == 'earliest') ||
+          (map['type'] == 'Earliest')) {
+        return ZhtlcSyncParams.earliest();
+      }
+      return null;
+    }
+
+    return null;
+  }
+
+  /// JSON suitable for KDF API
+  /// - "earliest" | { "height": int } | { "date": int }
+  dynamic toJsonRequest() {
+    if (isEarliest) return 'earliest';
+    if (height != null) return {'height': height};
+    if (date != null) return {'date': date};
+    // Should not reach here due to constructor assert, but return null to be safe
+    return null;
+  }
+}
+
 /// Contains information about electrum servers for coins being used in 'Electrum'
 /// or 'Light' mode
 class ActivationServers {
diff --git a/packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/activation_params_index.dart b/packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/activation_params_index.dart
index 37411d396..03c7fd164 100644
--- a/packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/activation_params_index.dart
+++ b/packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/activation_params_index.dart
@@ -16,3 +16,5 @@ export 'slp_activation_params.dart';
 export 'tendermint_activation_params.dart';
 export 'utxo_activation_params.dart';
 export 'zhtlc_activation_params.dart';
+export 'package:komodo_defi_rpc_methods/src/common_structures/activation/activation_params/activation_params.dart'
+    show PrivKeyPolicySerializer;
diff --git a/packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/erc20_activation_params.dart b/packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/erc20_activation_params.dart
index 3ac6cb061..27ae65ecf 100644
--- a/packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/erc20_activation_params.dart
+++ b/packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/erc20_activation_params.dart
@@ -21,8 +21,11 @@ class Erc20ActivationParams extends ActivationParams {
 
   @override
   JsonMap toRpcParams() => super.toRpcParams().deepMerge({
-    'nodes': nodes.map((e) => e.url).toList(),
+    // Align with KDF API which expects node objects (url/gui_auth), not plain strings
+    'nodes': nodes.map((e) => e.toJson()).toList(),
     'swap_contract_address': swapContractAddress,
     'fallback_swap_contract': fallbackSwapContract,
+    // Ensure priv_key_policy uses the structured JSON object for EVM
+    'priv_key_policy': privKeyPolicy?.toJson(),
   });
 }
diff --git a/packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/eth_activation_params.dart b/packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/eth_activation_params.dart
index 2d86f87b9..5089c1c78 100644
--- a/packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/eth_activation_params.dart
+++ b/packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/eth_activation_params.dart
@@ -72,8 +72,9 @@ class EthWithTokensActivationParams extends ActivationParams {
       'fallback_swap_contract': fallbackSwapContract,
       'erc20_tokens_requests': erc20Tokens.map((e) => e.toJson()).toList(),
       if (txHistory != null) 'tx_history': txHistory,
-      // override privKeyPolicy to ensure it is in the expected enum format
-      'priv_key_policy': privKeyPolicy?.toJson(),
+      // Override priv_key_policy with object form for ETH/ERC20
+      'priv_key_policy':
+          (privKeyPolicy ?? const PrivateKeyPolicy.contextPrivKey()).toJson(),
     };
   }
 }
diff --git a/packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/zhtlc_activation_params.dart b/packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/zhtlc_activation_params.dart
index 6df56f8f3..0b1fac575 100644
--- a/packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/zhtlc_activation_params.dart
+++ b/packages/komodo_defi_rpc_methods/lib/src/common_structures/activation/activation_params/zhtlc_activation_params.dart
@@ -1,6 +1,94 @@
 import 'package:komodo_defi_rpc_methods/src/internal_exports.dart';
+import 'package:komodo_defi_types/komodo_defi_type_utils.dart';
 
 /// ZHTLC activation parameters
 ///
-/// Aliased to [ActivationParams] as there are no unique parameters for ZHTLC.
-typedef ZhtlcActivationParams = ActivationParams;
+/// Extends [ActivationParams] to ensure correct Light wallet mode is used
+/// and that ZHTLC-specific defaults are applied.
+class ZhtlcActivationParams extends ActivationParams {
+  const ZhtlcActivationParams({
+    required super.mode,
+    super.requiredConfirmations,
+    super.requiresNotarization = false,
+    super.privKeyPolicy = const PrivateKeyPolicy.contextPrivKey(),
+    super.minAddressesNumber,
+    super.scanPolicy,
+    super.gapLimit,
+    this.zcashParamsPath,
+    this.scanBlocksPerIteration,
+    this.scanIntervalMs,
+  });
+
+  factory ZhtlcActivationParams.fromConfigJson(JsonMap json) {
+    // ZHTLC coins use Light wallet mode
+    final mode = ActivationMode.fromConfig(
+      json,
+      type: ActivationModeType.lightWallet,
+    );
+
+    final base = ActivationParams.fromConfigJson(json);
+
+    return ZhtlcActivationParams(
+      mode: mode,
+      requiredConfirmations: base.requiredConfirmations,
+      requiresNotarization: base.requiresNotarization,
+      privKeyPolicy: base.privKeyPolicy,
+      minAddressesNumber: base.minAddressesNumber,
+      scanPolicy: base.scanPolicy,
+      gapLimit: base.gapLimit,
+      zcashParamsPath: json.valueOrNull<String>('zcash_params_path'),
+      scanBlocksPerIteration: json.valueOrNull<int>(
+        'scan_blocks_per_iteration',
+      ),
+      scanIntervalMs: json.valueOrNull<int>('scan_interval_ms'),
+    );
+  }
+
+  @override
+  JsonMap toRpcParams() => super.toRpcParams().deepMerge({
+    if (zcashParamsPath != null) 'zcash_params_path': zcashParamsPath,
+    if (scanBlocksPerIteration != null)
+      'scan_blocks_per_iteration': scanBlocksPerIteration,
+    if (scanIntervalMs != null) 'scan_interval_ms': scanIntervalMs,
+  });
+
+  ZhtlcActivationParams copyWith({
+    ActivationMode? mode,
+    int? requiredConfirmations,
+    bool? requiresNotarization,
+    PrivateKeyPolicy? privKeyPolicy,
+    int? minAddressesNumber,
+    ScanPolicy? scanPolicy,
+    int? gapLimit,
+    String? zcashParamsPath,
+    int? scanBlocksPerIteration,
+    int? scanIntervalMs,
+  }) {
+    return ZhtlcActivationParams(
+      mode: mode ?? this.mode,
+      requiredConfirmations:
+          requiredConfirmations ?? this.requiredConfirmations,
+      requiresNotarization: requiresNotarization ?? this.requiresNotarization,
+      privKeyPolicy: privKeyPolicy ?? this.privKeyPolicy,
+      minAddressesNumber: minAddressesNumber ?? this.minAddressesNumber,
+      scanPolicy: scanPolicy ?? this.scanPolicy,
+      gapLimit: gapLimit ?? this.gapLimit,
+      zcashParamsPath: zcashParamsPath ?? this.zcashParamsPath,
+      scanBlocksPerIteration:
+          scanBlocksPerIteration ?? this.scanBlocksPerIteration,
+      scanIntervalMs: scanIntervalMs ?? this.scanIntervalMs,
+    );
+  }
+
+  /// ZHTLC coins only. Path to folder containing Zcash parameters.
+  /// Optional, defaults to standard location.
+  final String? zcashParamsPath;
+
+  /// ZHTLC coins only. Sets the number of scanned blocks per iteration during
+  /// BuildingWalletDb state. Optional, default value is 1000.
+  final int? scanBlocksPerIteration;
+
+  /// ZHTLC coins only. Sets the interval in milliseconds between iterations of
+  /// BuildingWalletDb state. Optional, default value is 0.
+  final int? scanIntervalMs;
+}
diff --git a/packages/komodo_defi_rpc_methods/lib/src/common_structures/orderbook/order_address.dart b/packages/komodo_defi_rpc_methods/lib/src/common_structures/orderbook/order_address.dart
new file mode 100644
index 000000000..123f92cd9
--- /dev/null
+++ b/packages/komodo_defi_rpc_methods/lib/src/common_structures/orderbook/order_address.dart
@@ -0,0 +1,52 @@
+import 'package:komodo_defi_types/komodo_defi_type_utils.dart';
+
+/// Structured address used within orderbook responses.
+class OrderAddress {
+  const OrderAddress({required this.addressData, required this.addressType});
+
+  factory OrderAddress.fromJson(JsonMap json) {
+    final addressData = json.valueOrNull<String>('address_data');
+    final typeValue = json.valueOrNull<String>('address_type');
+
+    if (typeValue == null) {
+      throw ArgumentError('Key "address_type" not found in Map');
+    }
+
+    return OrderAddress(
+      addressData: addressData,
+      addressType: OrderAddressType.fromJson(typeValue),
+    );
+  }
+
+  /// Address payload when nested under `address_data`.
+  final String? addressData;
+
+  /// Address type descriptor (e.g. Transparent, Shielded).
+  final OrderAddressType addressType;
+
+  Map<String, dynamic> toJson() => {
+    'address_data': addressData,
+    'address_type': addressType.toJson(),
+  };
+}
+
+/// Available address types returned by the orderbook API.
+enum OrderAddressType {
+  transparent('Transparent'),
+  shielded('Shielded');
+
+  const OrderAddressType(this.value);
+
+  final String value;
+
+  /// Parses an [OrderAddressType] from its JSON representation.
+  static OrderAddressType fromJson(String source) {
+    return OrderAddressType.values.firstWhere(
+      (type) => type.value.toLowerCase() == source.toLowerCase(),
+      orElse: () => throw ArgumentError('Unknown address type: $source'),
+    );
+  }
+
+  /// Converts this enum to its JSON string representation.
+  String toJson() => value;
+}
diff --git a/packages/komodo_defi_rpc_methods/lib/src/common_structures/orderbook/order_info.dart b/packages/komodo_defi_rpc_methods/lib/src/common_structures/orderbook/order_info.dart
index 1f6bf326e..068c04662 100644
--- a/packages/komodo_defi_rpc_methods/lib/src/common_structures/orderbook/order_info.dart
+++ b/packages/komodo_defi_rpc_methods/lib/src/common_structures/orderbook/order_info.dart
@@ -1,187 +1,141 @@
+import 'package:komodo_defi_rpc_methods/src/common_structures/orderbook/order_address.dart';
+import 'package:komodo_defi_rpc_methods/src/common_structures/primitive/numeric_value.dart';
+import 'package:komodo_defi_rpc_methods/src/common_structures/trading/order_status.dart'
+    show OrderConfirmationSettings;
 import 'package:komodo_defi_types/komodo_defi_type_utils.dart';
-import 'package:rational/rational.dart';
-import '../primitive/mm2_rational.dart';
-import '../primitive/fraction.dart';
 
 /// Represents information about an order in the orderbook.
-/// 
+///
 /// This class contains all the essential details about a trading order,
 /// including pricing, volume constraints, and metadata about the order creator.
 /// It's used to represent both bid and ask orders in orderbook responses.
 class OrderInfo {
   /// Creates a new [OrderInfo] instance.
-  /// 
-  /// All parameters are required and represent core order attributes:
-  /// - [uuid]: Unique identifier for the order
-  /// - [price]: The price per unit in rel coin
-  /// - [maxVolume]: Maximum volume available for this order
-  /// - [minVolume]: Minimum volume that must be traded
-  /// - [pubkey]: Public key of the order creator
-  /// - [age]: Age of the order in seconds
-  /// - [zcredits]: Zero-knowledge credits associated with the order
-  /// - [coin]: The coin being offered in this order
-  /// - [address]: The address associated with this order
-  OrderInfo({
-    required this.uuid,
-    required this.price,
-    required this.maxVolume,
-    required this.minVolume,
-    required this.pubkey,
-    required this.age,
-    required this.zcredits,
-    required this.coin,
-    required this.address,
-    this.priceFraction,
-    this.priceRat,
-    this.maxVolumeFraction,
-    this.maxVolumeRat,
-    this.minVolumeFraction,
-    this.minVolumeRat,
+  ///
+  /// All parameters are optional to allow partial payloads from the API.
+  const OrderInfo({
+    this.uuid,
+    this.address,
+    this.baseMaxVolume,
+    this.baseMaxVolumeAggregated,
+    this.baseMinVolume,
+    this.coin,
+    this.confSettings,
+    this.isMine,
+    this.price,
+    this.pubkey,
+    this.relMaxVolume,
+    this.relMaxVolumeAggregated,
+    this.relMinVolume,
   });
 
   /// Creates an [OrderInfo] instance from a JSON map.
-  /// 
-  /// Expects the following keys in the JSON:
-  /// - `uuid`: String - Unique order identifier
-  /// - `price`: String - Price per unit
-  /// - `max_volume`: String - Maximum tradeable volume
-  /// - `min_volume`: String - Minimum tradeable volume
-  /// - `pubkey`: String - Order creator's public key
-  /// - `age`: int - Order age in seconds
-  /// - `zcredits`: int - Zero-knowledge credits
-  /// - `coin`: String - Coin ticker
-  /// - `address`: String - Associated address
+  ///
+  /// Parses only the v2 orderbook schema fields without legacy fallbacks.
   factory OrderInfo.fromJson(JsonMap json) {
+    final priceJson = json.valueOrNull<JsonMap>('price');
+    final baseMaxVolumeJson = json.valueOrNull<JsonMap>('base_max_volume');
+    final baseMaxVolumeAggrJson = json.valueOrNull<JsonMap>(
+      'base_max_volume_aggr',
+    );
+    final baseMinVolumeJson = json.valueOrNull<JsonMap>('base_min_volume');
+    final relMaxVolumeJson = json.valueOrNull<JsonMap>('rel_max_volume');
+    final relMaxVolumeAggrJson = json.valueOrNull<JsonMap>(
+      'rel_max_volume_aggr',
+    );
+    final relMinVolumeJson = json.valueOrNull<JsonMap>('rel_min_volume');
+    final addressJson = json.valueOrNull<JsonMap>('address');
+    final confSettingsJson = json.valueOrNull<JsonMap>('conf_settings');
+
     return OrderInfo(
-      uuid: json.value<String>('uuid'),
-      price: json.value<String>('price'),
-      maxVolume: json.value<String>('max_volume'),
-      minVolume: json.value<String>('min_volume'),
-      pubkey: json.value<String>('pubkey'),
-      age: json.value<int>('age'),
-      zcredits: json.value<int>('zcredits'),
-      coin: json.value<String>('coin'),
-      address: json.value<String>('address'),
-      priceFraction:
-          json.valueOrNull<JsonMap>('price_fraction') != null
-              ? Fraction.fromJson(json.value<JsonMap>('price_fraction'))
-              : null,
-      priceRat:
-          json.valueOrNull<List<dynamic>>('price_rat') != null
-              ? rationalFromMm2(json.value<List<dynamic>>('price_rat'))
-              : null,
-      maxVolumeFraction:
-          json.valueOrNull<JsonMap>('max_volume_fraction') != null
-              ? Fraction.fromJson(json.value<JsonMap>('max_volume_fraction'))
-              : null,
-      maxVolumeRat:
-          json.valueOrNull<List<dynamic>>('max_volume_rat') != null
-              ? rationalFromMm2(json.value<List<dynamic>>('max_volume_rat'))
-              : null,
-      minVolumeFraction:
-          json.valueOrNull<JsonMap>('min_volume_fraction') != null
-              ? Fraction.fromJson(json.value<JsonMap>('min_volume_fraction'))
-              : null,
-      minVolumeRat:
-          json.valueOrNull<List<dynamic>>('min_volume_rat') != null
-              ? rationalFromMm2(json.value<List<dynamic>>('min_volume_rat'))
-              : null,
+      uuid: json.valueOrNull<String>('uuid'),
+      coin: json.valueOrNull<String>('coin'),
+      pubkey: json.valueOrNull<String>('pubkey'),
+      isMine: json.valueOrNull<bool>('is_mine'),
+      price: priceJson != null ? NumericValue.fromJson(priceJson) : null,
+      baseMaxVolume: baseMaxVolumeJson != null
+          ? NumericValue.fromJson(baseMaxVolumeJson)
+          : null,
+      baseMaxVolumeAggregated: baseMaxVolumeAggrJson != null
+          ? NumericValue.fromJson(baseMaxVolumeAggrJson)
+          : null,
+      baseMinVolume: baseMinVolumeJson != null
+          ? NumericValue.fromJson(baseMinVolumeJson)
+          : null,
+      relMaxVolume: relMaxVolumeJson != null
+          ? NumericValue.fromJson(relMaxVolumeJson)
+          : null,
+      relMaxVolumeAggregated: relMaxVolumeAggrJson != null
+          ? NumericValue.fromJson(relMaxVolumeAggrJson)
+          : null,
+      relMinVolume: relMinVolumeJson != null
+          ? NumericValue.fromJson(relMinVolumeJson)
+          : null,
+      address: addressJson != null ? OrderAddress.fromJson(addressJson) : null,
+      confSettings: confSettingsJson != null
+          ? OrderConfirmationSettings.fromJson(confSettingsJson)
+          : null,
     );
   }
 
-  /// Unique identifier for this order.
-  /// 
-  /// This UUID is used to reference the order in subsequent operations
-  /// such as order matching or cancellation.
-  final String uuid;
-
-  /// The price per unit for this order.
-  /// 
-  /// Expressed as a string to maintain precision. This represents the
-  /// exchange rate between the base and rel coins.
-  final String price;
-
-  /// Maximum volume available for trading in this order.
-  /// 
-  /// This is the total amount of the coin that can be traded through
-  /// this order. Expressed as a string to maintain precision.
-  final String maxVolume;
-
-  /// Minimum volume that must be traded.
-  /// 
-  /// Orders cannot be partially filled below this threshold. This helps
-  /// prevent dust trades and ensures economically viable transactions.
-  /// Expressed as a string to maintain precision.
-  final String minVolume;
-
-  /// Public key of the order creator.
-  /// 
-  /// This identifies the node that created the order and is used for
-  /// P2P communication during swap negotiation.
-  final String pubkey;
-
-  /// Age of the order in seconds.
-  /// 
-  /// Indicates how long ago this order was created. Useful for sorting
-  /// orders by recency or implementing time-based order preferences.
-  final int age;
-
-  /// Zero-knowledge credits associated with this order.
-  /// 
-  /// Used in privacy-enhanced trading to manage reputation and trading
-  /// privileges without revealing identity.
-  final int zcredits;
-
-  /// The coin ticker for this order.
-  /// 
-  /// Identifies which coin is being offered in this order.
-  final String coin;
-
-  /// The address associated with this order.
-  /// 
-  /// This is typically the address that will receive funds in a swap
-  /// involving this order.
-  final String address;
-
-  /// Optional fractional representation of the price
-  final Fraction? priceFraction;
-
-  /// Optional rational representation of the price
-  final Rational? priceRat;
-
-  /// Optional fractional representation of the maximum volume
-  final Fraction? maxVolumeFraction;
-
-  /// Optional rational representation of the maximum volume
-  final Rational? maxVolumeRat;
-
-  /// Optional fractional representation of the minimum volume
-  final Fraction? minVolumeFraction;
-
-  /// Optional rational representation of the minimum volume
-  final Rational? minVolumeRat;
+  /// Unique identifier for this order, if provided.
+  final String? uuid;
+
+  /// Optional structured address information for the order maker.
+  final OrderAddress? address;
+
+  /// Optional maximum base volume.
+  final NumericValue? baseMaxVolume;
+
+  /// Optional aggregated maximum base volume across orderbook depth.
+  final NumericValue? baseMaxVolumeAggregated;
+
+  /// Optional minimum base volume.
+  final NumericValue? baseMinVolume;
+
+  /// Optional coin ticker.
+  final String? coin;
+
+  /// Optional confirmation settings supplied by the API.
+  final OrderConfirmationSettings? confSettings;
+
+  /// Indicates whether the order belongs to the current wallet.
+  final bool? isMine;
+
+  /// Optional price for the order.
+  final NumericValue? price;
+
+  /// Optional public key of the order creator.
+  final String? pubkey;
+
+  /// Optional maximum rel volume.
+  final NumericValue? relMaxVolume;
+
+  /// Optional aggregated maximum rel volume across orderbook depth.
+  final NumericValue? relMaxVolumeAggregated;
+
+  /// Optional minimum rel volume.
+  final NumericValue? relMinVolume;
 
   /// Converts this [OrderInfo] instance to a JSON map.
-  /// 
+  ///
   /// The resulting map can be serialized to JSON and will contain all
   /// the order information in the expected API format.
-  Map<String, dynamic> toJson() => {
-    'uuid': uuid,
-    'price': price,
-    'max_volume': maxVolume,
-    'min_volume': minVolume,
-    'pubkey': pubkey,
-    'age': age,
-    'zcredits': zcredits,
-    'coin': coin,
-    'address': address,
-    if (priceFraction != null) 'price_fraction': priceFraction!.toJson(),
-    if (priceRat != null) 'price_rat': rationalToMm2(priceRat!),
-    if (maxVolumeFraction != null)
-      'max_volume_fraction': maxVolumeFraction!.toJson(),
-    if (maxVolumeRat != null) 'max_volume_rat': rationalToMm2(maxVolumeRat!),
-    if (minVolumeFraction != null)
-      'min_volume_fraction': minVolumeFraction!.toJson(),
-    if (minVolumeRat != null) 'min_volume_rat': rationalToMm2(minVolumeRat!),
-  };
-}
\ No newline at end of file
+  Map<String, dynamic> toJson() {
+    return <String, dynamic>{
+      'uuid': ?uuid,
+      'coin': ?coin,
+      'pubkey': ?pubkey,
+      'is_mine': ?isMine,
+      'price': ?price?.toJson(),
+      'base_max_volume': ?baseMaxVolume?.toJson(),
+      'base_max_volume_aggr': ?baseMaxVolumeAggregated?.toJson(),
+      'base_min_volume': ?baseMinVolume?.toJson(),
+      'rel_max_volume': ?relMaxVolume?.toJson(),
+      'rel_max_volume_aggr': ?relMaxVolumeAggregated?.toJson(),
+      'rel_min_volume': ?relMinVolume?.toJson(),
+      'address': ?address?.toJson(),
+      'conf_settings': ?confSettings?.toJson(),
+    };
+  }
+}
diff --git a/packages/komodo_defi_rpc_methods/lib/src/common_structures/pagination/pagination.dart b/packages/komodo_defi_rpc_methods/lib/src/common_structures/pagination/pagination.dart
index 1c5f072be..97597d444 100644
--- a/packages/komodo_defi_rpc_methods/lib/src/common_structures/pagination/pagination.dart
+++ b/packages/komodo_defi_rpc_methods/lib/src/common_structures/pagination/pagination.dart
@@ -1,5 +1,18 @@
 class Pagination {
   Pagination({this.fromId, this.pageNumber});
+
+  factory Pagination.fromJson(Map<String, dynamic> json) {
+    final dynamic rawFromId =
+        json['FromId'] ?? json['from_id'] ?? json['fromId'];
+    final dynamic rawPageNumber =
+        json['PageNumber'] ?? json['page_number'] ?? json['pageNumber'];
+
+    return Pagination(
+      fromId: rawFromId?.toString(),
+      pageNumber: rawPageNumber is num ? rawPageNumber.toInt() : null,
+    );
+  }
+
   final String? fromId;
   final int? pageNumber;
 
diff --git a/packages/komodo_defi_rpc_methods/lib/src/common_structures/primitive/numeric_value.dart b/packages/komodo_defi_rpc_methods/lib/src/common_structures/primitive/numeric_value.dart
index 76b602d0a..5c9f74202 100644
--- a/packages/komodo_defi_rpc_methods/lib/src/common_structures/primitive/numeric_value.dart
+++ b/packages/komodo_defi_rpc_methods/lib/src/common_structures/primitive/numeric_value.dart
@@ -1,25 +1,82 @@
-// class NumericValue {
-//   final String decimal;
-//   final List<List<int>> rational;
-//   final Map<String, String> fraction;
-
-//   NumericValue({
-//     required this.decimal,
-//     required this.rational,
-//     required this.fraction,
-//   });
-
-//   factory NumericValue.fromJson(Map<String, dynamic> json) => NumericValue(
-//         decimal: json['decimal'],
-//         rational: List<List<int>>.from(
-//             json['rational'].map((x) => List<int>.from(x))),
-//         fraction: Map.from(json['fraction'])
-//             .map((k, v) => MapEntry<String, String>(k, v.toString())),
-//       );
-
-//   Map<String, dynamic> toJson() => {
-//         'decimal': decimal,
-//         'rational': rational,
-//         'fraction': fraction,
-//       };
-// }
+import 'package:komodo_defi_rpc_methods/src/common_structures/primitive/fraction.dart';
+import 'package:komodo_defi_rpc_methods/src/common_structures/primitive/mm2_rational.dart';
+import 'package:komodo_defi_types/komodo_defi_type_utils.dart';
+import 'package:rational/rational.dart';
+
+/// Represents a numeric value returned by MM2 APIs that can include
+/// decimal, fraction, and rational representations.
+class NumericValue {
+  NumericValue({required this.decimal, this.fraction, this.rational});
+
+  /// Parses a [NumericValue] from a JSON map.
+  factory NumericValue.fromJson(JsonMap json) {
+    final decimalValue =
+        json.valueOrNull<String>('decimal') ?? json['decimal']?.toString();
+
+    if (decimalValue == null) {
+      throw ArgumentError('Key "decimal" not found in Map');
+    }
+
+    final fractionJson = json.valueOrNull<JsonMap>('fraction');
+    final rationalJson = json.valueOrNull<List<dynamic>>('rational');
+
+    return NumericValue(
+      decimal: decimalValue,
+      fraction: fractionJson != null ? Fraction.fromJson(fractionJson) : null,
+      rational: rationalJson != null ? rationalFromMm2(rationalJson) : null,
+    );
+  }
+
+  /// Attempts to parse a [NumericValue] from any supported JSON structure.
+  ///
+  /// Returns `null` if the input is null or cannot be parsed.
+  static NumericValue? tryParse(dynamic data) {
+    if (data == null) return null;
+    if (data is NumericValue) return data;
+
+    if (data is String) {
+      return NumericValue(decimal: data);
+    }
+
+    if (data is num) {
+      return NumericValue(decimal: data.toString());
+    }
+
+    JsonMap? asMap;
+
+    if (data is JsonMap) {
+      asMap = data;
+    } else if (data is Map) {
+      asMap = <String, dynamic>{};
+      data.forEach((key, value) {
+        asMap![key.toString()] = value;
+      });
+    }
+
+    if (asMap != null) {
+      try {
+        return NumericValue.fromJson(asMap);
+      } catch (_) {
+        return null;
+      }
+    }
+
+    return null;
+  }
+
+  /// Decimal string representation of the numeric value.
+  final String decimal;
+
+  /// Fractional representation, if available.
+  final Fraction? fraction;
+
+  /// Rational representation, if available.
+  final Rational? rational;
+
+  /// Converts this numeric value back to JSON format used by MM2 APIs.
+  Map<String, dynamic> toJson() => {
+    'decimal': decimal,
+    'fraction': ?fraction?.toJson(),
+    if (rational != null) 'rational': rationalToMm2(rational!),
+  };
+}
diff --git a/packages/komodo_defi_rpc_methods/lib/src/rpc_methods/transaction_history/my_tx_history.dart b/packages/komodo_defi_rpc_methods/lib/src/rpc_methods/transaction_history/my_tx_history.dart
index 58f9fdde3..c4ce56cf8 100644
--- a/packages/komodo_defi_rpc_methods/lib/src/rpc_methods/transaction_history/my_tx_history.dart
+++ b/packages/komodo_defi_rpc_methods/lib/src/rpc_methods/transaction_history/my_tx_history.dart
@@ -87,11 +87,13 @@ class MyTxHistoryResponse extends BaseResponse {
     required this.total,
     required this.totalPages,
     required this.pageNumber,
+    required this.pagingOptions,
     required this.transactions,
   });
 
   factory MyTxHistoryResponse.parse(Map<String, dynamic> json) {
     final result = json.value<JsonMap>('result');
+    final pagingOptionsJson = result.valueOrNull<JsonMap>('paging_options');
     return MyTxHistoryResponse(
       mmrpc: json.valueOrNull<String>('mmrpc'),
       currentBlock: result.value<int>('current_block'),
@@ -104,11 +106,13 @@ class MyTxHistoryResponse extends BaseResponse {
       total: result.value<int>('total'),
       totalPages: result.value<int>('total_pages'),
       pageNumber: result.valueOrNull<int>('page_number'),
-      transactions:
-          result
-              .value<JsonList>('transactions')
-              .map(TransactionInfo.fromJson)
-              .toList(),
+      pagingOptions: pagingOptionsJson != null
+          ? Pagination.fromJson(pagingOptionsJson)
+          : null,
+      transactions: result
+          .value<JsonList>('transactions')
+          .map(TransactionInfo.fromJson)
+          .toList(),
     );
   }
 
@@ -122,6 +126,7 @@ class MyTxHistoryResponse extends BaseResponse {
     total: 0,
     totalPages: 0,
     pageNumber: null,
+    pagingOptions: null,
     transactions: const [],
   );
 
@@ -133,6 +138,7 @@ class MyTxHistoryResponse extends BaseResponse {
   final int total;
   final int totalPages;
   final int? pageNumber;
+  final Pagination? pagingOptions;
   final List<TransactionInfo> transactions;
 
   @override
@@ -147,6 +153,7 @@ class MyTxHistoryResponse extends BaseResponse {
       'total': total,
       'total_pages': totalPages,
       if (pageNumber != null) 'page_number': pageNumber,
+      if (pagingOptions != null) 'paging_options': pagingOptions!.toJson(),
       'transactions': transactions.map((tx) => tx.toJson()).toList(),
     },
   };
diff --git a/packages/komodo_defi_rpc_methods/lib/src/rpc_methods/zhtlc/zhtlc_rpc_namespace.dart b/packages/komodo_defi_rpc_methods/lib/src/rpc_methods/zhtlc/zhtlc_rpc_namespace.dart
index 7edb29841..46cb17cbe 100644
--- a/packages/komodo_defi_rpc_methods/lib/src/rpc_methods/zhtlc/zhtlc_rpc_namespace.dart
+++ b/packages/komodo_defi_rpc_methods/lib/src/rpc_methods/zhtlc/zhtlc_rpc_namespace.dart
@@ -29,6 +29,45 @@ class ZhtlcMethodsNamespace extends BaseRpcMethodNamespace {
       ),
     );
   }
+
+  Future<UserActionResponse> enableZhtlcUserAction({
+    required int taskId,
+    required String actionType,
+    String? pin,
+    String? passphrase,
+  }) {
+    return execute(
+      TaskEnableZhtlcUserAction(
+        taskId: taskId,
+        actionType: actionType,
+        pin: pin,
+        passphrase: passphrase,
+        rpcPass: rpcPass,
+      ),
+    );
+  }
+
+  /// For Trezor support flows using the legacy/user-action RPC name
+  Future<UserActionResponse> initZCoinUserAction({
+    required int taskId,
+    required String actionType,
+    String? pin,
+    String? passphrase,
+  }) {
+    return execute(
+      TaskInitZCoinUserAction(
+        taskId: taskId,
+        actionType: actionType,
+        pin: pin,
+        passphrase: passphrase,
+        rpcPass: rpcPass,
+      ),
+    );
+  }
+
+  Future<ZhtlcCancelResponse> enableZhtlcCancel({required int taskId}) {
+    return execute(TaskEnableZhtlcCancel(taskId: taskId, rpcPass: rpcPass));
+  }
 }
 
 // Also adding ZHTLC task requests:
@@ -59,6 +98,119 @@ class TaskEnableZhtlcInit
   }
 }
 
+class TaskEnableZhtlcUserAction
+    extends BaseRequest<UserActionResponse, GeneralErrorResponse> {
+  TaskEnableZhtlcUserAction({
+    required this.taskId,
+    required this.actionType,
+    this.pin,
+    this.passphrase,
+    super.rpcPass,
+  }) : super(method: 'task::enable_z_coin::user_action', mmrpc: RpcVersion.v2_0);
+
+  final int taskId;
+  final String actionType;
+  final String? pin;
+  final String? passphrase;
+
+  @override
+  JsonMap toJson() => {
+    ...super.toJson(),
+    'userpass': rpcPass,
+    'mmrpc': mmrpc,
+    'method': method,
+    'params': {
+      'task_id': taskId,
+      'user_action': {
+        'action_type': actionType,
+        if (pin != null) 'pin': pin,
+        if (passphrase != null) 'passphrase': passphrase,
+      },
+    },
+  };
+
+  @override
+  UserActionResponse parse(JsonMap json) {
+    return UserActionResponse.parse(json);
+  }
+}
+
+/// Trezor-specific user action endpoint used by some environments
+class TaskInitZCoinUserAction
+    extends BaseRequest<UserActionResponse, GeneralErrorResponse> {
+  TaskInitZCoinUserAction({
+    required this.taskId,
+    required this.actionType,
+    this.pin,
+    this.passphrase,
+    super.rpcPass,
+  }) : super(method: 'init_z_coin_user_action', mmrpc: RpcVersion.v2_0);
+
+  final int taskId;
+  final String actionType;
+  final String? pin;
+  final String? passphrase;
+
+  @override
+  JsonMap toJson() => {
+    ...super.toJson(),
+    'userpass': rpcPass,
+    'mmrpc': mmrpc,
+    'method': method,
+    'params': {
+      'task_id': taskId,
+      'user_action': {
+        'action_type': actionType,
+        if (pin != null) 'pin': pin,
+        if (passphrase != null) 'passphrase': passphrase,
+      },
+    },
+  };
+
+  @override
+  UserActionResponse parse(JsonMap json) {
+    return UserActionResponse.parse(json);
+  }
+}
+
+class TaskEnableZhtlcCancel
+    extends BaseRequest<ZhtlcCancelResponse, GeneralErrorResponse> {
+  TaskEnableZhtlcCancel({required this.taskId, super.rpcPass})
+    : super(method: 'task::enable_z_coin::cancel', mmrpc: '2.0');
+
+  final int taskId;
+
+  @override
+  JsonMap toJson() => {
+    ...super.toJson(),
+    'userpass': rpcPass,
+    'mmrpc': mmrpc,
+    'method': method,
+    'params': {'task_id': taskId},
+  };
+
+  @override
+  ZhtlcCancelResponse parse(Map<String, dynamic> json) {
+    return ZhtlcCancelResponse.parse(json);
+  }
+}
+
+class ZhtlcCancelResponse extends BaseResponse {
+  ZhtlcCancelResponse({required super.mmrpc, required this.result});
+
+  factory ZhtlcCancelResponse.parse(Map<String, dynamic> json) {
+    return ZhtlcCancelResponse(
+      mmrpc: json.value<String>('mmrpc'),
+      result: json.value<String>('result'),
+    );
+  }
+
+  final String result;
+
+  @override
+  JsonMap toJson() => {'mmrpc': mmrpc, 'result': result};
+}
+
 class TaskEnableZhtlcStatus
     extends BaseRequest<TaskStatusResponse, GeneralErrorResponse> {
   TaskEnableZhtlcStatus({
diff --git a/packages/komodo_defi_rpc_methods/test/fixtures/orderbook/orderbook_response.json b/packages/komodo_defi_rpc_methods/test/fixtures/orderbook/orderbook_response.json
new file mode 100644
index 000000000..315cb989d
--- /dev/null
+++ b/packages/komodo_defi_rpc_methods/test/fixtures/orderbook/orderbook_response.json
@@ -0,0 +1,246 @@
+{
+  "mmrpc": "2.0",
+  "result": {
+    "asks": [
+      {
+        "coin": "DGB",
+        "address": {
+          "address_type": "Transparent",
+          "address_data": "DEsCggcN3WNmaTkF2WpqoMQqx4JGQrLbPS"
+        },
+        "price": {
+          "decimal": "0.0002658065",
+          "rational": [
+            [1, [531613]],
+            [1, [2000000000]]
+          ],
+          "fraction": {
+            "numer": "531613",
+            "denom": "2000000000"
+          }
+        },
+        "pubkey": "03de96cb66dcfaceaa8b3d4993ce8914cd5fe84e3fd53cefdae45add8032792a12",
+        "uuid": "1115d7f2-a7b9-4ab1-913f-497db2549a2b",
+        "is_mine": false,
+        "base_max_volume": {
+          "decimal": "90524.256020352",
+          "rational": [
+            [1, [2846113615, 164]],
+            [1, [7812500]]
+          ],
+          "fraction": {
+            "numer": "707220750159",
+            "denom": "7812500"
+          }
+        },
+        "base_min_volume": {
+          "decimal": "0.3762135237475381527539770472129161626973004798603495399849138376977237200745655204067620618758382508",
+          "rational": [
+            [1, [200000]],
+            [1, [531613]]
+          ],
+          "fraction": {
+            "numer": "200000",
+            "denom": "531613"
+          }
+        },
+        "rel_max_volume": {
+          "decimal": "24.061935657873693888",
+          "rational": [
+            [1, [4213143411, 87536811]],
+            [1, [3466432512, 3637978]]
+          ],
+          "fraction": {
+            "numer": "375967744654276467",
+            "denom": "15625000000000000"
+          }
+        },
+        "rel_min_volume": {
+          "decimal": "0.0001",
+          "rational": [
+            [1, [1]],
+            [1, [10000]]
+          ],
+          "fraction": {
+            "numer": "1",
+            "denom": "10000"
+          }
+        },
+        "conf_settings": {
+          "base_confs": 7,
+          "base_nota": false,
+          "rel_confs": 2,
+          "rel_nota": false
+        },
+        "base_max_volume_aggr": {
+          "decimal": "133319.023345413",
+          "rational": [
+            [1, [3238477573, 31040]],
+            [1, [1000000000]]
+          ],
+          "fraction": {
+            "numer": "133319023345413",
+            "denom": "1000000000"
+          }
+        },
+        "rel_max_volume_aggr": {
+          "decimal": "35.2500366381728643576",
+          "rational": [
+            [1, [473921343, 1669176307, 2]],
+            [1, [2436694016, 291038304]]
+          ],
+          "fraction": {
+            "numer": "44062545797716080447",
+            "denom": "1250000000000000000"
+          }
+        }
+      }
+    ],
+    "base": "DGB",
+    "bids": [
+      {
+        "coin": "DASH",
+        "address": {
+          "address_type": "Transparent",
+          "address_data": "XcYdfQgeuM5f5V2LNo9g8o8p3rPPbKwwCg"
+        },
+        "price": {
+          "decimal": "0.0002544075418788651605521516540338523799763700988224165198319218986992534200426899830070024093907274001",
+          "rational": [
+            [1, [1410065408, 2]],
+            [1, [3765089107, 9151]]
+          ],
+          "fraction": {
+            "numer": "10000000000",
+            "denom": "39307010814803"
+          }
+        },
+        "pubkey": "0315d9c51c657ab1be4ae9d3ab6e76a619d3bccfe830d5363fa168424c0d044732",
+        "uuid": "e9e4feb2-60b4-4184-8294-591687171e6b",
+        "is_mine": false,
+        "base_max_volume": {
+          "decimal": "15449.5309493280527473176",
+          "rational": [
+            [1, [161102659, 3869502237, 1046]],
+            [1, [2436694016, 291038304]]
+          ],
+          "fraction": {
+            "numer": "19311913686660065934147",
+            "denom": "1250000000000000000"
+          }
+        },
+        "base_min_volume": {
+          "decimal": "0.39307010814803",
+          "rational": [
+            [1, [3765089107, 9151]],
+            [1, [276447232, 23283]]
+          ],
+          "fraction": {
+            "numer": "39307010814803",
+            "denom": "100000000000000"
+          }
+        },
+        "rel_max_volume": {
+          "decimal": "3.930477192",
+          "rational": [
+            [1, [491309649]],
+            [1, [125000000]]
+          ],
+          "fraction": {
+            "numer": "491309649",
+            "denom": "125000000"
+          }
+        },
+        "rel_min_volume": {
+          "decimal": "0.0001",
+          "rational": [
+            [1, [1]],
+            [1, [10000]]
+          ],
+          "fraction": {
+            "numer": "1",
+            "denom": "10000"
+          }
+        },
+        "conf_settings": {
+          "base_confs": 7,
+          "base_nota": false,
+          "rel_confs": 2,
+          "rel_nota": false
+        },
+        "base_max_volume_aggr": {
+          "decimal": "15449.5309493280527473176",
+          "rational": [
+            [1, [161102659, 3869502237, 1046]],
+            [1, [2436694016, 291038304]]
+          ],
+          "fraction": {
+            "numer": "19311913686660065934147",
+            "denom": "1250000000000000000"
+          }
+        },
+        "rel_max_volume_aggr": {
+          "decimal": "3.930477192",
+          "rational": [
+            [1, [491309649]],
+            [1, [125000000]]
+          ],
+          "fraction": {
+            "numer": "491309649",
+            "denom": "125000000"
+          }
+        }
+      }
+    ],
+    "net_id": 8762,
+    "num_asks": 3,
+    "num_bids": 3,
+    "rel": "DASH",
+    "timestamp": 1694183345,
+    "total_asks_base_vol": {
+      "decimal": "133319.023345413",
+      "rational": [
+        [1, [3238477573, 31040]],
+        [1, [1000000000]]
+      ],
+      "fraction": {
+        "numer": "133319023345413",
+        "denom": "1000000000"
+      }
+    },
+    "total_asks_rel_vol": {
+      "decimal": "35.2500366381728643576",
+      "rational": [
+        [1, [473921343, 1669176307, 2]],
+        [1, [2436694016, 291038304]]
+      ],
+      "fraction": {
+        "numer": "44062545797716080447",
+        "denom": "1250000000000000000"
+      }
+    },
+    "total_bids_base_vol": {
+      "decimal": "59100.6554157135128550633",
+      "rational": [
+        [1, [1422777577, 2274178813, 32038]],
+        [1, [2313682944, 2328306436]]
+      ],
+      "fraction": {
+        "numer": "591006554157135128550633",
+        "denom": "10000000000000000000"
+      }
+    },
+    "total_bids_rel_vol": {
+      "decimal": "14.814675225",
+      "rational": [
+        [1, [592587009]],
+        [1, [40000000]]
+      ],
+      "fraction": {
+        "numer": "592587009",
+        "denom": "40000000"
+      }
+    }
+  },
+  "id": 42
+}
diff --git a/packages/komodo_defi_rpc_methods/test/src/common_structures/orderbook/order_info_test.dart b/packages/komodo_defi_rpc_methods/test/src/common_structures/orderbook/order_info_test.dart
new file mode 100644
index 000000000..2c938fcad
--- /dev/null
+++ b/packages/komodo_defi_rpc_methods/test/src/common_structures/orderbook/order_info_test.dart
@@ -0,0 +1,90 @@
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:komodo_defi_rpc_methods/src/common_structures/orderbook/order_address.dart';
+import 'package:komodo_defi_rpc_methods/src/common_structures/orderbook/order_info.dart';
+import 'package:komodo_defi_rpc_methods/src/common_structures/primitive/fraction.dart';
+import 'package:rational/rational.dart';
+import 'package:test/test.dart';
+
+Map<String, dynamic> loadFixture(String relativePath) {
+  final contents = File('test/fixtures/$relativePath').readAsStringSync();
+  return jsonDecode(contents) as Map<String, dynamic>;
+}
+
+void main() {
+  late Map<String, dynamic> askJson;
+
+  setUpAll(() {
+    final fixture = loadFixture('orderbook/orderbook_response.json');
+    final result = fixture['result'] as Map<String, dynamic>;
+    askJson = Map<String, dynamic>.from(
+      (result['asks'] as List<dynamic>).first as Map,
+    );
+  });
+
+  group('OrderInfo.fromJson', () {
+    test('parses ask payload from fixture verbatim', () {
+      final info = OrderInfo.fromJson(askJson);
+
+      expect(info.uuid, '1115d7f2-a7b9-4ab1-913f-497db2549a2b');
+      expect(info.coin, 'DGB');
+      expect(
+        info.pubkey,
+        '03de96cb66dcfaceaa8b3d4993ce8914cd5fe84e3fd53cefdae45add8032792a12',
+      );
+      expect(info.isMine, isFalse);
+
+      expect(info.price!.decimal, '0.0002658065');
+      expect(info.price!.fraction, isA<Fraction>());
+      expect(info.price!.fraction?.numer, '531613');
+      expect(info.price!.fraction?.denom, '2000000000');
+      expect(
+        info.price!.rational,
+        Rational(BigInt.from(531613), BigInt.from(2000000000)),
+      );
+
+      expect(info.baseMaxVolume!.decimal, '90524.256020352');
+      expect(info.baseMaxVolume!.fraction?.numer, '707220750159');
+      expect(info.baseMaxVolume!.fraction?.denom, '7812500');
+      expect(info.baseMaxVolumeAggregated!.decimal, '133319.023345413');
+
+      expect(
+        info.baseMinVolume!.decimal,
+        '0.3762135237475381527539770472129161626973004798603495399849138376977237200745655204067620618758382508',
+      );
+
+      expect(info.relMaxVolume!.decimal, '24.061935657873693888');
+      expect(info.relMaxVolumeAggregated!.decimal, '35.2500366381728643576');
+      expect(info.relMinVolume!.decimal, '0.0001');
+
+      expect(info.address!.addressType, OrderAddressType.transparent);
+      expect(info.address!.addressData, 'DEsCggcN3WNmaTkF2WpqoMQqx4JGQrLbPS');
+
+      expect(info.confSettings!.baseConfs, 7);
+      expect(info.confSettings!.baseNota, isFalse);
+      expect(info.confSettings!.relConfs, 2);
+      expect(info.confSettings!.relNota, isFalse);
+    });
+  });
+
+  group('OrderInfo serialization', () {
+    test('toJson emits fixture-compliant structure', () {
+      final info = OrderInfo.fromJson(askJson);
+      final json = info.toJson();
+
+      expect(json, equals(askJson));
+    });
+
+    test('supports round-trip serialization', () {
+      final info = OrderInfo.fromJson(askJson);
+      final serialized = info.toJson();
+      final reparsed = OrderInfo.fromJson(
+        Map<String, dynamic>.from(serialized),
+      );
+
+      expect(reparsed.toJson(), equals(serialized));
+      expect(reparsed.toJson(), equals(askJson));
+    });
+  });
+}
diff --git a/packages/komodo_defi_sdk/analysis_options.yaml b/packages/komodo_defi_sdk/analysis_options.yaml
index dc1d1c012..9debbc07a 100644
--- a/packages/komodo_defi_sdk/analysis_options.yaml
+++ b/packages/komodo_defi_sdk/analysis_options.yaml
@@ -3,3 +3,6 @@ analyzer:
   errors:
     use_if_null_to_convert_nulls_to_bools: ignore
     omit_local_variable_types: ignore
+
+    # Required to use jsonserializable with freezed
+    invalid_annotation_target: ignore
diff --git a/packages/komodo_defi_sdk/build.yaml b/packages/komodo_defi_sdk/build.yaml
index 5e02f60b5..75f16e06c 100644
--- a/packages/komodo_defi_sdk/build.yaml
+++ b/packages/komodo_defi_sdk/build.yaml
@@ -1,5 +1,10 @@
 targets:
   $default:
     sources:
-      exclude:
-        - "example/**"
\ No newline at end of file
+      - lib/**
+      - pubspec.yaml
+    builders:
+      hive_ce_generator:
+        enabled: true
+        generate_for:
+          - lib/src/**.dart
diff --git a/packages/komodo_defi_sdk/example/.firebaserc b/packages/komodo_defi_sdk/example/.firebaserc
new file mode 100644
index 000000000..5f888be29
--- /dev/null
+++ b/packages/komodo_defi_sdk/example/.firebaserc
@@ -0,0 +1,15 @@
+{
+    "projects": {
+        "default": "komodo-defi-sdk"
+    },
+    "targets": {
+        "komodo-defi-sdk": {
+            "hosting": {
+                "kdf-sdk": [
+                    "kdf-sdk"
+                ]
+            }
+        }
+    },
+    "etags": {}
+}
\ No newline at end of file
diff --git a/packages/komodo_defi_sdk/example/android/app/build.gradle b/packages/komodo_defi_sdk/example/android/app/build.gradle
index bd28d42b6..c4d8c7ff0 100644
--- a/packages/komodo_defi_sdk/example/android/app/build.gradle
+++ b/packages/komodo_defi_sdk/example/android/app/build.gradle
@@ -29,8 +29,8 @@ android {
     ndkVersion = flutter.ndkVersion
 
     compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_17
-        targetCompatibility = JavaVersion.VERSION_17
+        sourceCompatibility = JavaVersion.VERSION_21
+        targetCompatibility = JavaVersion.VERSION_21
     }
 
     defaultConfig {
diff --git a/packages/komodo_defi_sdk/example/firebase.json b/packages/komodo_defi_sdk/example/firebase.json
new file mode 100644
index 000000000..6b427fce4
--- /dev/null
+++ b/packages/komodo_defi_sdk/example/firebase.json
@@ -0,0 +1,17 @@
+{
+    "hosting": {
+        "target": "kdf-sdk",
+        "public": "build/web",
+        "ignore": [
+            "firebase.json",
+            "**/.*",
+            "**/node_modules/**"
+        ],
+        "rewrites": [
+            {
+                "source": "**",
+                "destination": "/index.html"
+            }
+        ]
+    }
+}
\ No newline at end of file
diff --git a/packages/komodo_defi_sdk/example/lib/widgets/instance_manager/logged_in_view_widget.dart b/packages/komodo_defi_sdk/example/lib/widgets/instance_manager/logged_in_view_widget.dart
index 16cda2576..c314a6b6d 100644
--- a/packages/komodo_defi_sdk/example/lib/widgets/instance_manager/logged_in_view_widget.dart
+++ b/packages/komodo_defi_sdk/example/lib/widgets/instance_manager/logged_in_view_widget.dart
@@ -6,6 +6,7 @@ import 'package:kdf_sdk_example/widgets/assets/instance_assets_list.dart';
 import 'package:kdf_sdk_example/widgets/common/private_keys_display_widget.dart';
 import 'package:kdf_sdk_example/widgets/common/security_warning_dialog.dart';
 import 'package:kdf_sdk_example/widgets/instance_manager/kdf_instance_state.dart';
+import 'package:kdf_sdk_example/widgets/instance_manager/zhtlc_config_dialog.dart';
 import 'package:komodo_defi_types/komodo_defi_type_utils.dart';
 import 'package:komodo_defi_types/komodo_defi_types.dart';
 
@@ -36,10 +37,9 @@ class _LoggedInViewWidgetState extends State<LoggedInViewWidget> {
 
   Future<void> _getMnemonic({required bool encrypted}) async {
     try {
-      final mnemonic =
-          encrypted
-              ? await widget.instance.sdk.auth.getMnemonicEncrypted()
-              : await _getMnemonicWithPassword();
+      final mnemonic = encrypted
+          ? await widget.instance.sdk.auth.getMnemonicEncrypted()
+          : await _getMnemonicWithPassword();
 
       if (mnemonic != null && mounted) {
         setState(() => _mnemonic = mnemonic.toJson().toJsonString());
@@ -62,38 +62,34 @@ class _LoggedInViewWidgetState extends State<LoggedInViewWidget> {
     final passwordController = TextEditingController();
     return showDialog<String>(
       context: context,
-      builder:
-          (context) => AlertDialog(
-            title: const Text('Enter Password'),
-            content: Column(
-              mainAxisSize: MainAxisSize.min,
-              children: [
-                const Text(
-                  'Enter your wallet password to decrypt the mnemonic:',
-                ),
-                const SizedBox(height: 16),
-                TextField(
-                  controller: passwordController,
-                  decoration: const InputDecoration(
-                    labelText: 'Password',
-                    border: OutlineInputBorder(),
-                  ),
-                  obscureText: true,
-                ),
-              ],
-            ),
-            actions: [
-              TextButton(
-                onPressed: () => Navigator.of(context).pop(),
-                child: const Text('Cancel'),
-              ),
-              FilledButton(
-                onPressed:
-                    () => Navigator.of(context).pop(passwordController.text),
-                child: const Text('OK'),
+      builder: (context) => AlertDialog(
+        title: const Text('Enter Password'),
+        content: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            const Text('Enter your wallet password to decrypt the mnemonic:'),
+            const SizedBox(height: 16),
+            TextField(
+              controller: passwordController,
+              decoration: const InputDecoration(
+                labelText: 'Password',
+                border: OutlineInputBorder(),
               ),
-            ],
+              obscureText: true,
+            ),
+          ],
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.of(context).pop(),
+            child: const Text('Cancel'),
           ),
+          FilledButton(
+            onPressed: () => Navigator.of(context).pop(passwordController.text),
+            child: const Text('OK'),
+          ),
+        ],
+      ),
     );
   }
 
@@ -146,8 +142,8 @@ class _LoggedInViewWidgetState extends State<LoggedInViewWidget> {
           runSpacing: 8,
           children: [
             FilledButton.tonalIcon(
-              onPressed:
-                  () => context.read<AuthBloc>().add(const AuthSignedOut()),
+              onPressed: () =>
+                  context.read<AuthBloc>().add(const AuthSignedOut()),
               icon: const Icon(Icons.logout),
               label: const Text('Sign Out'),
               key: const Key('sign_out_button'),
@@ -165,14 +161,13 @@ class _LoggedInViewWidgetState extends State<LoggedInViewWidget> {
               ),
               FilledButton.tonalIcon(
                 onPressed: _isExportingPrivateKeys ? null : _exportPrivateKeys,
-                icon:
-                    _isExportingPrivateKeys
-                        ? const SizedBox(
-                          width: 16,
-                          height: 16,
-                          child: CircularProgressIndicator(strokeWidth: 2),
-                        )
-                        : const Icon(Icons.vpn_key),
+                icon: _isExportingPrivateKeys
+                    ? const SizedBox(
+                        width: 16,
+                        height: 16,
+                        child: CircularProgressIndicator(strokeWidth: 2),
+                      )
+                    : const Icon(Icons.vpn_key),
                 label: Text(
                   _isExportingPrivateKeys
                       ? 'Exporting...'
@@ -214,7 +209,31 @@ class _LoggedInViewWidgetState extends State<LoggedInViewWidget> {
           child: InstanceAssetList(
             assets: widget.filteredAssets,
             searchController: widget.searchController,
-            onAssetSelected: widget.onNavigateToAsset,
+            onAssetSelected: (asset) async {
+              // If asset is ZHTLC and has no saved config, prompt user for config
+              if (asset.id.subClass == CoinSubClass.zhtlc) {
+                final sdk = widget.instance.sdk;
+                final existing = await sdk.activationConfigService
+                    .getSavedZhtlc(asset.id);
+                if (existing == null && mounted) {
+                  final config =
+                      await ZhtlcConfigDialogHandler.handleZhtlcConfigDialog(
+                        context,
+                        asset,
+                      );
+                  if (!mounted) return;
+                  if (config != null) {
+                    await sdk.activationConfigService.saveZhtlcConfig(
+                      asset.id,
+                      config,
+                    );
+                  } else {
+                    return; // User cancelled
+                  }
+                }
+              }
+              widget.onNavigateToAsset(asset);
+            },
             authOptions: widget.currentUser.walletId.authOptions,
           ),
         ),
diff --git a/packages/komodo_defi_sdk/example/lib/widgets/instance_manager/zhtlc_config_dialog.dart b/packages/komodo_defi_sdk/example/lib/widgets/instance_manager/zhtlc_config_dialog.dart
new file mode 100644
index 000000000..fd0a69cb5
--- /dev/null
+++ b/packages/komodo_defi_sdk/example/lib/widgets/instance_manager/zhtlc_config_dialog.dart
@@ -0,0 +1,405 @@
+import 'dart:async';
+
+import 'package:flutter/material.dart';
+import 'package:komodo_defi_rpc_methods/komodo_defi_rpc_methods.dart'
+    show ZhtlcSyncParams;
+import 'package:komodo_defi_sdk/komodo_defi_sdk.dart'
+    show
+        DownloadProgress,
+        DownloadResultPatterns,
+        ZcashParamsDownloader,
+        ZcashParamsDownloaderFactory,
+        ZhtlcUserConfig;
+import 'package:komodo_defi_types/komodo_defi_types.dart';
+
+/// Handles ZHTLC configuration dialog with optional automatic Zcash parameters download.
+///
+/// This class manages the complete flow for configuring ZHTLC assets:
+/// - On desktop platforms: automatically downloads Zcash parameters and prefills the path
+/// - Shows progress dialog during download
+/// - Displays configuration dialog for user input
+/// - Handles download failures gracefully with fallback to manual configuration
+class ZhtlcConfigDialogHandler {
+  /// Shows a download progress dialog for Zcash parameters.
+  ///
+  /// Returns:
+  /// - true if download completes successfully
+  /// - false if user cancelled
+  /// - null if download failed
+  static Future<bool?> _showDownloadProgressDialog(
+    BuildContext context,
+    ZcashParamsDownloader downloader,
+  ) async {
+    const downloadTimeout = Duration(minutes: 10);
+    // Start the download
+    final downloadFuture = downloader.downloadParams().timeout(
+      downloadTimeout,
+      onTimeout: () => throw TimeoutException(
+        'Download timed out after ${downloadTimeout.inMinutes} minutes',
+        downloadTimeout,
+      ),
+    );
+    var downloadComplete = false;
+    var downloadSuccess = false;
+    var dialogClosed = false;
+
+    // Show the progress dialog that monitors download completion
+    return showDialog<bool>(
+      context: context,
+      barrierDismissible: false,
+      builder: (context) {
+        return StatefulBuilder(
+          builder: (context, setState) {
+            // Listen for download completion and close dialog automatically
+            downloadFuture
+                .then((result) {
+                  if (!downloadComplete && !dialogClosed && context.mounted) {
+                    downloadComplete = true;
+                    downloadSuccess = result.when(
+                      success: (paramsPath) => true,
+                      failure: (error) => false,
+                    );
+
+                    // Close the dialog with the result
+                    dialogClosed = true;
+                    Navigator.of(context).pop(downloadSuccess);
+                  }
+                })
+                .catchError((Object e, StackTrace? stackTrace) {
+                  if (!downloadComplete && !dialogClosed && context.mounted) {
+                    downloadComplete = true;
+                    downloadSuccess = false;
+
+                    // Log the error for debugging
+                    debugPrint('Zcash parameters download failed: $e');
+                    if (stackTrace != null) {
+                      debugPrint('Stack trace: $stackTrace');
+                    }
+
+                    // Indicate download failed (null result)
+                    dialogClosed = true;
+                    Navigator.of(context).pop();
+                  }
+                });
+
+            return AlertDialog(
+              title: const Text('Downloading Zcash Parameters'),
+              content: SizedBox(
+                height: 120,
+                child: Column(
+                  mainAxisAlignment: MainAxisAlignment.center,
+                  children: [
+                    const CircularProgressIndicator(),
+                    const SizedBox(height: 16),
+                    StreamBuilder<DownloadProgress>(
+                      stream: downloader.downloadProgress,
+                      builder: (context, snapshot) {
+                        if (snapshot.hasData) {
+                          final progress = snapshot.data;
+                          return Column(
+                            children: [
+                              Text(
+                                progress?.displayText ?? '',
+                                textAlign: TextAlign.center,
+                              ),
+                              const SizedBox(height: 8),
+                              LinearProgressIndicator(
+                                value: (progress?.percentage ?? 0) / 100,
+                              ),
+                              Text(
+                                '${(progress?.percentage ?? 0).toStringAsFixed(1)}%',
+                                style: Theme.of(context).textTheme.bodySmall,
+                                textAlign: TextAlign.center,
+                              ),
+                            ],
+                          );
+                        }
+                        return const Text('Preparing download...');
+                      },
+                    ),
+                  ],
+                ),
+              ),
+              actions: [
+                TextButton(
+                  onPressed: () async {
+                    if (!dialogClosed) {
+                      dialogClosed = true;
+                      await downloader.cancelDownload();
+                      Navigator.of(context).pop(false); // Cancelled
+                    }
+                  },
+                  child: const Text('Cancel'),
+                ),
+              ],
+            );
+          },
+        );
+      },
+    );
+  }
+
+  /// Handles the complete ZHTLC configuration flow including optional download.
+  ///
+  /// On desktop platforms, this method will attempt to download Zcash parameters
+  /// automatically. If successful, it prefills the parameters path in the dialog.
+  /// Returns null if the user cancels the download or configuration.
+  static Future<ZhtlcUserConfig?> handleZhtlcConfigDialog(
+    BuildContext context,
+    Asset asset,
+  ) async {
+    // On desktop platforms, try to download Zcash parameters first
+    if (ZcashParamsDownloaderFactory.requiresDownload) {
+      ZcashParamsDownloader? downloader;
+      try {
+        downloader = ZcashParamsDownloaderFactory.create();
+
+        // Check if parameters are already available
+        final areAvailable = await downloader.areParamsAvailable();
+        if (!areAvailable) {
+          // Show download progress dialog (starts download internally)
+          final downloadResult = await _showDownloadProgressDialog(
+            context,
+            downloader,
+          );
+
+          if (downloadResult == false) {
+            // User cancelled the download
+            return null;
+          }
+        }
+
+        final paramsPath = await downloader.getParamsPath();
+        return _showZhtlcConfigDialog(
+          context,
+          asset,
+          prefilledZcashPath: paramsPath,
+        );
+      } catch (e) {
+        // Error creating downloader or getting params path
+        if (context.mounted) {
+          ScaffoldMessenger.of(context).showSnackBar(
+            SnackBar(
+              content: Text('Error setting up Zcash parameters: $e'),
+              backgroundColor: Theme.of(context).colorScheme.error,
+            ),
+          );
+        }
+      } finally {
+        // Always dispose the downloader to release resources
+        downloader?.dispose();
+      }
+    }
+
+    // On web or if download failed, show dialog without prefilled path
+    return _showZhtlcConfigDialog(context, asset);
+  }
+
+  /// Shows the ZHTLC configuration dialog.
+  ///
+  /// If [prefilledZcashPath] is provided, the Zcash parameters path field
+  /// will be prefilled and made read-only.
+  static Future<ZhtlcUserConfig?> _showZhtlcConfigDialog(
+    BuildContext context,
+    Asset asset, {
+    String? prefilledZcashPath,
+  }) async {
+    final zcashPathController = TextEditingController(text: prefilledZcashPath);
+    final blocksPerIterController = TextEditingController(text: '1000');
+    final intervalMsController = TextEditingController(text: '0');
+
+    var syncType = 'date'; // earliest | height | date
+    final syncValueController = TextEditingController();
+    DateTime? selectedDateTime;
+
+    String formatDate(DateTime dateTime) {
+      return dateTime.toIso8601String().split('T')[0];
+    }
+
+    Future<void> selectDate(BuildContext context) async {
+      final picked = await showDatePicker(
+        context: context,
+        initialDate: selectedDateTime ?? DateTime.now(),
+        firstDate: DateTime(2000),
+        lastDate: DateTime(2100),
+      );
+
+      if (picked != null) {
+        // Default to midnight (00:00) of the selected day
+        selectedDateTime = DateTime(picked.year, picked.month, picked.day);
+        syncValueController.text = formatDate(selectedDateTime!);
+      }
+    }
+
+    // Initialize with default date (2 days ago)
+    void initializeDate() {
+      selectedDateTime = DateTime.now().subtract(const Duration(days: 2));
+      syncValueController.text = formatDate(selectedDateTime!);
+    }
+
+    initializeDate();
+
+    ZhtlcUserConfig? result;
+
+    await showDialog<void>(
+      context: context,
+      barrierDismissible: false,
+      builder: (context) {
+        return StatefulBuilder(
+          builder: (context, setInnerState) {
+            return AlertDialog(
+              title: Text('Configure ${asset.id.name}'),
+              content: SingleChildScrollView(
+                child: Column(
+                  mainAxisSize: MainAxisSize.min,
+                  children: [
+                    TextField(
+                      controller: zcashPathController,
+                      readOnly: prefilledZcashPath != null,
+                      decoration: InputDecoration(
+                        labelText: 'Zcash parameters path',
+                        helperText: prefilledZcashPath != null
+                            ? 'Path automatically detected'
+                            : 'Folder containing sapling params',
+                      ),
+                    ),
+                    const SizedBox(height: 12),
+                    TextField(
+                      controller: blocksPerIterController,
+                      decoration: const InputDecoration(
+                        labelText: 'Blocks per iteration',
+                      ),
+                      keyboardType: TextInputType.number,
+                    ),
+                    const SizedBox(height: 12),
+                    TextField(
+                      controller: intervalMsController,
+                      decoration: const InputDecoration(
+                        labelText: 'Scan interval (ms)',
+                      ),
+                      keyboardType: TextInputType.number,
+                    ),
+                    const SizedBox(height: 12),
+                    Row(
+                      children: [
+                        const Text('Start sync from:'),
+                        const SizedBox(width: 12),
+                        DropdownButton<String>(
+                          value: syncType,
+                          items: const [
+                            DropdownMenuItem(
+                              value: 'earliest',
+                              child: Text('Earliest (sapling)'),
+                            ),
+                            DropdownMenuItem(
+                              value: 'height',
+                              child: Text('Block height'),
+                            ),
+                            DropdownMenuItem(
+                              value: 'date',
+                              child: Text('Date & Time'),
+                            ),
+                          ],
+                          onChanged: (v) {
+                            if (v == null) return;
+                            setInnerState(() => syncType = v);
+                          },
+                        ),
+                        const SizedBox(width: 8),
+                        if (syncType != 'earliest')
+                          Expanded(
+                            child: TextField(
+                              controller: syncValueController,
+                              decoration: InputDecoration(
+                                labelText: syncType == 'height'
+                                    ? 'Block height'
+                                    : 'Select date & time',
+                                suffixIcon: syncType == 'date'
+                                    ? IconButton(
+                                        icon: const Icon(Icons.calendar_today),
+                                        onPressed: () => selectDate(context),
+                                      )
+                                    : null,
+                              ),
+                              keyboardType: syncType == 'height'
+                                  ? TextInputType.number
+                                  : TextInputType.none,
+                              readOnly: syncType == 'date',
+                              onTap: syncType == 'date'
+                                  ? () => selectDate(context)
+                                  : null,
+                            ),
+                          ),
+                      ],
+                    ),
+                  ],
+                ),
+              ),
+              actions: [
+                TextButton(
+                  onPressed: () => Navigator.of(context).pop(),
+                  child: const Text('Cancel'),
+                ),
+                FilledButton(
+                  onPressed: () {
+                    final path = zcashPathController.text.trim();
+                    if (path.isEmpty) {
+                      ScaffoldMessenger.of(context).showSnackBar(
+                        const SnackBar(
+                          content: Text('Zcash params path is required'),
+                        ),
+                      );
+                      return;
+                    }
+
+                    ZhtlcSyncParams? syncParams;
+                    if (syncType == 'earliest') {
+                      syncParams = ZhtlcSyncParams.earliest();
+                    } else if (syncType == 'height') {
+                      final v = int.tryParse(syncValueController.text.trim());
+                      if (v == null) {
+                        ScaffoldMessenger.of(context).showSnackBar(
+                          const SnackBar(
+                            content: Text('Enter a valid block height'),
+                          ),
+                        );
+                        return;
+                      }
+                      syncParams = ZhtlcSyncParams.height(v);
+                    } else if (syncType == 'date') {
+                      if (selectedDateTime == null) {
+                        ScaffoldMessenger.of(context).showSnackBar(
+                          const SnackBar(
+                            content: Text('Please select a date and time'),
+                          ),
+                        );
+                        return;
+                      }
+                      // Convert to Unix timestamp (seconds since epoch)
+                      final unixTimestamp =
+                          selectedDateTime!.millisecondsSinceEpoch ~/ 1000;
+                      syncParams = ZhtlcSyncParams.date(unixTimestamp);
+                    }
+
+                    result = ZhtlcUserConfig(
+                      zcashParamsPath: path,
+                      scanBlocksPerIteration:
+                          int.tryParse(blocksPerIterController.text) ?? 1000,
+                      scanIntervalMs:
+                          int.tryParse(intervalMsController.text) ?? 0,
+                      syncParams: syncParams,
+                    );
+                    Navigator.of(context).pop();
+                  },
+                  child: const Text('Save'),
+                ),
+              ],
+            );
+          },
+        );
+      },
+    );
+
+    return result;
+  }
+}
diff --git a/packages/komodo_defi_sdk/example/macos/Podfile b/packages/komodo_defi_sdk/example/macos/Podfile
index c795730db..b52666a10 100644
--- a/packages/komodo_defi_sdk/example/macos/Podfile
+++ b/packages/komodo_defi_sdk/example/macos/Podfile
@@ -1,4 +1,4 @@
-platform :osx, '10.14'
+platform :osx, '10.15'
 
 # CocoaPods analytics sends network stats synchronously affecting flutter build latency.
 ENV['COCOAPODS_DISABLE_STATS'] = 'true'
diff --git a/packages/komodo_defi_sdk/example/macos/Podfile.lock b/packages/komodo_defi_sdk/example/macos/Podfile.lock
index ffc5c67f7..e417bec12 100644
--- a/packages/komodo_defi_sdk/example/macos/Podfile.lock
+++ b/packages/komodo_defi_sdk/example/macos/Podfile.lock
@@ -14,6 +14,8 @@ PODS:
   - path_provider_foundation (0.0.1):
     - Flutter
     - FlutterMacOS
+  - share_plus (0.0.1):
+    - FlutterMacOS
   - shared_preferences_foundation (0.0.1):
     - Flutter
     - FlutterMacOS
@@ -25,6 +27,7 @@ DEPENDENCIES:
   - local_auth_darwin (from `Flutter/ephemeral/.symlinks/plugins/local_auth_darwin/darwin`)
   - mobile_scanner (from `Flutter/ephemeral/.symlinks/plugins/mobile_scanner/darwin`)
   - path_provider_foundation (from `Flutter/ephemeral/.symlinks/plugins/path_provider_foundation/darwin`)
+  - share_plus (from `Flutter/ephemeral/.symlinks/plugins/share_plus/macos`)
   - shared_preferences_foundation (from `Flutter/ephemeral/.symlinks/plugins/shared_preferences_foundation/darwin`)
 
 EXTERNAL SOURCES:
@@ -40,18 +43,21 @@ EXTERNAL SOURCES:
     :path: Flutter/ephemeral/.symlinks/plugins/mobile_scanner/darwin
   path_provider_foundation:
     :path: Flutter/ephemeral/.symlinks/plugins/path_provider_foundation/darwin
+  share_plus:
+    :path: Flutter/ephemeral/.symlinks/plugins/share_plus/macos
   shared_preferences_foundation:
     :path: Flutter/ephemeral/.symlinks/plugins/shared_preferences_foundation/darwin
 
 SPEC CHECKSUMS:
   flutter_secure_storage_darwin: ce237a8775b39723566dc72571190a3769d70468
-  FlutterMacOS: 8f6f14fa908a6fb3fba0cd85dbd81ec4b251fb24
+  FlutterMacOS: d0db08ddef1a9af05a5ec4b724367152bb0500b1
   komodo_defi_framework: 725599127b357521f4567b16192bf07d7ad1d4b0
-  local_auth_darwin: 553ce4f9b16d3fdfeafce9cf042e7c9f77c1c391
+  local_auth_darwin: d2e8c53ef0c4f43c646462e3415432c4dab3ae19
   mobile_scanner: 9157936403f5a0644ca3779a38ff8404c5434a93
   path_provider_foundation: 080d55be775b7414fd5a5ef3ac137b97b097e564
+  share_plus: 510bf0af1a42cd602274b4629920c9649c52f4cc
   shared_preferences_foundation: 9e1978ff2562383bd5676f64ec4e9aa8fa06a6f7
 
-PODFILE CHECKSUM: 236401fc2c932af29a9fcf0e97baeeb2d750d367
+PODFILE CHECKSUM: 9ebaf0ce3d369aaa26a9ea0e159195ed94724cf3
 
 COCOAPODS: 1.16.2
diff --git a/packages/komodo_defi_sdk/example/macos/Runner.xcodeproj/project.pbxproj b/packages/komodo_defi_sdk/example/macos/Runner.xcodeproj/project.pbxproj
index 5abdb07e4..4e8e3acb4 100644
--- a/packages/komodo_defi_sdk/example/macos/Runner.xcodeproj/project.pbxproj
+++ b/packages/komodo_defi_sdk/example/macos/Runner.xcodeproj/project.pbxproj
@@ -556,7 +556,7 @@
 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				MACOSX_DEPLOYMENT_TARGET = 10.14;
+				MACOSX_DEPLOYMENT_TARGET = 10.15;
 				MTL_ENABLE_DEBUG_INFO = NO;
 				SDKROOT = macosx;
 				SWIFT_COMPILATION_MODE = wholemodule;
@@ -641,7 +641,7 @@
 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				MACOSX_DEPLOYMENT_TARGET = 10.14;
+				MACOSX_DEPLOYMENT_TARGET = 10.15;
 				MTL_ENABLE_DEBUG_INFO = YES;
 				ONLY_ACTIVE_ARCH = YES;
 				SDKROOT = macosx;
@@ -691,7 +691,7 @@
 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				MACOSX_DEPLOYMENT_TARGET = 10.14;
+				MACOSX_DEPLOYMENT_TARGET = 10.15;
 				MTL_ENABLE_DEBUG_INFO = NO;
 				SDKROOT = macosx;
 				SWIFT_COMPILATION_MODE = wholemodule;
diff --git a/packages/komodo_defi_sdk/lib/komodo_defi_sdk.dart b/packages/komodo_defi_sdk/lib/komodo_defi_sdk.dart
index 2d191c7ce..e5c0a0d84 100644
--- a/packages/komodo_defi_sdk/lib/komodo_defi_sdk.dart
+++ b/packages/komodo_defi_sdk/lib/komodo_defi_sdk.dart
@@ -11,6 +11,9 @@ export 'package:komodo_defi_framework/komodo_defi_framework.dart'
     show IKdfHostConfig, LocalConfig, RemoteConfig;
 export 'package:komodo_defi_local_auth/komodo_defi_local_auth.dart'
     show AuthenticationState, AuthenticationStatus;
+// ZHTLC sync parameters
+export 'package:komodo_defi_rpc_methods/komodo_defi_rpc_methods.dart'
+    show ZhtlcSyncParams;
 export 'package:komodo_defi_sdk/src/addresses/address_operations.dart'
     show AddressOperations;
 export 'package:komodo_defi_sdk/src/balances/balance_manager.dart'
@@ -19,6 +22,18 @@ export 'package:komodo_defi_sdk/src/sdk/komodo_defi_sdk_config.dart';
 export 'package:komodo_defi_sdk/src/security/security_manager.dart'
     show SecurityManager;
 
+export 'src/activation_config/activation_config_service.dart'
+    show
+        ActivationConfigRepository,
+        ActivationConfigService,
+        ActivationSettingDescriptor,
+        AssetIdActivationSettings,
+        InMemoryKeyValueStore,
+        JsonActivationConfigRepository,
+        WalletIdResolver,
+        ZhtlcUserConfig;
+export 'src/activation_config/hive_activation_config_repository.dart'
+    show HiveActivationConfigRepository;
 export 'src/assets/_assets_index.dart' show AssetHdWalletAddressesExtension;
 export 'src/assets/asset_extensions.dart'
     show
@@ -29,3 +44,8 @@ export 'src/assets/asset_pubkey_extensions.dart';
 export 'src/assets/legacy_asset_extensions.dart';
 export 'src/komodo_defi_sdk.dart' show KomodoDefiSdk;
 export 'src/widgets/asset_balance_text.dart';
+export 'src/zcash_params/models/download_progress.dart';
+export 'src/zcash_params/models/download_result.dart';
+export 'src/zcash_params/zcash_params_downloader.dart';
+// Zcash parameters download functionality
+export 'src/zcash_params/zcash_params_downloader_factory.dart';
diff --git a/packages/komodo_defi_sdk/lib/src/_internal_exports.dart b/packages/komodo_defi_sdk/lib/src/_internal_exports.dart
index 1420008b3..bc173a069 100644
--- a/packages/komodo_defi_sdk/lib/src/_internal_exports.dart
+++ b/packages/komodo_defi_sdk/lib/src/_internal_exports.dart
@@ -6,3 +6,4 @@ library _internal_exports;
 export 'activation/_activation_index.dart';
 export 'assets/_assets_index.dart';
 export 'transaction_history/_transaction_history_index.dart';
+export 'zcash_params/_zcash_params_index.dart';
diff --git a/packages/komodo_defi_sdk/lib/src/activation/activation_manager.dart b/packages/komodo_defi_sdk/lib/src/activation/activation_manager.dart
index ef1ef7e33..625adda70 100644
--- a/packages/komodo_defi_sdk/lib/src/activation/activation_manager.dart
+++ b/packages/komodo_defi_sdk/lib/src/activation/activation_manager.dart
@@ -6,6 +6,7 @@ import 'package:komodo_coins/komodo_coins.dart';
 import 'package:komodo_defi_local_auth/komodo_defi_local_auth.dart';
 import 'package:komodo_defi_rpc_methods/komodo_defi_rpc_methods.dart';
 import 'package:komodo_defi_sdk/src/_internal_exports.dart';
+import 'package:komodo_defi_sdk/src/activation_config/activation_config_service.dart';
 import 'package:komodo_defi_sdk/src/balances/balance_manager.dart';
 import 'package:komodo_defi_types/komodo_defi_types.dart';
 import 'package:mutex/mutex.dart';
@@ -19,6 +20,7 @@ class ActivationManager {
     this._assetHistory,
     this._assetLookup,
     this._balanceManager,
+    this._configService,
     this._assetsUpdateManager,
   );
 
@@ -27,6 +29,7 @@ class ActivationManager {
   final AssetHistoryStorage _assetHistory;
   final IAssetLookup _assetLookup;
   final IBalanceManager _balanceManager;
+  final ActivationConfigService _configService;
   final KomodoAssetsUpdateManager _assetsUpdateManager;
   final _activationMutex = Mutex();
   static const _operationTimeout = Duration(seconds: 30);
@@ -82,7 +85,7 @@ class ActivationManager {
       yield ActivationProgress(
         status: 'Starting activation for ${group.primary.id.name}...',
         progressDetails: ActivationProgressDetails(
-          currentStep: 'group_start',
+          currentStep: ActivationStep.groupStart,
           stepCount: 1,
           additionalInfo: {
             'primaryAsset': group.primary.id.name,
@@ -102,6 +105,7 @@ class ActivationManager {
         final activator = ActivationStrategyFactory.createStrategy(
           _client,
           privKeyPolicy,
+          _configService,
         );
 
         await for (final progress in activator.activate(
@@ -161,7 +165,7 @@ class ActivationManager {
     return const ActivationProgress(
       status: 'Needs activation',
       progressDetails: ActivationProgressDetails(
-        currentStep: 'init',
+        currentStep: ActivationStep.init,
         stepCount: 1,
       ),
     );
diff --git a/packages/komodo_defi_sdk/lib/src/activation/base_strategies/activation_strategy_base.dart b/packages/komodo_defi_sdk/lib/src/activation/base_strategies/activation_strategy_base.dart
index 8271415f7..817fc0f40 100644
--- a/packages/komodo_defi_sdk/lib/src/activation/base_strategies/activation_strategy_base.dart
+++ b/packages/komodo_defi_sdk/lib/src/activation/base_strategies/activation_strategy_base.dart
@@ -45,7 +45,7 @@ class SmartAssetActivator extends BatchCapableActivator {
     yield ActivationProgress(
       status: 'Planning activation strategy...',
       progressDetails: ActivationProgressDetails(
-        currentStep: 'planning',
+        currentStep: ActivationStep.planning,
         stepCount: 1,
         additionalInfo: {
           'parentActivated': parentActivated,
@@ -117,7 +117,7 @@ class CompositeAssetActivator extends BatchCapableActivator {
     yield ActivationProgress(
       status: 'Finding appropriate activation strategy...',
       progressDetails: ActivationProgressDetails(
-        currentStep: 'strategy_selection',
+        currentStep: ActivationStep.strategySelection,
         stepCount: 1,
         additionalInfo: {'assetId': asset.id.id},
       ),
@@ -144,4 +144,4 @@ abstract class ProtocolActivationStrategy extends BatchCapableActivator {
       supportedProtocols.contains(asset.protocol.subClass);
 
   Set<CoinSubClass> get supportedProtocols;
-}
+}
\ No newline at end of file
diff --git a/packages/komodo_defi_sdk/lib/src/activation/base_strategies/activation_strategy_factory.dart b/packages/komodo_defi_sdk/lib/src/activation/base_strategies/activation_strategy_factory.dart
index 0ec3e9e3d..d16ed8257 100644
--- a/packages/komodo_defi_sdk/lib/src/activation/base_strategies/activation_strategy_factory.dart
+++ b/packages/komodo_defi_sdk/lib/src/activation/base_strategies/activation_strategy_factory.dart
@@ -1,5 +1,6 @@
 import 'package:komodo_defi_rpc_methods/komodo_defi_rpc_methods.dart';
 import 'package:komodo_defi_sdk/src/activation/_activation.dart';
+import 'package:komodo_defi_sdk/src/activation_config/activation_config_service.dart';
 import 'package:komodo_defi_types/komodo_defi_types.dart';
 
 /// Factory for creating the complete activation strategy stack
@@ -9,9 +10,11 @@ class ActivationStrategyFactory {
   /// [client] The [ApiClient] to use for RPC calls.
   /// [privKeyPolicy] The [PrivateKeyPolicy] to use for private key management.
   /// This is used for external wallet support. E.g. trezor, wallet connect, etc
+  /// [configService] The [ActivationConfigService] for resolving activation configuration.
   static SmartAssetActivator createStrategy(
     ApiClient client,
     PrivateKeyPolicy privKeyPolicy,
+    ActivationConfigService configService,
   ) {
     return SmartAssetActivator(
       client,
@@ -28,7 +31,7 @@ class ActivationStrategyFactory {
         TendermintWithTokensActivationStrategy(client, privKeyPolicy),
         TendermintTokenActivationStrategy(client, privKeyPolicy),
         QtumActivationStrategy(client, privKeyPolicy),
-        ZhtlcActivationStrategy(client, privKeyPolicy),
+        ZhtlcActivationStrategy(client, privKeyPolicy, configService),
         CustomErc20ActivationStrategy(client),
       ]),
     );
diff --git a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/bch_activation_strategy.dart b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/bch_activation_strategy.dart
index 0a2dcd0b2..2901b58c4 100644
--- a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/bch_activation_strategy.dart
+++ b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/bch_activation_strategy.dart
@@ -45,7 +45,7 @@ class BchActivationStrategy extends ProtocolActivationStrategy {
     yield ActivationProgress(
       status: 'Starting BCH/SLP activation...',
       progressDetails: ActivationProgressDetails(
-        currentStep: 'initialization',
+        currentStep: ActivationStep.initialization,
         stepCount: 4,
         additionalInfo: {
           'assetType': isBch ? 'BCH' : 'SLP',
@@ -62,7 +62,7 @@ class BchActivationStrategy extends ProtocolActivationStrategy {
           status: 'Configuring BCH platform...',
           progressPercentage: 25,
           progressDetails: ActivationProgressDetails(
-            currentStep: 'platform_setup',
+            currentStep: ActivationStep.platformSetup,
             stepCount: 4,
             additionalInfo: {
               'electrumServers': protocol.requiredServers.toJsonRequest(),
@@ -77,7 +77,7 @@ class BchActivationStrategy extends ProtocolActivationStrategy {
           status: 'Activating BCH with SLP support...',
           progressPercentage: 50,
           progressDetails: ActivationProgressDetails(
-            currentStep: 'activation',
+            currentStep: ActivationStep.activation,
             stepCount: 4,
           ),
         );
@@ -98,7 +98,7 @@ class BchActivationStrategy extends ProtocolActivationStrategy {
           status: 'Verifying activation...',
           progressPercentage: 75,
           progressDetails: ActivationProgressDetails(
-            currentStep: 'verification',
+            currentStep: ActivationStep.verification,
             stepCount: 4,
             additionalInfo: {
               'currentBlock': response.currentBlock,
@@ -109,7 +109,7 @@ class BchActivationStrategy extends ProtocolActivationStrategy {
 
         yield ActivationProgress.success(
           details: ActivationProgressDetails(
-            currentStep: 'complete',
+            currentStep: ActivationStep.complete,
             stepCount: 4,
             additionalInfo: {
               'activatedChain': 'BCH',
@@ -124,7 +124,7 @@ class BchActivationStrategy extends ProtocolActivationStrategy {
           status: 'Activating SLP token...',
           progressPercentage: 50,
           progressDetails: ActivationProgressDetails(
-            currentStep: 'token_activation',
+            currentStep: ActivationStep.tokenActivation,
             stepCount: 2,
           ),
         );
@@ -136,7 +136,7 @@ class BchActivationStrategy extends ProtocolActivationStrategy {
 
         yield ActivationProgress.success(
           details: ActivationProgressDetails(
-            currentStep: 'complete',
+            currentStep: ActivationStep.complete,
             stepCount: 2,
             additionalInfo: {
               'activatedToken': asset.id.name,
@@ -151,7 +151,7 @@ class BchActivationStrategy extends ProtocolActivationStrategy {
         errorMessage: e.toString(),
         isComplete: true,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'error',
+          currentStep: ActivationStep.error,
           stepCount: 4,
           errorCode: isBch ? 'BCH_ACTIVATION_ERROR' : 'SLP_ACTIVATION_ERROR',
           errorDetails: e.toString(),
diff --git a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/custom_erc20_activation_strategy.dart b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/custom_erc20_activation_strategy.dart
index f4241ca9b..d8fcf3a7c 100644
--- a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/custom_erc20_activation_strategy.dart
+++ b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/custom_erc20_activation_strategy.dart
@@ -41,7 +41,7 @@ class CustomErc20ActivationStrategy extends ProtocolActivationStrategy {
     yield ActivationProgress(
       status: 'Activating ${asset.id.name}...',
       progressDetails: ActivationProgressDetails(
-        currentStep: 'initialization',
+        currentStep: ActivationStep.initialization,
         stepCount: 2,
         additionalInfo: {
           'assetType': 'token',
@@ -70,7 +70,7 @@ class CustomErc20ActivationStrategy extends ProtocolActivationStrategy {
 
       yield ActivationProgress.success(
         details: ActivationProgressDetails(
-          currentStep: 'complete',
+          currentStep: ActivationStep.complete,
           stepCount: 2,
           additionalInfo: {
             'activatedChain': asset.id.name,
@@ -85,7 +85,7 @@ class CustomErc20ActivationStrategy extends ProtocolActivationStrategy {
         errorMessage: e.toString(),
         isComplete: true,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'error',
+          currentStep: ActivationStep.error,
           stepCount: 2,
           errorCode: 'ERC20_ACTIVATION_ERROR',
           errorDetails: e.toString(),
@@ -94,4 +94,4 @@ class CustomErc20ActivationStrategy extends ProtocolActivationStrategy {
       );
     }
   }
-}
+}
\ No newline at end of file
diff --git a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/erc20_activation_strategy.dart b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/erc20_activation_strategy.dart
index 3fa1b70fb..7c1a5acb6 100644
--- a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/erc20_activation_strategy.dart
+++ b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/erc20_activation_strategy.dart
@@ -52,7 +52,7 @@ class Erc20ActivationStrategy extends ProtocolActivationStrategy {
     yield ActivationProgress(
       status: 'Activating ${asset.id.name} token...',
       progressDetails: ActivationProgressDetails(
-        currentStep: 'initialization',
+        currentStep: ActivationStep.initialization,
         stepCount: 2,
         additionalInfo: {
           'assetType': 'token',
@@ -71,7 +71,7 @@ class Erc20ActivationStrategy extends ProtocolActivationStrategy {
 
       yield ActivationProgress.success(
         details: ActivationProgressDetails(
-          currentStep: 'complete',
+          currentStep: ActivationStep.complete,
           stepCount: 2,
           additionalInfo: {
             'activatedToken': asset.id.name,
@@ -86,7 +86,7 @@ class Erc20ActivationStrategy extends ProtocolActivationStrategy {
         errorMessage: e.toString(),
         isComplete: true,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'error',
+          currentStep: ActivationStep.error,
           stepCount: 2,
           errorCode: 'ERC20_ACTIVATION_ERROR',
           errorDetails: e.toString(),
@@ -95,4 +95,4 @@ class Erc20ActivationStrategy extends ProtocolActivationStrategy {
       );
     }
   }
-}
+}
\ No newline at end of file
diff --git a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/eth_task_activation_strategy.dart b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/eth_task_activation_strategy.dart
index 8fa5cf48c..9d1c81a52 100644
--- a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/eth_task_activation_strategy.dart
+++ b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/eth_task_activation_strategy.dart
@@ -50,7 +50,7 @@ class EthTaskActivationStrategy extends ProtocolActivationStrategy {
     yield ActivationProgress(
       status: 'Starting ${asset.id.name} activation...',
       progressDetails: ActivationProgressDetails(
-        currentStep: 'initialization',
+        currentStep: ActivationStep.initialization,
         stepCount: 5,
         additionalInfo: {
           'chainType': protocol.subClass.formatted,
@@ -65,30 +65,31 @@ class EthTaskActivationStrategy extends ProtocolActivationStrategy {
         status: 'Validating protocol configuration...',
         progressPercentage: 20,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'validation',
+          currentStep: ActivationStep.validation,
           stepCount: 5,
         ),
       );
 
       final taskResponse = await client.rpc.erc20.enableEthInit(
         ticker: asset.id.id,
-        params: EthWithTokensActivationParams.fromJson(
-          asset.protocol.config,
-        ).copyWith(
-          erc20Tokens:
-              children?.map((e) => TokensRequest(ticker: e.id.id)).toList() ??
-              [],
-          txHistory: const EtherscanProtocolHelper()
-              .shouldEnableTransactionHistory(asset),
-          privKeyPolicy: privKeyPolicy,
-        ),
+        params: EthWithTokensActivationParams.fromJson(asset.protocol.config)
+            .copyWith(
+              erc20Tokens:
+                  children
+                      ?.map((e) => TokensRequest(ticker: e.id.id))
+                      .toList() ??
+                  [],
+              txHistory: const EtherscanProtocolHelper()
+                  .shouldEnableTransactionHistory(asset),
+              privKeyPolicy: privKeyPolicy,
+            ),
       );
 
       yield ActivationProgress(
         status: 'Establishing network connections...',
         progressPercentage: 40,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'connection',
+          currentStep: ActivationStep.connection,
           stepCount: 5,
           additionalInfo: {
             'nodes': protocol.requiredServers.toJsonRequest(),
@@ -108,7 +109,7 @@ class EthTaskActivationStrategy extends ProtocolActivationStrategy {
           if (status.status == 'Ok') {
             yield ActivationProgress.success(
               details: ActivationProgressDetails(
-                currentStep: 'complete',
+                currentStep: ActivationStep.complete,
                 stepCount: 5,
                 additionalInfo: {
                   'activatedChain': asset.id.name,
@@ -123,7 +124,7 @@ class EthTaskActivationStrategy extends ProtocolActivationStrategy {
               errorMessage: status.details,
               isComplete: true,
               progressDetails: ActivationProgressDetails(
-                currentStep: 'error',
+                currentStep: ActivationStep.error,
                 stepCount: 5,
                 errorCode: 'ETH_TASK_ACTIVATION_ERROR',
                 errorDetails: status.details,
@@ -151,7 +152,7 @@ class EthTaskActivationStrategy extends ProtocolActivationStrategy {
         errorMessage: e.toString(),
         isComplete: true,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'error',
+          currentStep: ActivationStep.error,
           stepCount: 5,
           errorCode: 'ETH_TASK_ACTIVATION_ERROR',
           errorDetails: e.toString(),
@@ -161,56 +162,61 @@ class EthTaskActivationStrategy extends ProtocolActivationStrategy {
     }
   }
 
-  ({String status, double percentage, String step, Map<String, dynamic> info})
+  ({
+    String status,
+    double percentage,
+    ActivationStep step,
+    Map<String, dynamic> info,
+  })
   _parseEthStatus(String status) {
     switch (status) {
       case 'ActivatingCoin':
         return (
           status: 'Activating platform coin...',
           percentage: 60,
-          step: 'coin_activation',
+          step: ActivationStep.platformActivation,
           info: {'activationType': 'platform'},
         );
       case 'RequestingWalletBalance':
         return (
           status: 'Requesting wallet balance...',
           percentage: 70,
-          step: 'balance_request',
+          step: ActivationStep.verification,
           info: {'dataType': 'balance'},
         );
       case 'ActivatingTokens':
         return (
           status: 'Activating ERC20 tokens...',
           percentage: 80,
-          step: 'token_activation',
+          step: ActivationStep.tokenActivation,
           info: {'activationType': 'tokens'},
         );
       case 'Finishing':
         return (
           status: 'Finalizing activation...',
           percentage: 90,
-          step: 'finalization',
+          step: ActivationStep.processing,
           info: {'stage': 'completion'},
         );
       case 'WaitingForTrezorToConnect':
         return (
           status: 'Waiting for Trezor device...',
           percentage: 50,
-          step: 'trezor_connection',
+          step: ActivationStep.connection,
           info: {'deviceType': 'Trezor', 'action': 'connect'},
         );
       case 'FollowHwDeviceInstructions':
         return (
           status: 'Follow instructions on hardware device',
           percentage: 55,
-          step: 'hardware_interaction',
+          step: ActivationStep.connection,
           info: {'deviceType': 'Hardware', 'action': 'follow_instructions'},
         );
       default:
         return (
           status: 'Processing activation...',
           percentage: 95,
-          step: 'processing',
+          step: ActivationStep.processing,
           info: {'status': status},
         );
     }
diff --git a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/eth_with_tokens_activation_strategy.dart b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/eth_with_tokens_activation_strategy.dart
index ce3dd2e08..4d3a6e1bc 100644
--- a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/eth_with_tokens_activation_strategy.dart
+++ b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/eth_with_tokens_activation_strategy.dart
@@ -52,7 +52,7 @@ class EthWithTokensActivationStrategy extends ProtocolActivationStrategy {
         status:
             'Activating ${asset.id.name} with ${children!.length} tokens...',
         progressDetails: ActivationProgressDetails(
-          currentStep: 'initialization',
+          currentStep: ActivationStep.initialization,
           stepCount: 3,
           additionalInfo: {
             'assetType': 'platform',
@@ -65,7 +65,7 @@ class EthWithTokensActivationStrategy extends ProtocolActivationStrategy {
       yield ActivationProgress(
         status: 'Activating ${asset.id.name}...',
         progressDetails: ActivationProgressDetails(
-          currentStep: 'initialization',
+          currentStep: ActivationStep.initialization,
           stepCount: 3,
           additionalInfo: {
             'assetType': 'platform',
@@ -80,7 +80,7 @@ class EthWithTokensActivationStrategy extends ProtocolActivationStrategy {
         status: 'Configuring platform activation...',
         progressPercentage: 33,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'configuration',
+          currentStep: ActivationStep.processing,
           stepCount: 3,
           additionalInfo: {
             'method': 'enableEthWithTokens',
@@ -91,30 +91,31 @@ class EthWithTokensActivationStrategy extends ProtocolActivationStrategy {
 
       await client.rpc.erc20.enableEthWithTokens(
         ticker: asset.id.id,
-        params: EthWithTokensActivationParams.fromJson(
-          asset.protocol.config,
-        ).copyWith(
-          erc20Tokens:
-              children?.map((e) => TokensRequest(ticker: e.id.id)).toList() ??
-              [],
-          txHistory: const EtherscanProtocolHelper()
-              .shouldEnableTransactionHistory(asset),
-          privKeyPolicy: privKeyPolicy,
-        ),
+        params: EthWithTokensActivationParams.fromJson(asset.protocol.config)
+            .copyWith(
+              erc20Tokens:
+                  children
+                      ?.map((e) => TokensRequest(ticker: e.id.id))
+                      .toList() ??
+                  [],
+              txHistory: const EtherscanProtocolHelper()
+                  .shouldEnableTransactionHistory(asset),
+              privKeyPolicy: privKeyPolicy,
+            ),
       );
 
       yield const ActivationProgress(
         status: 'Finalizing activation...',
         progressPercentage: 66,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'finalization',
+          currentStep: ActivationStep.processing,
           stepCount: 3,
         ),
       );
 
       yield ActivationProgress.success(
         details: ActivationProgressDetails(
-          currentStep: 'complete',
+          currentStep: ActivationStep.complete,
           stepCount: 3,
           additionalInfo: {
             'activatedChain': asset.id.name,
@@ -130,7 +131,7 @@ class EthWithTokensActivationStrategy extends ProtocolActivationStrategy {
         errorMessage: e.toString(),
         isComplete: true,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'error',
+          currentStep: ActivationStep.error,
           stepCount: 3,
           errorCode: 'ETH_WITH_TOKENS_ACTIVATION_ERROR',
           errorDetails: e.toString(),
diff --git a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/protocol_error_handler.dart b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/protocol_error_handler.dart
index 7bcbb6f46..e5d851534 100644
--- a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/protocol_error_handler.dart
+++ b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/protocol_error_handler.dart
@@ -21,7 +21,7 @@ class Erc20ErrorHandler extends ProtocolErrorHandler {
   ActivationProgressDetails handleError(Object error, StackTrace stack) {
     final code = getErrorCode(error);
     return ActivationProgressDetails(
-      currentStep: 'error',
+      currentStep: ActivationStep.error,
       stepCount: 2,
       errorCode: code,
       errorDetails: getUserMessage(error),
diff --git a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/qtum_activation_strategy.dart b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/qtum_activation_strategy.dart
index 44474931c..9092f927a 100644
--- a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/qtum_activation_strategy.dart
+++ b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/qtum_activation_strategy.dart
@@ -27,7 +27,7 @@ class QtumActivationStrategy extends ProtocolActivationStrategy {
     yield ActivationProgress(
       status: 'Starting QTUM activation...',
       progressDetails: ActivationProgressDetails(
-        currentStep: 'initialization',
+        currentStep: ActivationStep.initialization,
         stepCount: 4,
         additionalInfo: {
           'protocol': 'QTUM',
@@ -54,7 +54,7 @@ class QtumActivationStrategy extends ProtocolActivationStrategy {
           if (status.status == 'Ok') {
             yield ActivationProgress.success(
               details: ActivationProgressDetails(
-                currentStep: 'complete',
+                currentStep: ActivationStep.complete,
                 stepCount: 4,
                 additionalInfo: {
                   'activatedChain': asset.id.name,
@@ -68,7 +68,7 @@ class QtumActivationStrategy extends ProtocolActivationStrategy {
               errorMessage: status.details,
               isComplete: true,
               progressDetails: ActivationProgressDetails(
-                currentStep: 'error',
+                currentStep: ActivationStep.error,
                 stepCount: 4,
                 errorCode: 'QTUM_ACTIVATION_ERROR',
                 errorDetails: status.details,
@@ -96,7 +96,7 @@ class QtumActivationStrategy extends ProtocolActivationStrategy {
         errorMessage: e.toString(),
         isComplete: true,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'error',
+          currentStep: ActivationStep.error,
           stepCount: 4,
           errorCode: 'QTUM_ACTIVATION_ERROR',
           errorDetails: e.toString(),
@@ -106,35 +106,40 @@ class QtumActivationStrategy extends ProtocolActivationStrategy {
     }
   }
 
-  ({String status, double percentage, String step, Map<String, dynamic> info})
+  ({
+    String status,
+    double percentage,
+    ActivationStep step,
+    Map<String, dynamic> info,
+  })
   _parseQtumStatus(String status) {
     switch (status) {
       case 'ConnectingNodes':
         return (
           status: 'Connecting to QTUM nodes...',
           percentage: 25,
-          step: 'connection',
+          step: ActivationStep.connection,
           info: {'status': status},
         );
       case 'ValidatingConfig':
         return (
           status: 'Validating configuration...',
           percentage: 50,
-          step: 'validation',
+          step: ActivationStep.validation,
           info: {'status': status},
         );
       case 'LoadingContracts':
         return (
           status: 'Loading smart contracts...',
           percentage: 75,
-          step: 'contracts',
+          step: ActivationStep.contracts,
           info: {'status': status},
         );
       default:
         return (
           status: 'Processing activation...',
           percentage: 85,
-          step: 'processing',
+          step: ActivationStep.processing,
           info: {'status': status},
         );
     }
diff --git a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/slp_activation_strategy.dart b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/slp_activation_strategy.dart
index a29dcb05c..a627360bc 100644
--- a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/slp_activation_strategy.dart
+++ b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/slp_activation_strategy.dart
@@ -26,7 +26,7 @@ class SlpActivationStrategy extends ProtocolActivationStrategy {
     yield ActivationProgress(
       status: 'Starting BCH/SLP activation...',
       progressDetails: ActivationProgressDetails(
-        currentStep: 'initialization',
+        currentStep: ActivationStep.initialization,
         stepCount: 3,
         additionalInfo: {
           'assetType': isPlatformAsset ? 'platform' : 'token',
@@ -43,7 +43,7 @@ class SlpActivationStrategy extends ProtocolActivationStrategy {
           status: 'Configuring BCH platform...',
           progressPercentage: 33,
           progressDetails: ActivationProgressDetails(
-            currentStep: 'platform_setup',
+            currentStep: ActivationStep.platformSetup,
             stepCount: 3,
             additionalInfo: {
               'bchdServers': protocol.bchdUrls.length,
@@ -67,7 +67,7 @@ class SlpActivationStrategy extends ProtocolActivationStrategy {
           status: 'Activating SLP token...',
           progressPercentage: 66,
           progressDetails: ActivationProgressDetails(
-            currentStep: 'token_activation',
+            currentStep: ActivationStep.tokenActivation,
             stepCount: 3,
           ),
         );
@@ -79,7 +79,7 @@ class SlpActivationStrategy extends ProtocolActivationStrategy {
       }
       yield ActivationProgress.success(
         details: ActivationProgressDetails(
-          currentStep: 'complete',
+          currentStep: ActivationStep.complete,
           stepCount: 3,
           additionalInfo: {
             'activatedChain': asset.id.name,
@@ -93,7 +93,7 @@ class SlpActivationStrategy extends ProtocolActivationStrategy {
         errorMessage: e.toString(),
         isComplete: true,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'error',
+          currentStep: ActivationStep.error,
           stepCount: 3,
           errorCode: 'SLP_ACTIVATION_ERROR',
           errorDetails: e.toString(),
diff --git a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/tendermint_activation_strategy.dart b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/tendermint_activation_strategy.dart
index 86e6c64b2..ea50326c9 100644
--- a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/tendermint_activation_strategy.dart
+++ b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/tendermint_activation_strategy.dart
@@ -46,7 +46,7 @@ class TendermintWithTokensActivationStrategy
         status:
             'Activating ${asset.id.name} with ${children!.length} tokens...',
         progressDetails: ActivationProgressDetails(
-          currentStep: 'initialization',
+          currentStep: ActivationStep.initialization,
           stepCount: 5,
           additionalInfo: {
             'assetType': 'platform',
@@ -61,7 +61,7 @@ class TendermintWithTokensActivationStrategy
       yield ActivationProgress(
         status: 'Activating ${asset.id.name}...',
         progressDetails: ActivationProgressDetails(
-          currentStep: 'initialization',
+          currentStep: ActivationStep.initialization,
           stepCount: 5,
           additionalInfo: {
             'assetType': 'platform',
@@ -78,7 +78,7 @@ class TendermintWithTokensActivationStrategy
         status: 'Validating RPC endpoints...',
         progressPercentage: 20,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'validation',
+          currentStep: ActivationStep.validation,
           stepCount: 5,
           additionalInfo: {
             'rpcEndpoints': protocol.rpcUrlsMap.length,
@@ -91,7 +91,7 @@ class TendermintWithTokensActivationStrategy
         status: 'Initializing task-based activation...',
         progressPercentage: 40,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'task_initialization',
+          currentStep: ActivationStep.initialization,
           stepCount: 5,
         ),
       );
@@ -110,7 +110,7 @@ class TendermintWithTokensActivationStrategy
         status: 'Monitoring activation progress...',
         progressPercentage: 60,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'progress_monitoring',
+          currentStep: ActivationStep.processing,
           stepCount: 5,
           additionalInfo: {
             'taskId': taskResponse.taskId,
@@ -130,7 +130,7 @@ class TendermintWithTokensActivationStrategy
         if (status.status == SyncStatusEnum.success) {
           yield ActivationProgress.success(
             details: ActivationProgressDetails(
-              currentStep: 'complete',
+              currentStep: ActivationStep.complete,
               stepCount: 5,
               additionalInfo: {
                 'activatedChain': asset.id.name,
@@ -149,7 +149,7 @@ class TendermintWithTokensActivationStrategy
             errorMessage: status.details.error ?? 'Unknown error',
             isComplete: true,
             progressDetails: ActivationProgressDetails(
-              currentStep: 'error',
+              currentStep: ActivationStep.error,
               stepCount: 5,
               errorCode: 'TENDERMINT_TASK_ACTIVATION_ERROR',
               errorDetails: status.details.error,
@@ -176,7 +176,7 @@ class TendermintWithTokensActivationStrategy
         errorMessage: e.toString(),
         isComplete: true,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'error',
+          currentStep: ActivationStep.error,
           stepCount: 5,
           errorCode: 'TENDERMINT_WITH_TOKENS_ACTIVATION_ERROR',
           errorDetails: e.toString(),
@@ -186,29 +186,34 @@ class TendermintWithTokensActivationStrategy
     }
   }
 
-  ({String status, double percentage, String step, Map<String, dynamic> info})
+  ({
+    String status,
+    double percentage,
+    ActivationStep step,
+    Map<String, dynamic> info,
+  })
   _parseTendermintStatus(SyncStatusEnum status) {
     switch (status) {
+      case SyncStatusEnum.notStarted:
+        return (
+          status: 'Initializing Tendermint activation...',
+          percentage: 50,
+          step: ActivationStep.initialization,
+          info: {'stage': 'init', 'type': 'tendermint'},
+        );
       case SyncStatusEnum.inProgress:
         return (
           status: 'Synchronizing with Tendermint network...',
-          percentage: 80,
-          step: 'synchronization',
+          percentage: 75,
+          step: ActivationStep.blockchainSync,
           info: {'stage': 'sync', 'type': 'tendermint'},
         );
-      case SyncStatusEnum.notStarted:
-        return (
-          status: 'Preparing Tendermint activation...',
-          percentage: 70,
-          step: 'preparation',
-          info: {'stage': 'init', 'type': 'tendermint'},
-        );
-      case SyncStatusEnum.success:
-      case SyncStatusEnum.error:
+      // Success and error cases are handled in the main loop
+      default:
         return (
           status: 'Processing Tendermint activation...',
-          percentage: 85,
-          step: 'processing',
+          percentage: 60,
+          step: ActivationStep.processing,
           info: {'status': status.toString(), 'type': 'tendermint'},
         );
     }
diff --git a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/tendermint_task_activation_strategy.dart b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/tendermint_task_activation_strategy.dart
index 1aa7da74c..7beff48b1 100644
--- a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/tendermint_task_activation_strategy.dart
+++ b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/tendermint_task_activation_strategy.dart
@@ -38,7 +38,7 @@ class TendermintTaskActivationStrategy extends ProtocolActivationStrategy {
     yield ActivationProgress(
       status: 'Starting ${asset.id.name} activation...',
       progressDetails: ActivationProgressDetails(
-        currentStep: 'initialization',
+        currentStep: ActivationStep.initialization,
         stepCount: 5,
         additionalInfo: {
           'chainType': protocol.subClass.formatted,
@@ -54,7 +54,7 @@ class TendermintTaskActivationStrategy extends ProtocolActivationStrategy {
         status: 'Validating protocol configuration...',
         progressPercentage: 20,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'validation',
+          currentStep: ActivationStep.validation,
           stepCount: 5,
         ),
       );
@@ -73,7 +73,7 @@ class TendermintTaskActivationStrategy extends ProtocolActivationStrategy {
         status: 'Establishing network connections...',
         progressPercentage: 40,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'connection',
+          currentStep: ActivationStep.connection,
           stepCount: 5,
           additionalInfo: {
             'nodes': protocol.rpcUrlsMap.length,
@@ -95,7 +95,7 @@ class TendermintTaskActivationStrategy extends ProtocolActivationStrategy {
         if (status.status == SyncStatusEnum.success) {
           yield ActivationProgress.success(
             details: ActivationProgressDetails(
-              currentStep: 'complete',
+              currentStep: ActivationStep.complete,
               stepCount: 5,
               additionalInfo: {
                 'activatedChain': asset.id.name,
@@ -114,7 +114,7 @@ class TendermintTaskActivationStrategy extends ProtocolActivationStrategy {
             errorMessage: status.details.error ?? 'Unknown error',
             isComplete: true,
             progressDetails: ActivationProgressDetails(
-              currentStep: 'error',
+              currentStep: ActivationStep.error,
               stepCount: 5,
               errorCode: 'TENDERMINT_TASK_ACTIVATION_ERROR',
               errorDetails: status.details.error,
@@ -141,7 +141,7 @@ class TendermintTaskActivationStrategy extends ProtocolActivationStrategy {
         errorMessage: e.toString(),
         isComplete: true,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'error',
+          currentStep: ActivationStep.error,
           stepCount: 5,
           errorCode: 'TENDERMINT_TASK_ACTIVATION_ERROR',
           errorDetails: e.toString(),
@@ -151,30 +151,35 @@ class TendermintTaskActivationStrategy extends ProtocolActivationStrategy {
     }
   }
 
-  ({String status, double percentage, String step, Map<String, dynamic> info})
+  ({
+    String status,
+    double percentage,
+    ActivationStep step,
+    Map<String, dynamic> info,
+  })
   _parseTendermintStatus(SyncStatusEnum status) {
     switch (status) {
+      case SyncStatusEnum.notStarted:
+        return (
+          status: 'Initializing Tendermint activation...',
+          percentage: 50,
+          step: ActivationStep.initialization,
+          info: {'stage': 'init', 'type': 'tendermint'},
+        );
       case SyncStatusEnum.inProgress:
         return (
           status: 'Synchronizing with Tendermint network...',
-          percentage: 80,
-          step: 'synchronization',
+          percentage: 75,
+          step: ActivationStep.blockchainSync,
           info: {'stage': 'sync', 'type': 'tendermint'},
         );
-      case SyncStatusEnum.notStarted:
-        return (
-          status: 'Preparing Tendermint activation...',
-          percentage: 70,
-          step: 'preparation',
-          info: {'stage': 'init', 'type': 'tendermint'},
-        );
       case SyncStatusEnum.success:
       case SyncStatusEnum.error:
-        return (
-          status: 'Processing Tendermint activation...',
-          percentage: 85,
-          step: 'processing',
-          info: {'status': status.toString(), 'type': 'tendermint'},
+        // These cases should never be reached as they are handled in the main loop
+        // before calling this method. Including them for exhaustive enumeration.
+        throw StateError(
+          'Unexpected status $status in _parseTendermintStatus. '
+          'Success and error cases should be handled in the main activation loop.',
         );
     }
   }
diff --git a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/tendermint_token_activation_strategy.dart b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/tendermint_token_activation_strategy.dart
index 4f0f8aa17..4ce8da5dc 100644
--- a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/tendermint_token_activation_strategy.dart
+++ b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/tendermint_token_activation_strategy.dart
@@ -43,7 +43,7 @@ class TendermintTokenActivationStrategy extends ProtocolActivationStrategy {
     yield ActivationProgress(
       status: 'Activating ${asset.id.name} token...',
       progressDetails: ActivationProgressDetails(
-        currentStep: 'initialization',
+        currentStep: ActivationStep.initialization,
         stepCount: 3,
         additionalInfo: {
           'assetType': 'token',
@@ -58,7 +58,7 @@ class TendermintTokenActivationStrategy extends ProtocolActivationStrategy {
         status: 'Configuring token activation...',
         progressPercentage: 33,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'configuration',
+          currentStep: ActivationStep.processing,
           stepCount: 3,
           additionalInfo: {
             'method': 'enable_tendermint_token',
@@ -78,14 +78,14 @@ class TendermintTokenActivationStrategy extends ProtocolActivationStrategy {
         status: 'Finalizing activation...',
         progressPercentage: 66,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'finalization',
+          currentStep: ActivationStep.processing,
           stepCount: 3,
         ),
       );
 
       yield ActivationProgress.success(
         details: ActivationProgressDetails(
-          currentStep: 'complete',
+          currentStep: ActivationStep.complete,
           stepCount: 3,
           additionalInfo: {
             'activatedToken': asset.id.name,
@@ -101,7 +101,7 @@ class TendermintTokenActivationStrategy extends ProtocolActivationStrategy {
         errorMessage: e.toString(),
         isComplete: true,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'error',
+          currentStep: ActivationStep.error,
           stepCount: 3,
           errorCode: 'TENDERMINT_TOKEN_ACTIVATION_ERROR',
           errorDetails: e.toString(),
diff --git a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/utxo_activation_strategy.dart b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/utxo_activation_strategy.dart
index 3b3aacb02..fa293f339 100644
--- a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/utxo_activation_strategy.dart
+++ b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/utxo_activation_strategy.dart
@@ -33,7 +33,7 @@ class UtxoActivationStrategy extends ProtocolActivationStrategy {
     yield ActivationProgress(
       status: 'Starting ${asset.id.name} activation...',
       progressDetails: ActivationProgressDetails(
-        currentStep: 'initialization',
+        currentStep: ActivationStep.initialization,
         stepCount: 5,
         additionalInfo: {
           'chainType': protocol.subClass.formatted,
@@ -53,7 +53,7 @@ class UtxoActivationStrategy extends ProtocolActivationStrategy {
         status: 'Validating protocol configuration...',
         progressPercentage: 20,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'validation',
+          currentStep: ActivationStep.validation,
           stepCount: 5,
         ),
       );
@@ -67,7 +67,7 @@ class UtxoActivationStrategy extends ProtocolActivationStrategy {
         status: 'Establishing network connections...',
         progressPercentage: 40,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'connection',
+          currentStep: ActivationStep.connection,
           stepCount: 5,
           additionalInfo: {
             'electrumServers': protocol.requiredServers.toJsonRequest(),
@@ -86,7 +86,7 @@ class UtxoActivationStrategy extends ProtocolActivationStrategy {
           if (status.status == 'Ok') {
             yield ActivationProgress.success(
               details: ActivationProgressDetails(
-                currentStep: 'complete',
+                currentStep: ActivationStep.complete,
                 stepCount: 5,
                 additionalInfo: {
                   'activatedChain': asset.id.name,
@@ -102,7 +102,7 @@ class UtxoActivationStrategy extends ProtocolActivationStrategy {
               errorMessage: status.details,
               isComplete: true,
               progressDetails: ActivationProgressDetails(
-                currentStep: 'error',
+                currentStep: ActivationStep.error,
                 stepCount: 5,
                 errorCode: 'UTXO_ACTIVATION_ERROR',
                 errorDetails: status.details,
@@ -130,7 +130,7 @@ class UtxoActivationStrategy extends ProtocolActivationStrategy {
         errorMessage: e.toString(),
         isComplete: true,
         progressDetails: ActivationProgressDetails(
-          currentStep: 'error',
+          currentStep: ActivationStep.error,
           stepCount: 5,
           errorCode: 'UTXO_ACTIVATION_ERROR',
           errorDetails: e.toString(),
@@ -140,35 +140,35 @@ class UtxoActivationStrategy extends ProtocolActivationStrategy {
     }
   }
 
-  ({String status, double percentage, String step, Map<String, dynamic> info})
-  _parseUtxoStatus(String status) {
+  ({String status, double percentage, ActivationStep step, Map<String, dynamic> info})
+      _parseUtxoStatus(String status) {
     switch (status) {
       case 'ConnectingElectrum':
         return (
           status: 'Connecting to Electrum servers...',
           percentage: 60,
-          step: 'electrum_connection',
+          step: ActivationStep.electrumConnection,
           info: {'connectionType': 'Electrum'},
         );
       case 'LoadingBlockchain':
         return (
           status: 'Loading blockchain data...',
           percentage: 80,
-          step: 'blockchain_sync',
+          step: ActivationStep.blockchainSync,
           info: {'dataType': 'blockchain'},
         );
       case 'ScanningTransactions':
         return (
           status: 'Scanning transaction history...',
           percentage: 90,
-          step: 'tx_scan',
+          step: ActivationStep.txScan,
           info: {'dataType': 'transactions'},
         );
       default:
         return (
           status: 'Processing activation...',
           percentage: 95,
-          step: 'processing',
+          step: ActivationStep.processing,
           info: {'status': status},
         );
     }
diff --git a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/zhtlc_activation_progress.dart b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/zhtlc_activation_progress.dart
new file mode 100644
index 000000000..70e094ab0
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/zhtlc_activation_progress.dart
@@ -0,0 +1,90 @@
+// TODO(komodo-team): Allow passing the start sync mode; currently hard-coded
+// to sync from the time of activation.
+
+import 'package:komodo_defi_types/komodo_defi_types.dart';
+
+/// Convenience wrapper around [ActivationProgress] that exposes the canonical
+/// progress snapshots used throughout ZHTLC activation.
+class ZhtlcActivationProgress extends ActivationProgress {
+  static const errorCode = 'ZHTLC_ACTIVATION_ERROR';
+
+  const ZhtlcActivationProgress._({
+    required super.status,
+    super.isComplete,
+    super.errorMessage,
+    super.progressDetails,
+  });
+
+  /// Creates the initial "starting activation" progress update.
+  factory ZhtlcActivationProgress.starting(Asset asset) {
+    return ZhtlcActivationProgress._(
+      status: 'Starting ZHTLC activation...',
+      progressDetails: ActivationProgressDetails(
+        currentStep: ActivationStep.initialization,
+        stepCount: 6,
+        additionalInfo: {'protocol': 'ZHTLC', 'asset': asset.id.name},
+      ),
+    );
+  }
+
+  /// Emits progress while validating protocol configuration before task start.
+  factory ZhtlcActivationProgress.validation(ZhtlcProtocol protocol) {
+    return ZhtlcActivationProgress._(
+      status: 'Validating ZHTLC parameters...',
+      progressDetails: ActivationProgressDetails(
+        currentStep: ActivationStep.validation,
+        stepCount: 6,
+        additionalInfo: {
+          'electrumServers': protocol.requiredServers.toJsonRequest(),
+          'zcashParamsPath': protocol.zcashParamsPath,
+        },
+      ),
+    );
+  }
+
+  /// Emits a terminal failure progress snapshot for unexpected exceptions.
+  factory ZhtlcActivationProgress.failure(Object error, StackTrace stack) {
+    return ZhtlcActivationProgress._(
+      status: 'Activation failed',
+      errorMessage: error.toString(),
+      isComplete: true,
+      progressDetails: ActivationProgressDetails(
+        currentStep: ActivationStep.error,
+        stepCount: 6,
+        errorCode: ZhtlcActivationProgress.errorCode,
+        errorDetails: error.toString(),
+        stackTrace: stack.toString(),
+        additionalInfo: {
+          'errorType': error.runtimeType.toString(),
+          'timestamp': DateTime.now().toUtc().toIso8601String(),
+        },
+      ),
+    );
+  }
+
+  /// Emits a terminal failure snapshot when required Zcash params are missing.
+  factory ZhtlcActivationProgress.missingZcashParams() {
+    return const ZhtlcActivationProgress._(
+      status: 'Zcash params path required',
+      errorMessage: 'Zcash params path required',
+      isComplete: true,
+      progressDetails: ActivationProgressDetails(
+        currentStep: ActivationStep.error,
+        stepCount: 1,
+      ),
+    );
+  }
+}
+
+/// Additional helpers for creating ZHTLC-specific [ActivationProgress] states.
+extension ActivationProgressZhtlc on ActivationProgress {
+  /// Convenience helper for the missing Zcash params terminal state.
+  static ActivationProgress missingZcashParams() {
+    return ZhtlcActivationProgress.missingZcashParams();
+  }
+
+  /// Convenience helper for wrapping unexpected activation failures.
+  static ActivationProgress failure(Object error, StackTrace stack) {
+    return ZhtlcActivationProgress.failure(error, stack);
+  }
+}
diff --git a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/zhtlc_activation_progress_estimator.dart b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/zhtlc_activation_progress_estimator.dart
new file mode 100644
index 000000000..f60420c0c
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/zhtlc_activation_progress_estimator.dart
@@ -0,0 +1,650 @@
+import 'dart:math' as math;
+
+import 'package:komodo_defi_rpc_methods/komodo_defi_rpc_methods.dart';
+import 'package:komodo_defi_sdk/src/activation/protocol_strategies/zhtlc_activation_progress.dart';
+import 'package:komodo_defi_types/komodo_defi_type_utils.dart';
+import 'package:komodo_defi_types/komodo_defi_types.dart';
+
+/// High-level phases emitted by the ZHTLC activation task engine.
+enum ZhtlcActivationPhase {
+  /// Initial stage where the protocol sends activation requests.
+  activatingCoin,
+
+  /// Phase in which the lightwalletd cache is updated before scanning.
+  updatingBlocksCache,
+
+  /// Phase dedicated to building the ZHTLC wallet database.
+  buildingWalletDb,
+
+  /// Waiting for a connection to an available lightwalletd server.
+  waitingLightwalletd,
+
+  /// Fetching balance information from the backend.
+  requestingWalletBalance,
+
+  /// Finalization stage reported before completion.
+  finishing,
+
+  /// Waiting for a hardware wallet (e.g. Trezor) to connect.
+  waitingForTrezor,
+
+  /// Waiting for the user to follow hardware-device instructions.
+  followHardwareInstructions,
+
+  /// Activation task reports that all work has completed successfully.
+  completed,
+
+  /// Activation task reports an unrecoverable error.
+  error,
+
+  /// State could not be classified into a known phase.
+  unknown,
+}
+
+/// Tunable weights applied when converting task phases into user-facing
+/// progress percentages.
+class ZhtlcProgressWeights {
+  /// Creates a [ZhtlcProgressWeights] instance with optional overrides for the
+  /// default percentage contributions.
+  const ZhtlcProgressWeights({
+    this.defaultProgress = 2,
+    this.activatingCoin = 1,
+    this.requestingWalletBalance = 99,
+    this.waitingLightwalletd = 60,
+    this.waitingForTrezor = 45,
+    this.followingHardwareInstructions = 55,
+    this.finishing = 99,
+    this.scanningBlocks = 98,
+    this.updatingBlocksCacheWeight = 15,
+    this.buildingWalletDbWeight = 98,
+    this.minWalletDbProgress = 15,
+  });
+
+  /// Fallback percentage when no better estimate is possible.
+  final double defaultProgress;
+
+  /// Activation progress when "ActivatingCoin" is reported.
+  final double activatingCoin;
+
+  /// Activation progress when balances are being fetched.
+  final double requestingWalletBalance;
+
+  /// Activation progress when waiting for lightwalletd connection.
+  final double waitingLightwalletd;
+
+  /// Activation progress when waiting for a hardware wallet connection.
+  final double waitingForTrezor;
+
+  /// Activation progress when following hardware wallet instructions.
+  final double followingHardwareInstructions;
+
+  /// Activation progress when activation is in the finishing phase.
+  final double finishing;
+
+  /// Activation progress when scanning blocks without ratio context.
+  final double scanningBlocks;
+
+  /// Maximum contribution for the block cache warm-up stage.
+  final double updatingBlocksCacheWeight;
+
+  /// Maximum contribution for the wallet DB build stage.
+  final double buildingWalletDbWeight;
+
+  /// Minimum progress reported during wallet DB build.
+  final double minWalletDbProgress;
+}
+
+/// Parsed representation of the `details` payload emitted by the task engine
+/// during activation.
+class ZhtlcStatusDetail {
+  /// Creates a [ZhtlcStatusDetail] from the parsed activation payload.
+  const ZhtlcStatusDetail({
+    required this.phase,
+    required this.raw,
+    this.rawJson,
+    this.message,
+    this.error,
+    this.currentScannedBlock,
+    this.latestBlock,
+  });
+
+  /// Phase categorized from the raw task details.
+  final ZhtlcActivationPhase phase;
+
+  /// Raw JSON string or label reported by the task engine.
+  final String raw;
+
+  /// Parsed representation of [raw] when it contains JSON.
+  final JsonMap? rawJson;
+
+  /// Human-readable status message derived from the payload.
+  final String? message;
+
+  /// Optional error metadata returned by the task engine.
+  final JsonMap? error;
+
+  /// Current block that has been processed, if reported.
+  final int? currentScannedBlock;
+
+  /// Highest known block height at the time of reporting.
+  final int? latestBlock;
+
+  /// Whether the payload contains an explicit error description.
+  bool get hasError => error != null;
+
+  /// Ratio of processed blocks to the latest known block, if available.
+  double? get progressRatio {
+    final current = currentScannedBlock;
+    final latest = latestBlock;
+    if (current == null || latest == null || latest <= 0) {
+      return null;
+    }
+    return current / latest;
+  }
+}
+
+/// Converts ZHTLC task status updates into `ActivationProgress` snapshots using
+/// heuristics derived from the legacy C++ activation flow.
+class ZhtlcActivationProgressEstimator {
+  /// Creates a [ZhtlcActivationProgressEstimator] that applies the provided
+  /// [weights] and exposes [stepCount] steps to the UI.
+  const ZhtlcActivationProgressEstimator({
+    this.weights = const ZhtlcProgressWeights(),
+    this.stepCount = 6,
+  });
+
+  /// Weight configuration applied when translating phases to percentages.
+  final ZhtlcProgressWeights weights;
+
+  /// Number of activation steps surfaced to the UI for progress reporting.
+  final int stepCount;
+
+  /// Estimates the activation progress for a given ZHTLC task status.
+  ActivationProgress estimate({
+    required TaskStatusResponse status,
+    required Asset asset,
+    ZhtlcStatusDetail? detail,
+    int? currentBlock,
+  }) {
+    final parsedDetail = detail ?? parse(status.details);
+    final baseInfo = _buildAdditionalInfo(
+      asset,
+      status,
+      parsedDetail,
+      currentBlock,
+    );
+
+    if (status.status == 'Ok') {
+      if (parsedDetail.hasError) {
+        final message =
+            _extractErrorMessage(parsedDetail.error) ?? 'Unknown error';
+        return ActivationProgress(
+          status: 'Activation failed',
+          errorMessage: message,
+          isComplete: true,
+          progressDetails: ActivationProgressDetails(
+            currentStep: ActivationStep.error,
+            stepCount: stepCount,
+            errorCode: ZhtlcActivationProgress.errorCode,
+            errorDetails: message,
+            additionalInfo: baseInfo,
+          ),
+        );
+      }
+
+      return ActivationProgress.success(
+        details: ActivationProgressDetails(
+          currentStep: ActivationStep.complete,
+          stepCount: stepCount,
+          additionalInfo: {...baseInfo, 'activatedChain': asset.id.name},
+        ),
+      );
+    }
+
+    if (status.status == 'Error' ||
+        parsedDetail.phase == ZhtlcActivationPhase.error) {
+      final message = parsedDetail.message ?? status.details;
+      return ActivationProgress(
+        status: 'Activation failed',
+        errorMessage: message,
+        isComplete: true,
+        progressDetails: ActivationProgressDetails(
+          currentStep: ActivationStep.error,
+          stepCount: stepCount,
+          errorCode: ZhtlcActivationProgress.errorCode,
+          errorDetails: parsedDetail.error != null
+              ? jsonToString(parsedDetail.error)
+              : message,
+          additionalInfo: baseInfo,
+        ),
+      );
+    }
+
+    final progress = _estimateProgress(parsedDetail).clamp(0, 100).toDouble();
+    final statusMessage = parsedDetail.message ?? status.details;
+    final awaitingUserAction =
+        status.status == 'UserActionRequired' ||
+        parsedDetail.phase == ZhtlcActivationPhase.waitingForTrezor ||
+        parsedDetail.phase == ZhtlcActivationPhase.followHardwareInstructions;
+
+    return ActivationProgress(
+      status: statusMessage,
+      progressPercentage: progress,
+      progressDetails: ActivationProgressDetails(
+        currentStep: _mapPhaseToStep(parsedDetail.phase),
+        stepCount: stepCount,
+        additionalInfo: baseInfo,
+        uiSignal: awaitingUserAction
+            ? ActivationUiSignal.awaitingUserInput
+            : null,
+      ),
+    );
+  }
+
+  /// Parses the raw task details payload into a structured representation.
+  ZhtlcStatusDetail parse(String rawDetails) {
+    final trimmed = rawDetails.trim();
+    if (trimmed.isEmpty) {
+      return ZhtlcStatusDetail(
+        phase: ZhtlcActivationPhase.unknown,
+        raw: rawDetails,
+        message: 'Awaiting activation status...',
+      );
+    }
+
+    final json = tryParseJson(trimmed);
+    if (json != null && json.isNotEmpty) {
+      if (json.containsKey('error')) {
+        return ZhtlcStatusDetail(
+          phase: ZhtlcActivationPhase.error,
+          raw: rawDetails,
+          rawJson: json,
+          message: _extractErrorMessage(json['error']) ?? 'Activation error',
+          error: json['error'] is JsonMap
+              ? Map<String, dynamic>.from(json['error'] as Map)
+              : {'message': json['error']},
+        );
+      }
+
+      if (json.containsKey('wallet_balance') ||
+          json.containsKey('current_block') ||
+          json.containsKey('ticker')) {
+        return ZhtlcStatusDetail(
+          phase: ZhtlcActivationPhase.completed,
+          raw: rawDetails,
+          rawJson: json,
+          message: 'Activation completed successfully',
+        );
+      }
+
+      for (final key in json.keys) {
+        final normalizedKey = key.trim();
+        final payload = json[key];
+        switch (_phaseFromKey(normalizedKey)) {
+          case ZhtlcActivationPhase.updatingBlocksCache:
+            final data = _asJsonMap(payload);
+            return ZhtlcStatusDetail(
+              phase: ZhtlcActivationPhase.updatingBlocksCache,
+              raw: rawDetails,
+              rawJson: json,
+              message: 'Updating ZHTLC blocks cache...',
+              currentScannedBlock: _asInt(data['current_scanned_block']),
+              latestBlock: _asInt(data['latest_block']),
+            );
+          case ZhtlcActivationPhase.buildingWalletDb:
+            final data = _asJsonMap(payload);
+            return ZhtlcStatusDetail(
+              phase: ZhtlcActivationPhase.buildingWalletDb,
+              raw: rawDetails,
+              rawJson: json,
+              message: 'Building wallet database...',
+              currentScannedBlock: _asInt(data['current_scanned_block']),
+              latestBlock: _asInt(data['latest_block']),
+            );
+          case ZhtlcActivationPhase.requestingWalletBalance:
+            return ZhtlcStatusDetail(
+              phase: ZhtlcActivationPhase.requestingWalletBalance,
+              raw: rawDetails,
+              rawJson: json,
+              message: 'Requesting wallet balance...',
+            );
+          case ZhtlcActivationPhase.finishing:
+            return ZhtlcStatusDetail(
+              phase: ZhtlcActivationPhase.finishing,
+              raw: rawDetails,
+              rawJson: json,
+              message: 'Finalizing activation...',
+            );
+          case ZhtlcActivationPhase.waitingForTrezor:
+            return ZhtlcStatusDetail(
+              phase: ZhtlcActivationPhase.waitingForTrezor,
+              raw: rawDetails,
+              rawJson: json,
+              message: 'Waiting for Trezor device...',
+            );
+          case ZhtlcActivationPhase.followHardwareInstructions:
+            return ZhtlcStatusDetail(
+              phase: ZhtlcActivationPhase.followHardwareInstructions,
+              raw: rawDetails,
+              rawJson: json,
+              message: 'Follow instructions on hardware device...',
+            );
+          case ZhtlcActivationPhase.activatingCoin:
+            return ZhtlcStatusDetail(
+              phase: ZhtlcActivationPhase.activatingCoin,
+              raw: rawDetails,
+              rawJson: json,
+              message: 'Activating coin...',
+            );
+          case ZhtlcActivationPhase.waitingLightwalletd:
+            return ZhtlcStatusDetail(
+              phase: ZhtlcActivationPhase.waitingLightwalletd,
+              raw: rawDetails,
+              rawJson: json,
+              message: 'Connecting to Lightwalletd server...',
+            );
+          case ZhtlcActivationPhase.completed:
+            return ZhtlcStatusDetail(
+              phase: ZhtlcActivationPhase.completed,
+              raw: rawDetails,
+              rawJson: json,
+              message: 'Activation completed successfully',
+            );
+          case ZhtlcActivationPhase.error:
+            return ZhtlcStatusDetail(
+              phase: ZhtlcActivationPhase.error,
+              raw: rawDetails,
+              rawJson: json,
+              message: _extractErrorMessage(payload) ?? 'Activation error',
+              error: _asJsonMap(payload),
+            );
+          case ZhtlcActivationPhase.unknown:
+            continue;
+        }
+      }
+    }
+
+    final phase = _phaseFromKey(trimmed);
+    switch (phase) {
+      case ZhtlcActivationPhase.updatingBlocksCache:
+        return ZhtlcStatusDetail(
+          phase: phase,
+          raw: rawDetails,
+          message: 'Updating ZHTLC blocks cache...',
+        );
+      case ZhtlcActivationPhase.buildingWalletDb:
+        return ZhtlcStatusDetail(
+          phase: phase,
+          raw: rawDetails,
+          message: 'Building wallet database...',
+        );
+      case ZhtlcActivationPhase.waitingLightwalletd:
+        return ZhtlcStatusDetail(
+          phase: phase,
+          raw: rawDetails,
+          message: 'Connecting to Lightwalletd server...',
+        );
+      case ZhtlcActivationPhase.requestingWalletBalance:
+        return ZhtlcStatusDetail(
+          phase: phase,
+          raw: rawDetails,
+          message: 'Requesting wallet balance...',
+        );
+      case ZhtlcActivationPhase.finishing:
+        return ZhtlcStatusDetail(
+          phase: phase,
+          raw: rawDetails,
+          message: 'Finalizing activation...',
+        );
+      case ZhtlcActivationPhase.waitingForTrezor:
+        return ZhtlcStatusDetail(
+          phase: phase,
+          raw: rawDetails,
+          message: 'Waiting for Trezor device...',
+        );
+      case ZhtlcActivationPhase.followHardwareInstructions:
+        return ZhtlcStatusDetail(
+          phase: phase,
+          raw: rawDetails,
+          message: 'Follow instructions on hardware device...',
+        );
+      case ZhtlcActivationPhase.activatingCoin:
+        return ZhtlcStatusDetail(
+          phase: phase,
+          raw: rawDetails,
+          message: 'Activating coin...',
+        );
+      case ZhtlcActivationPhase.completed:
+        return ZhtlcStatusDetail(
+          phase: phase,
+          raw: rawDetails,
+          message: 'Activation completed successfully',
+        );
+      case ZhtlcActivationPhase.error:
+        return ZhtlcStatusDetail(
+          phase: phase,
+          raw: rawDetails,
+          message: 'Activation error',
+        );
+      case ZhtlcActivationPhase.unknown:
+        return ZhtlcStatusDetail(
+          phase: ZhtlcActivationPhase.unknown,
+          raw: rawDetails,
+          message: rawDetails,
+        );
+    }
+  }
+
+  double _estimateProgress(ZhtlcStatusDetail detail) {
+    switch (detail.phase) {
+      case ZhtlcActivationPhase.activatingCoin:
+        return weights.activatingCoin;
+      case ZhtlcActivationPhase.updatingBlocksCache:
+        final ratio = detail.progressRatio;
+        if (ratio == null) {
+          return weights.defaultProgress;
+        }
+        return math.min(
+          weights.updatingBlocksCacheWeight,
+          ratio * weights.updatingBlocksCacheWeight,
+        );
+      case ZhtlcActivationPhase.buildingWalletDb:
+        final ratio = detail.progressRatio;
+        if (ratio == null) {
+          return weights.minWalletDbProgress;
+        }
+        final computed = ratio * weights.buildingWalletDbWeight;
+        return math.max(
+          weights.minWalletDbProgress,
+          math.min(weights.buildingWalletDbWeight, computed),
+        );
+      case ZhtlcActivationPhase.waitingLightwalletd:
+        return weights.waitingLightwalletd;
+      case ZhtlcActivationPhase.finishing:
+        return weights.finishing;
+      case ZhtlcActivationPhase.waitingForTrezor:
+        return weights.waitingForTrezor;
+      case ZhtlcActivationPhase.followHardwareInstructions:
+        return weights.followingHardwareInstructions;
+      case ZhtlcActivationPhase.requestingWalletBalance:
+        return weights.requestingWalletBalance;
+      case ZhtlcActivationPhase.completed:
+        return 100;
+      case ZhtlcActivationPhase.error:
+        return 0;
+      case ZhtlcActivationPhase.unknown:
+        return weights.defaultProgress;
+    }
+  }
+
+  ActivationStep _mapPhaseToStep(ZhtlcActivationPhase phase) {
+    switch (phase) {
+      case ZhtlcActivationPhase.activatingCoin:
+        return ActivationStep.initialization;
+      case ZhtlcActivationPhase.updatingBlocksCache:
+        return ActivationStep.blockchainSync;
+      case ZhtlcActivationPhase.buildingWalletDb:
+        return ActivationStep.database;
+      case ZhtlcActivationPhase.waitingLightwalletd:
+        return ActivationStep.connection;
+      case ZhtlcActivationPhase.requestingWalletBalance:
+        return ActivationStep.processing;
+      case ZhtlcActivationPhase.finishing:
+        return ActivationStep.processing;
+      case ZhtlcActivationPhase.waitingForTrezor:
+        return ActivationStep.connection;
+      case ZhtlcActivationPhase.followHardwareInstructions:
+        return ActivationStep.connection;
+      case ZhtlcActivationPhase.completed:
+        return ActivationStep.complete;
+      case ZhtlcActivationPhase.error:
+        return ActivationStep.error;
+      case ZhtlcActivationPhase.unknown:
+        return ActivationStep.processing;
+    }
+  }
+
+  Map<String, dynamic> _buildAdditionalInfo(
+    Asset asset,
+    TaskStatusResponse status,
+    ZhtlcStatusDetail detail,
+    int? currentBlock,
+  ) {
+    final info = <String, dynamic>{
+      'asset': asset.id.name,
+      'phase': detail.phase.name,
+      'taskStatus': status.status,
+    };
+
+    if (detail.currentScannedBlock != null) {
+      info['currentScannedBlock'] = detail.currentScannedBlock;
+    }
+    if (detail.latestBlock != null) {
+      info['latestBlock'] = detail.latestBlock;
+    }
+    final ratio = detail.progressRatio;
+    if (ratio != null) {
+      info['progressRatio'] = ratio;
+    }
+    if (currentBlock != null) {
+      info['currentWalletBlock'] = currentBlock;
+    }
+
+    if (status.status == 'UserActionRequired') {
+      info['awaitingUserAction'] = true;
+    }
+
+    switch (detail.phase) {
+      case ZhtlcActivationPhase.waitingForTrezor:
+        info['userActionType'] = 'connect_trezor';
+        break;
+      case ZhtlcActivationPhase.followHardwareInstructions:
+        info['userActionType'] = 'hardware_instructions';
+        break;
+      case ZhtlcActivationPhase.finishing:
+        info['stage'] = 'finishing';
+        break;
+      default:
+        break;
+    }
+
+    if (detail.rawJson != null && detail.rawJson!.isNotEmpty) {
+      info['rawDetails'] = detail.rawJson;
+    } else {
+      info['rawDetails'] = detail.raw;
+    }
+
+    if (detail.error != null && detail.error!.isNotEmpty) {
+      info['error'] = detail.error;
+    }
+
+    return info;
+  }
+
+  static ZhtlcActivationPhase _phaseFromKey(String key) {
+    final normalized = key.trim().toLowerCase().replaceAll(
+      RegExp(r'[^a-z0-9]'),
+      '',
+    );
+    if (normalized.contains('updatingblockscache')) {
+      return ZhtlcActivationPhase.updatingBlocksCache;
+    }
+    if (normalized.contains('buildingwalletdb')) {
+      return ZhtlcActivationPhase.buildingWalletDb;
+    }
+    if (normalized.contains('waitinglightwalletd')) {
+      return ZhtlcActivationPhase.waitingLightwalletd;
+    }
+    if (normalized.contains('requestingwalletbalance')) {
+      return ZhtlcActivationPhase.requestingWalletBalance;
+    }
+    if (normalized.contains('finishing')) {
+      return ZhtlcActivationPhase.finishing;
+    }
+    if (normalized.contains('waitingfortrezor')) {
+      return ZhtlcActivationPhase.waitingForTrezor;
+    }
+    if (normalized.contains('followhwdeviceinstructions')) {
+      return ZhtlcActivationPhase.followHardwareInstructions;
+    }
+    if (normalized.contains('activatingcoin')) {
+      return ZhtlcActivationPhase.activatingCoin;
+    }
+    if (normalized.contains('completed') || normalized.contains('finished')) {
+      return ZhtlcActivationPhase.completed;
+    }
+    if (normalized.contains('error') || normalized.contains('failed')) {
+      return ZhtlcActivationPhase.error;
+    }
+    return ZhtlcActivationPhase.unknown;
+  }
+
+  static JsonMap _asJsonMap(dynamic value) {
+    if (value is JsonMap) {
+      return value;
+    }
+    if (value is Map) {
+      return value.map((key, dynamic val) => MapEntry(key.toString(), val));
+    }
+    if (value is String) {
+      return tryParseJson(value) ?? <String, dynamic>{};
+    }
+    return <String, dynamic>{};
+  }
+
+  static int? _asInt(dynamic value) {
+    if (value is int) return value;
+    if (value is double) return value.toInt();
+    if (value is num) return value.toInt();
+    if (value is String) return int.tryParse(value);
+    return null;
+  }
+
+  static String? _extractErrorMessage(dynamic error) {
+    if (error is String) {
+      return error;
+    }
+    if (error is Map) {
+      final map = error.map(
+        (key, dynamic value) => MapEntry(key.toString(), value),
+      );
+      if (map['message'] is String) {
+        return map['message'] as String;
+      }
+      if (map['reason'] is String) {
+        return map['reason'] as String;
+      }
+      if (map['details'] is String) {
+        return map['details'] as String;
+      }
+      for (final entry in map.entries) {
+        final value = entry.value;
+        if (value is String && value.isNotEmpty) {
+          return value;
+        }
+      }
+      return null;
+    }
+    return null;
+  }
+}
diff --git a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/zhtlc_activation_strategy.dart b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/zhtlc_activation_strategy.dart
index d5682fb4e..c59377a9e 100644
--- a/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/zhtlc_activation_strategy.dart
+++ b/packages/komodo_defi_sdk/lib/src/activation/protocol_strategies/zhtlc_activation_strategy.dart
@@ -1,15 +1,39 @@
-// TODO: Refactor so that the start sync mode can be passed. For now, it is
-// hard-coded to sync from the time of activation.
+// TODO(komodo-team): Allow passing the start sync mode; currently hard-coded
+// to sync from the time of activation.
 
 import 'package:komodo_defi_rpc_methods/komodo_defi_rpc_methods.dart';
 import 'package:komodo_defi_sdk/src/activation/_activation.dart';
+import 'package:komodo_defi_sdk/src/activation/protocol_strategies/zhtlc_activation_progress.dart';
+import 'package:komodo_defi_sdk/src/activation/protocol_strategies/zhtlc_activation_progress_estimator.dart';
+import 'package:komodo_defi_sdk/src/activation_config/activation_config_service.dart';
 import 'package:komodo_defi_types/komodo_defi_types.dart';
 
+/// Activation strategy for ZHTLC-based assets that translates task updates into
+/// user-facing progress events.
 class ZhtlcActivationStrategy extends ProtocolActivationStrategy {
-  const ZhtlcActivationStrategy(super.client, this.privKeyPolicy);
-
+  /// Creates a strategy that activates ZHTLC assets using the provided
+  /// services.
+  const ZhtlcActivationStrategy(
+    super.client,
+    this.privKeyPolicy,
+    this.configService, {
+    this.pollingInterval = const Duration(milliseconds: 500),
+    ZhtlcActivationProgressEstimator? progressEstimator,
+  }) : progressEstimator =
+           progressEstimator ?? const ZhtlcActivationProgressEstimator();
+
+  /// Policy used when deriving private keys during activation.
   final PrivateKeyPolicy privKeyPolicy;
 
+  /// Service that provides user-configured activation parameters.
+  final ActivationConfigService configService;
+
+  /// Progress estimator that maps task status updates to activation progress.
+  final ZhtlcActivationProgressEstimator progressEstimator;
+
+  /// Interval between TaskShepherd status polls when monitoring activation.
+  final Duration pollingInterval;
+
   @override
   Set<CoinSubClass> get supportedProtocols => {CoinSubClass.zhtlc};
 
@@ -27,172 +51,100 @@ class ZhtlcActivationStrategy extends ProtocolActivationStrategy {
       );
     }
 
-    yield ActivationProgress(
-      status: 'Starting ZHTLC activation...',
-      progressDetails: ActivationProgressDetails(
-        currentStep: 'initialization',
-        stepCount: 6,
-        additionalInfo: {
-          'protocol': 'ZHTLC',
-          'asset': asset.id.name,
-          'scanBlocksPerIteration': 200,
-        },
-      ),
-    );
+    yield ZhtlcActivationProgress.starting(asset);
 
     try {
       final protocol = asset.protocol as ZhtlcProtocol;
-      final params = ActivationParams.fromConfigJson(
-        protocol.config,
-      ).genericCopyWith(
-        scanBlocksPerIteration: 200,
-        scanIntervalMs: 200,
-        zcashParamsPath: protocol.zcashParamsPath,
-        privKeyPolicy: privKeyPolicy,
-      );
+      final userConfig = await configService.getZhtlcOrRequest(asset.id);
 
-      // Setup parameters
-
-      yield ActivationProgress(
-        status: 'Validating ZHTLC parameters...',
-        progressPercentage: 20,
-        progressDetails: ActivationProgressDetails(
-          currentStep: 'validation',
-          stepCount: 6,
-          additionalInfo: {
-            'electrumServers': protocol.requiredServers.toJsonRequest(),
-            'zcashParamsPath': protocol.zcashParamsPath,
-          },
-        ),
-      );
-
-      // Initialize task
-      final taskResponse = await client.rpc.task.execute(
-        TaskEnableZhtlcInit(params: params, ticker: asset.id.id),
-      );
+      if (userConfig == null || userConfig.zcashParamsPath.trim().isEmpty) {
+        yield ActivationProgressZhtlc.missingZcashParams();
+        return;
+      }
 
-      var isComplete = false;
-      var buildingWalletDb = false;
-      var scanningBlocks = false;
-      var currentBlock = 0;
+      final effectivePollingInterval =
+          userConfig.taskStatusPollingIntervalMs != null &&
+                  userConfig.taskStatusPollingIntervalMs! > 0
+              ? Duration(
+                  milliseconds: userConfig.taskStatusPollingIntervalMs!,
+                )
+              : pollingInterval;
+
+      var params = ZhtlcActivationParams.fromConfigJson(protocol.config)
+          .copyWith(
+            scanBlocksPerIteration: userConfig.scanBlocksPerIteration,
+            scanIntervalMs: userConfig.scanIntervalMs,
+            zcashParamsPath: userConfig.zcashParamsPath,
+            privKeyPolicy: privKeyPolicy,
+          );
+
+      // Apply sync params if provided by the user configuration via rpc_data
+      if (params.mode?.rpcData != null && userConfig.syncParams != null) {
+        final rpcData = params.mode!.rpcData!;
+        final updatedRpcData = ActivationRpcData(
+          lightWalletDServers: rpcData.lightWalletDServers,
+          electrum: rpcData.electrum,
+          syncParams: userConfig.syncParams,
+        );
+        params = params.copyWith(
+          mode: ActivationMode(rpc: params.mode!.rpc, rpcData: updatedRpcData),
+        );
+      }
 
-      while (!isComplete) {
-        final status = await client.rpc.task.execute(
-          TaskEnableZhtlcStatus(taskId: taskResponse.taskId),
+      yield ZhtlcActivationProgress.validation(protocol);
+
+      // Initialize task and watch via TaskShepherd
+      final stream = client.rpc.zhtlc
+          .enableZhtlcInit(ticker: asset.id.id, params: params)
+          .watch<TaskStatusResponse>(
+            getTaskStatus: (int taskId) => client.rpc.zhtlc.enableZhtlcStatus(
+              taskId,
+              forgetIfFinished: false,
+            ),
+            isTaskComplete: (TaskStatusResponse s) =>
+                s.status == 'Ok' || s.status == 'Error',
+            pollingInterval: effectivePollingInterval,
+            // cancelTask intentionally omitted, as it is not used in this
+            // context and leaving it enabled lead to uncaught exceptions
+            // when taskId was already finished.
+            // TODO(gui-team): investigate why this is the case.
+          );
+
+      var emittedCompletion = false;
+      TaskStatusResponse? lastStatus;
+
+      await for (final status in stream) {
+        lastStatus = status;
+        final detail = progressEstimator.parse(status.details);
+
+        final progress = progressEstimator.estimate(
+          status: status,
+          asset: asset,
+          detail: detail,
         );
 
-        switch (status.details) {
-          case 'BuildingWalletDb':
-            if (!buildingWalletDb) {
-              buildingWalletDb = true;
-              yield const ActivationProgress(
-                status: 'Building wallet database...',
-                progressPercentage: 40,
-                progressDetails: ActivationProgressDetails(
-                  currentStep: 'database',
-                  stepCount: 6,
-                  additionalInfo: {'dbStatus': 'building'},
-                ),
-              );
-            }
-
-          case 'WaitingLightwalletd':
-            yield const ActivationProgress(
-              status: 'Connecting to Lightwalletd server...',
-              progressPercentage: 60,
-              progressDetails: ActivationProgressDetails(
-                currentStep: 'connection',
-                stepCount: 6,
-                additionalInfo: {'connectionStatus': 'connecting'},
-              ),
-            );
-
-          case 'ScanningBlocks':
-            if (!scanningBlocks) {
-              scanningBlocks = true;
-              currentBlock = await _getCurrentBlock();
-            }
-
-            yield ActivationProgress(
-              status: 'Scanning blockchain...',
-              progressPercentage: 80,
-              progressDetails: ActivationProgressDetails(
-                currentStep: 'scanning',
-                stepCount: 6,
-                additionalInfo: {
-                  'currentBlock': currentBlock,
-                  'scanStatus': 'inProgress',
-                },
-              ),
-            );
-
-          case 'Error':
-            yield ActivationProgress(
-              status: 'Activation failed',
-              errorMessage: status.details,
-              isComplete: true,
-              progressDetails: ActivationProgressDetails(
-                currentStep: 'error',
-                stepCount: 6,
-                errorCode: 'ZHTLC_ACTIVATION_ERROR',
-                errorDetails: status.details,
-              ),
-            );
-            isComplete = true;
-
-          case 'Success':
-            yield ActivationProgress.success(
-              details: ActivationProgressDetails(
-                currentStep: 'complete',
-                stepCount: 6,
-                additionalInfo: {
-                  'activatedChain': asset.id.name,
-                  'activationTime': DateTime.now().toIso8601String(),
-                  'finalBlock': currentBlock,
-                },
-              ),
-            );
-            isComplete = true;
-
-          default:
-            yield ActivationProgress(
-              status: status.details,
-              progressDetails: ActivationProgressDetails(
-                currentStep: 'processing',
-                stepCount: 6,
-                additionalInfo: {
-                  'status': status.details,
-                  'lastKnownBlock': currentBlock,
-                },
-              ),
-            );
-        }
+        yield progress;
 
-        if (!isComplete) {
-          await Future<void>.delayed(const Duration(milliseconds: 500));
+        if (progress.isComplete) {
+          emittedCompletion = true;
+          return;
         }
       }
+
+      // If the task ended with an error status but without emitting a specific
+      // error detail case, emit a failure result now.
+      if (!emittedCompletion &&
+          lastStatus != null &&
+          lastStatus.status == 'Error') {
+        final detail = progressEstimator.parse(lastStatus.details);
+        yield progressEstimator.estimate(
+          status: lastStatus,
+          asset: asset,
+          detail: detail,
+        );
+      }
     } catch (e, stack) {
-      yield ActivationProgress(
-        status: 'Activation failed',
-        errorMessage: e.toString(),
-        isComplete: true,
-        progressDetails: ActivationProgressDetails(
-          currentStep: 'error',
-          stepCount: 6,
-          errorCode: 'ZHTLC_ACTIVATION_ERROR',
-          errorDetails: e.toString(),
-          stackTrace: stack.toString(),
-          additionalInfo: {
-            'errorType': e.runtimeType.toString(),
-            'timestamp': DateTime.now().toIso8601String(),
-          },
-        ),
-      );
+      yield ActivationProgressZhtlc.failure(e, stack);
     }
   }
-
-  Future<int> _getCurrentBlock() async {
-    throw UnimplementedError();
-  }
 }
diff --git a/packages/komodo_defi_sdk/lib/src/activation_config/activation_config_service.dart b/packages/komodo_defi_sdk/lib/src/activation_config/activation_config_service.dart
new file mode 100644
index 000000000..978347c56
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/activation_config/activation_config_service.dart
@@ -0,0 +1,323 @@
+import 'dart:async';
+import 'dart:convert';
+
+import 'package:hive_ce/hive.dart';
+import 'package:komodo_defi_rpc_methods/komodo_defi_rpc_methods.dart';
+import 'package:komodo_defi_types/komodo_defi_type_utils.dart';
+import 'package:komodo_defi_types/komodo_defi_types.dart';
+
+typedef JsonMap = Map<String, dynamic>;
+
+/// Simple key-value store abstraction for persisting activation configs.
+abstract class KeyValueStore {
+  Future<JsonMap?> get(String key);
+  Future<void> set(String key, JsonMap value);
+}
+
+/// In-memory key-value store default implementation.
+class InMemoryKeyValueStore implements KeyValueStore {
+  final Map<String, JsonMap> _store = {};
+
+  @override
+  Future<JsonMap?> get(String key) async => _store[key];
+
+  @override
+  Future<void> set(String key, JsonMap value) async {
+    _store[key] = value;
+  }
+}
+
+/// Repository abstraction for typed activation configs.
+abstract class ActivationConfigRepository {
+  Future<TConfig?> getConfig<TConfig>(WalletId walletId, AssetId id);
+  Future<void> saveConfig<TConfig>(
+    WalletId walletId,
+    AssetId id,
+    TConfig config,
+  );
+}
+
+/// Minimal ZHTLC user configuration.
+class ZhtlcUserConfig {
+  ZhtlcUserConfig({
+    required this.zcashParamsPath,
+    this.scanBlocksPerIteration = 1000,
+    this.scanIntervalMs = 0,
+    this.taskStatusPollingIntervalMs,
+    this.syncParams,
+  });
+
+  final String zcashParamsPath;
+  final int scanBlocksPerIteration;
+  final int scanIntervalMs;
+  final int? taskStatusPollingIntervalMs;
+  final ZhtlcSyncParams? syncParams;
+
+  JsonMap toJson() => {
+    'zcashParamsPath': zcashParamsPath,
+    'scanBlocksPerIteration': scanBlocksPerIteration,
+    'scanIntervalMs': scanIntervalMs,
+    if (taskStatusPollingIntervalMs != null)
+      'taskStatusPollingIntervalMs': taskStatusPollingIntervalMs,
+    if (syncParams != null) 'syncParams': syncParams!.toJsonRequest(),
+  };
+
+  static ZhtlcUserConfig fromJson(JsonMap json) => ZhtlcUserConfig(
+    zcashParamsPath: json.value<String>('zcashParamsPath'),
+    scanBlocksPerIteration:
+        json.valueOrNull<int>('scanBlocksPerIteration') ?? 1000,
+    scanIntervalMs: json.valueOrNull<int>('scanIntervalMs') ?? 0,
+    taskStatusPollingIntervalMs: json.valueOrNull<int>(
+      'taskStatusPollingIntervalMs',
+    ),
+    syncParams: ZhtlcSyncParams.tryParse(
+      json.valueOrNull<dynamic>('syncParams'),
+    ),
+  );
+}
+
+/// Simple mapper for typed configs. Extend when adding more protocols.
+abstract class ActivationConfigMapper {
+  static JsonMap encode(Object config) {
+    if (config is ZhtlcUserConfig) return config.toJson();
+    throw UnsupportedError('Unsupported config type: ${config.runtimeType}');
+  }
+
+  static T decode<T>(JsonMap json) {
+    if (T == ZhtlcUserConfig) return ZhtlcUserConfig.fromJson(json) as T;
+    throw UnsupportedError('Unsupported type for decode: $T');
+  }
+}
+
+/// Wrapper class for storing activation configs in Hive.
+/// This replaces the problematic Map<String, String> storage approach
+/// and provides type safety while using the encode/decode functions.
+class HiveActivationConfigWrapper extends HiveObject {
+  /// Creates a wrapper from a wallet ID and a map of asset IDs to configurations
+  /// [walletId] The wallet ID this configuration belongs to
+  /// [configs] The map of asset IDs to configurations
+  HiveActivationConfigWrapper({required this.walletId, required this.configs});
+
+  /// Creates a wrapper from individual config components
+  /// [walletId] The wallet ID this configuration belongs to
+  /// [configs] The map of asset IDs to configurations
+  factory HiveActivationConfigWrapper.fromComponents({
+    required WalletId walletId,
+    required Map<String, Object> configs,
+  }) {
+    final encodedConfigs = <String, String>{};
+    configs.forEach((assetId, config) {
+      final json = ActivationConfigMapper.encode(config);
+      encodedConfigs[assetId] = jsonEncode(json);
+    });
+    return HiveActivationConfigWrapper(
+      walletId: walletId,
+      configs: encodedConfigs,
+    );
+  }
+
+  /// The wallet ID this configuration belongs to
+  @HiveField(0)
+  final WalletId walletId;
+
+  /// Map of asset ID to JSON-encoded configuration strings
+  @HiveField(1)
+  final Map<String, String> configs;
+
+  /// Gets a decoded configuration by asset ID and type
+  TConfig? getConfig<TConfig>(String assetId) {
+    final encodedConfig = configs[assetId];
+    if (encodedConfig == null) return null;
+
+    final json = jsonDecode(encodedConfig) as JsonMap;
+    return ActivationConfigMapper.decode<TConfig>(json);
+  }
+
+  /// Sets a configuration by asset ID
+  HiveActivationConfigWrapper setConfig(String assetId, Object config) {
+    final json = ActivationConfigMapper.encode(config);
+    final newConfigs = Map<String, String>.from(configs);
+    newConfigs[assetId] = jsonEncode(json);
+
+    return HiveActivationConfigWrapper(walletId: walletId, configs: newConfigs);
+  }
+
+  /// Removes a configuration by asset ID
+  HiveActivationConfigWrapper removeConfig(String assetId) {
+    final newConfigs = Map<String, String>.from(configs);
+    newConfigs.remove(assetId);
+
+    return HiveActivationConfigWrapper(walletId: walletId, configs: newConfigs);
+  }
+
+  /// Checks if a configuration exists for the given asset ID
+  bool hasConfig(String assetId) => configs.containsKey(assetId);
+
+  /// Gets all asset IDs that have configurations
+  List<String> getAssetIds() => configs.keys.toList();
+}
+
+class JsonActivationConfigRepository implements ActivationConfigRepository {
+  JsonActivationConfigRepository(this.store);
+  final KeyValueStore store;
+
+  String _key(WalletId walletId, AssetId id) =>
+      'activation_config:${walletId.compoundId}:${id.id}';
+
+  @override
+  Future<TConfig?> getConfig<TConfig>(WalletId walletId, AssetId id) async {
+    final data = await store.get(_key(walletId, id));
+    if (data == null) return null;
+    return ActivationConfigMapper.decode<TConfig>(data);
+  }
+
+  @override
+  Future<void> saveConfig<TConfig>(
+    WalletId walletId,
+    AssetId id,
+    TConfig config,
+  ) async {
+    final json = ActivationConfigMapper.encode(config as Object);
+    await store.set(_key(walletId, id), json);
+  }
+}
+
+typedef WalletIdResolver = Future<WalletId?> Function();
+
+/// Service orchestrating retrieval/request of activation configs.
+class ActivationConfigService {
+  ActivationConfigService(
+    this.repo, {
+    required WalletIdResolver walletIdResolver,
+  }) : _walletIdResolver = walletIdResolver;
+
+  final ActivationConfigRepository repo;
+  final WalletIdResolver _walletIdResolver;
+
+  Future<WalletId> _requireActiveWallet() async {
+    final walletId = await _walletIdResolver();
+    if (walletId == null) {
+      throw StateError('Attempted to access activation config with no wallet');
+    }
+    return walletId;
+  }
+
+  Future<ZhtlcUserConfig?> getSavedZhtlc(AssetId id) async {
+    final walletId = await _requireActiveWallet();
+    return repo.getConfig<ZhtlcUserConfig>(walletId, id);
+  }
+
+  Future<ZhtlcUserConfig?> getZhtlcOrRequest(
+    AssetId id, {
+    Duration timeout = const Duration(seconds: 60),
+  }) async {
+    final walletId = await _requireActiveWallet();
+    final key = _WalletAssetKey(walletId, id);
+
+    final existing = await repo.getConfig<ZhtlcUserConfig>(walletId, id);
+    if (existing != null) return existing;
+
+    final completer = Completer<ZhtlcUserConfig?>();
+    _awaitingControllers[key] = completer;
+    try {
+      final result = await completer.future.timeout(
+        timeout,
+        onTimeout: () => null,
+      );
+      if (result == null) return null;
+      await repo.saveConfig(walletId, id, result);
+      return result;
+    } finally {
+      _awaitingControllers.remove(key);
+    }
+  }
+
+  Future<void> saveZhtlcConfig(AssetId id, ZhtlcUserConfig config) async {
+    final walletId = await _requireActiveWallet();
+    await repo.saveConfig(walletId, id, config);
+  }
+
+  Future<void> submitZhtlc(AssetId id, ZhtlcUserConfig config) async {
+    final walletId = await _walletIdResolver();
+    if (walletId == null) return;
+    _awaitingControllers[_WalletAssetKey(walletId, id)]?.complete(config);
+  }
+
+  final Map<_WalletAssetKey, Completer<ZhtlcUserConfig?>> _awaitingControllers =
+      {};
+}
+
+class _WalletAssetKey {
+  _WalletAssetKey(this.walletId, this.assetId);
+
+  final WalletId walletId;
+  final AssetId assetId;
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+    return other is _WalletAssetKey &&
+        other.walletId == walletId &&
+        other.assetId == assetId;
+  }
+
+  @override
+  int get hashCode => Object.hash(walletId, assetId);
+}
+
+/// UI helper for building configuration forms.
+class ActivationSettingDescriptor {
+  ActivationSettingDescriptor({
+    required this.key,
+    required this.label,
+    required this.type,
+    this.required = false,
+    this.defaultValue,
+    this.helpText,
+  });
+
+  final String key;
+  final String label;
+  final String type; // 'path' | 'number' | 'string' | 'boolean' | 'select'
+  final bool required;
+  final Object? defaultValue;
+  final String? helpText;
+}
+
+extension AssetIdActivationSettings on AssetId {
+  List<ActivationSettingDescriptor> activationSettings() {
+    switch (subClass) {
+      case CoinSubClass.zhtlc:
+        return [
+          ActivationSettingDescriptor(
+            key: 'zcashParamsPath',
+            label: 'Zcash parameters path',
+            type: 'path',
+            required: true,
+            helpText: 'Folder containing Zcash parameters',
+          ),
+          ActivationSettingDescriptor(
+            key: 'scanBlocksPerIteration',
+            label: 'Blocks per scan iteration',
+            type: 'number',
+            defaultValue: 1000,
+          ),
+          ActivationSettingDescriptor(
+            key: 'scanIntervalMs',
+            label: 'Scan interval (ms)',
+            type: 'number',
+            defaultValue: 0,
+          ),
+          ActivationSettingDescriptor(
+            key: 'taskStatusPollingIntervalMs',
+            label: 'Task status polling interval (ms)',
+            type: 'number',
+            defaultValue: 500,
+            helpText: 'Delay between status polls while monitoring activation',
+          ),
+        ];
+      default:
+        return const [];
+    }
+  }
+}
diff --git a/packages/komodo_defi_sdk/lib/src/activation_config/hive_activation_config_repository.dart b/packages/komodo_defi_sdk/lib/src/activation_config/hive_activation_config_repository.dart
new file mode 100644
index 000000000..dddf1fc38
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/activation_config/hive_activation_config_repository.dart
@@ -0,0 +1,86 @@
+import 'dart:convert';
+
+import 'package:hive_ce/hive.dart';
+import 'package:komodo_defi_sdk/src/activation_config/activation_config_service.dart';
+import 'package:komodo_defi_sdk/src/activation_config/hive_adapters.dart';
+import 'package:komodo_defi_types/komodo_defi_types.dart';
+
+const _walletIdAdapterTypeId = 220;
+
+/// Type adapter for persisting [WalletId] keys inside Hive boxes.
+class WalletIdAdapter extends TypeAdapter<WalletId> {
+  @override
+  int get typeId => _walletIdAdapterTypeId;
+
+  @override
+  WalletId read(BinaryReader reader) {
+    final json = jsonDecode(reader.readString()) as Map<String, dynamic>;
+    return WalletId.fromJson(json);
+  }
+
+  @override
+  void write(BinaryWriter writer, WalletId obj) {
+    writer.writeString(jsonEncode(obj.toJson()));
+  }
+}
+
+/// Hive-backed activation configuration repository using wrapper class.
+/// This replaces the problematic Map&lt;String, String&gt; storage approach
+/// and provides type safety while using the encode/decode functions.
+class HiveActivationConfigRepository implements ActivationConfigRepository {
+  /// Creates a new [HiveActivationConfigRepository].
+  /// [hive] is the Hive instance to use.
+  /// [boxName] is the name of the Hive box to use.
+  HiveActivationConfigRepository({
+    HiveInterface? hive,
+    String boxName = 'activation_configs',
+  }) : _hive = hive ?? Hive,
+       _boxName = boxName;
+
+  final HiveInterface _hive;
+  final String _boxName;
+  Box<HiveActivationConfigWrapper>? _box;
+  Future<Box<HiveActivationConfigWrapper>>? _boxOpening;
+
+  Future<Box<HiveActivationConfigWrapper>> _openBox() {
+    if (_box != null) return Future.value(_box!);
+    if (_boxOpening != null) return _boxOpening!;
+    _boxOpening = () async {
+      // Register adapters
+      if (!_hive.isAdapterRegistered(_walletIdAdapterTypeId)) {
+        _hive.registerAdapter(WalletIdAdapter());
+      }
+      registerActivationConfigAdapters();
+
+      final box = await _hive.openBox<HiveActivationConfigWrapper>(_boxName);
+      _box = box;
+      return box;
+    }();
+    return _boxOpening!;
+  }
+
+  @override
+  Future<TConfig?> getConfig<TConfig>(WalletId walletId, AssetId id) async {
+    final box = await _openBox();
+    final wrapper = box.get(walletId.compoundId);
+    if (wrapper == null) return null;
+    return wrapper.getConfig<TConfig>(id.id);
+  }
+
+  @override
+  Future<void> saveConfig<TConfig>(
+    WalletId walletId,
+    AssetId id,
+    TConfig config,
+  ) async {
+    final box = await _openBox();
+    final existing = box.get(walletId.compoundId);
+
+    final updatedWrapper =
+        (existing ??
+                HiveActivationConfigWrapper(walletId: walletId, configs: {}))
+            .setConfig(id.id, config as Object);
+
+    await box.put(walletId.compoundId, updatedWrapper);
+  }
+}
diff --git a/packages/komodo_defi_sdk/lib/src/activation_config/hive_adapters.dart b/packages/komodo_defi_sdk/lib/src/activation_config/hive_adapters.dart
new file mode 100644
index 000000000..7d50229da
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/activation_config/hive_adapters.dart
@@ -0,0 +1,21 @@
+import 'package:hive_ce/hive.dart';
+import 'package:komodo_defi_sdk/src/activation_config/activation_config_service.dart';
+import 'package:komodo_defi_types/komodo_defi_types.dart';
+
+/// Generates Hive adapters for activation config data models
+///
+/// This file uses the new GenerateAdapters annotation approach from Hive CE
+/// to automatically generate type adapters for our data models.
+@GenerateAdapters([AdapterSpec<HiveActivationConfigWrapper>()])
+// The generated file will be created by build_runner
+part 'hive_adapters.g.dart';
+
+/// Registers all Hive adapters for activation config
+///
+/// Call this function before opening any Hive boxes to ensure
+/// all type adapters are properly registered.
+void registerActivationConfigAdapters() {
+  if (!Hive.isAdapterRegistered(20)) {
+    Hive.registerAdapter(HiveActivationConfigWrapperAdapter());
+  }
+}
diff --git a/packages/komodo_defi_sdk/lib/src/activation_config/hive_adapters.g.dart b/packages/komodo_defi_sdk/lib/src/activation_config/hive_adapters.g.dart
new file mode 100644
index 000000000..1c484aaaa
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/activation_config/hive_adapters.g.dart
@@ -0,0 +1,45 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'hive_adapters.dart';
+
+// **************************************************************************
+// AdaptersGenerator
+// **************************************************************************
+
+class HiveActivationConfigWrapperAdapter
+    extends TypeAdapter<HiveActivationConfigWrapper> {
+  @override
+  final typeId = 20;
+
+  @override
+  HiveActivationConfigWrapper read(BinaryReader reader) {
+    final numOfFields = reader.readByte();
+    final fields = <int, dynamic>{
+      for (int i = 0; i < numOfFields; i++) reader.readByte(): reader.read(),
+    };
+    return HiveActivationConfigWrapper(
+      walletId: fields[0] as WalletId,
+      configs: (fields[1] as Map).cast<String, String>(),
+    );
+  }
+
+  @override
+  void write(BinaryWriter writer, HiveActivationConfigWrapper obj) {
+    writer
+      ..writeByte(2)
+      ..writeByte(0)
+      ..write(obj.walletId)
+      ..writeByte(1)
+      ..write(obj.configs);
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is HiveActivationConfigWrapperAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}
diff --git a/packages/komodo_defi_sdk/lib/src/activation_config/hive_adapters.g.yaml b/packages/komodo_defi_sdk/lib/src/activation_config/hive_adapters.g.yaml
new file mode 100644
index 000000000..674d7449a
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/activation_config/hive_adapters.g.yaml
@@ -0,0 +1,13 @@
+# Generated by Hive CE
+# Manual modifications may be necessary for certain migrations
+# Check in to version control
+nextTypeId: 21
+types:
+  HiveActivationConfigWrapper:
+    typeId: 20
+    nextIndex: 2
+    fields:
+      walletId:
+        index: 0
+      configs:
+        index: 1
diff --git a/packages/komodo_defi_sdk/lib/src/activation_config/hive_registrar.g.dart b/packages/komodo_defi_sdk/lib/src/activation_config/hive_registrar.g.dart
new file mode 100644
index 000000000..d71c8a96e
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/activation_config/hive_registrar.g.dart
@@ -0,0 +1,18 @@
+// Generated by Hive CE
+// Do not modify
+// Check in to version control
+
+import 'package:hive_ce/hive.dart';
+import 'package:komodo_defi_sdk/src/activation_config/hive_adapters.dart';
+
+extension HiveRegistrar on HiveInterface {
+  void registerAdapters() {
+    registerAdapter(HiveActivationConfigWrapperAdapter());
+  }
+}
+
+extension IsolatedHiveRegistrar on IsolatedHiveInterface {
+  void registerAdapters() {
+    registerAdapter(HiveActivationConfigWrapperAdapter());
+  }
+}
diff --git a/packages/komodo_defi_sdk/lib/src/bootstrap.dart b/packages/komodo_defi_sdk/lib/src/bootstrap.dart
index 5a449c025..617aa9170 100644
--- a/packages/komodo_defi_sdk/lib/src/bootstrap.dart
+++ b/packages/komodo_defi_sdk/lib/src/bootstrap.dart
@@ -1,23 +1,36 @@
 // ignore_for_file: cascade_invocations
 
-import 'package:flutter/foundation.dart';
+import 'dart:developer';
+
 import 'package:get_it/get_it.dart';
+import 'package:hive_ce_flutter/hive_flutter.dart';
 import 'package:komodo_cex_market_data/komodo_cex_market_data.dart';
 import 'package:komodo_coins/komodo_coins.dart';
 import 'package:komodo_defi_framework/komodo_defi_framework.dart';
 import 'package:komodo_defi_local_auth/komodo_defi_local_auth.dart';
 import 'package:komodo_defi_sdk/komodo_defi_sdk.dart';
 import 'package:komodo_defi_sdk/src/_internal_exports.dart';
+import 'package:komodo_defi_sdk/src/activation_config/hive_adapters.dart';
 import 'package:komodo_defi_sdk/src/fees/fee_manager.dart';
 import 'package:komodo_defi_sdk/src/market_data/market_data_manager.dart'
     show CexMarketDataManager, MarketDataManager;
 import 'package:komodo_defi_sdk/src/message_signing/message_signing_manager.dart';
 import 'package:komodo_defi_sdk/src/pubkeys/pubkey_manager.dart';
 import 'package:komodo_defi_sdk/src/storage/secure_rpc_password_mixin.dart';
+import 'package:komodo_defi_sdk/src/withdrawals/legacy_withdrawal_manager.dart';
 import 'package:komodo_defi_sdk/src/withdrawals/withdrawal_manager.dart';
 import 'package:komodo_defi_types/komodo_defi_type_utils.dart';
 import 'package:komodo_defi_types/komodo_defi_types.dart';
 
+var _activationConfigHiveInitialized = false;
+
+Future<void> _ensureActivationConfigHiveInitialized() async {
+  if (_activationConfigHiveInitialized) return;
+  await Hive.initFlutter();
+  registerActivationConfigAdapters();
+  _activationConfigHiveInitialized = true;
+}
+
 /// Bootstrap the SDK's dependencies
 Future<void> bootstrap({
   required IKdfHostConfig? hostConfig,
@@ -26,6 +39,9 @@ Future<void> bootstrap({
   KomodoDefiFramework? kdfFramework,
   void Function(String)? externalLogger,
 }) async {
+  log('Bootstrap: Starting dependency injection setup...', name: 'Bootstrap');
+  final stopwatch = Stopwatch()..start();
+
   final rpcPassword = await SecureRpcPasswordMixin().ensureRpcPassword();
 
   // Framework and core dependencies
@@ -37,7 +53,7 @@ Future<void> bootstrap({
 
     return KomodoDefiFramework.create(
       hostConfig: resolvedHostConfig,
-      externalLogger: externalLogger ?? (kDebugMode ? print : null),
+      externalLogger: externalLogger,
     );
   });
 
@@ -64,6 +80,17 @@ Future<void> bootstrap({
     () async => KomodoAssetsUpdateManager(),
   );
 
+  // Activation configuration service (must be available before ActivationManager)
+  container.registerSingletonAsync<ActivationConfigService>(() async {
+    await _ensureActivationConfigHiveInitialized();
+    final auth = await container.getAsync<KomodoDefiLocalAuth>();
+    final repo = HiveActivationConfigRepository();
+    return ActivationConfigService(
+      repo,
+      walletIdResolver: () async => (await auth.currentUser)?.walletId,
+    );
+  }, dependsOn: [KomodoDefiLocalAuth]);
+
   // Register asset manager first since it's a core dependency
   container.registerSingletonAsync<AssetManager>(() async {
     final client = await container.getAsync<ApiClient>();
@@ -103,6 +130,7 @@ Future<void> bootstrap({
       final auth = await container.getAsync<KomodoDefiLocalAuth>();
       final assetManager = await container.getAsync<AssetManager>();
       final balanceManager = await container.getAsync<BalanceManager>();
+      final configService = await container.getAsync<ActivationConfigService>();
 
       final activationManager = ActivationManager(
         client,
@@ -110,6 +138,7 @@ Future<void> bootstrap({
         container<AssetHistoryStorage>(),
         assetManager,
         balanceManager,
+        configService,
         // Needed here to add custom tokens to the same instance
         // as the asset manager
         container<KomodoAssetsUpdateManager>(),
@@ -122,6 +151,7 @@ Future<void> bootstrap({
       KomodoDefiLocalAuth,
       AssetManager,
       BalanceManager,
+      ActivationConfigService,
       KomodoAssetsUpdateManager,
     ],
   );
@@ -199,6 +229,11 @@ Future<void> bootstrap({
     return FeeManager(client);
   }, dependsOn: [ApiClient]);
 
+  container.registerSingletonAsync<LegacyWithdrawalManager>(() async {
+    final client = await container.getAsync<ApiClient>();
+    return LegacyWithdrawalManager(client);
+  }, dependsOn: [ApiClient]);
+
   container.registerSingletonAsync<TransactionHistoryManager>(
     () async {
       final client = await container.getAsync<ApiClient>();
@@ -229,6 +264,7 @@ Future<void> bootstrap({
       final client = await container.getAsync<ApiClient>();
       final assetProvider = await container.getAsync<AssetManager>();
       final feeManager = await container.getAsync<FeeManager>();
+      final legacyManager = await container.getAsync<LegacyWithdrawalManager>();
 
       final activationCoordinator = await container
           .getAsync<SharedActivationCoordinator>();
@@ -237,6 +273,7 @@ Future<void> bootstrap({
         assetProvider,
         feeManager,
         activationCoordinator,
+        legacyManager,
       );
     },
     dependsOn: [
@@ -244,6 +281,7 @@ Future<void> bootstrap({
       AssetManager,
       SharedActivationCoordinator,
       FeeManager,
+      LegacyWithdrawalManager,
     ],
   );
 
@@ -271,4 +309,10 @@ Future<void> bootstrap({
 
   // Wait for all async singletons to initialize
   await container.allReady();
+
+  stopwatch.stop();
+  log(
+    'Bootstrap: Dependency injection setup completed in ${stopwatch.elapsedMilliseconds}ms',
+    name: 'Bootstrap',
+  );
 }
diff --git a/packages/komodo_defi_sdk/lib/src/komodo_defi_sdk.dart b/packages/komodo_defi_sdk/lib/src/komodo_defi_sdk.dart
index 864d2a5fa..db9798207 100644
--- a/packages/komodo_defi_sdk/lib/src/komodo_defi_sdk.dart
+++ b/packages/komodo_defi_sdk/lib/src/komodo_defi_sdk.dart
@@ -15,6 +15,7 @@ import 'package:komodo_defi_sdk/src/storage/secure_rpc_password_mixin.dart';
 import 'package:komodo_defi_sdk/src/withdrawals/withdrawal_manager.dart';
 import 'package:komodo_defi_types/komodo_defi_type_utils.dart';
 import 'package:komodo_defi_types/komodo_defi_types.dart';
+import 'package:komodo_defi_sdk/src/activation_config/activation_config_service.dart';
 
 /// A high-level SDK that provides a simple way to build cross-platform applications
 /// using the Komodo DeFi Framework, with a primary focus on wallet functionality.
@@ -151,12 +152,7 @@ class KomodoDefiSdk with SecureRpcPasswordMixin {
     this._config,
     this._kdfFramework,
     this._onLog,
-  ) {
-    _container = GetIt.asNewInstance();
-    if (_kdfFramework != null && _onLog != null) {
-      _logSubscription = _kdfFramework!.logStream.listen(_onLog!);
-    }
-  }
+  ) : _container = GetIt.asNewInstance();
 
   final IKdfHostConfig? _hostConfig;
   final KomodoDefiSdkConfig _config;
@@ -166,7 +162,6 @@ class KomodoDefiSdk with SecureRpcPasswordMixin {
   bool _isDisposed = false;
   Future<void>? _initializationFuture;
   final void Function(String)? _onLog;
-  StreamSubscription<String>? _logSubscription;
 
   /// The API client for making direct RPC calls.
   ///
@@ -200,6 +195,10 @@ class KomodoDefiSdk with SecureRpcPasswordMixin {
   AddressOperations get addresses =>
       _assertSdkInitialized(_container<AddressOperations>());
 
+  /// Service for resolving/persisting activation configuration.
+  ActivationConfigService get activationConfigService =>
+      _assertSdkInitialized(_container<ActivationConfigService>());
+
   /// The asset manager instance.
   ///
   /// Handles coin/token activation and configuration.
@@ -288,9 +287,8 @@ class KomodoDefiSdk with SecureRpcPasswordMixin {
   ///
   /// Subscribe to receive human-readable log messages from the underlying
   /// Komodo DeFi Framework. Requires the SDK to be initialized.
-  Stream<String> get logStream => _assertSdkInitialized(
-        _container<KomodoDefiFramework>().logStream,
-      );
+  Stream<String> get logStream =>
+      _assertSdkInitialized(_container<KomodoDefiFramework>().logStream);
 
   /// Initializes the SDK instance.
   ///
@@ -330,20 +328,26 @@ class KomodoDefiSdk with SecureRpcPasswordMixin {
 
   Future<void> _initialize() async {
     _assertNotDisposed();
+
+    log('KomodoDefiSdk: Starting initialization...', name: 'KomodoDefiSdk');
+    final stopwatch = Stopwatch()..start();
+
     await bootstrap(
       hostConfig: _hostConfig,
       config: _config,
       kdfFramework: _kdfFramework,
       container: _container,
-      // Let SDK manage onLog subscription itself to avoid duplication
-      externalLogger: null,
+      // Pass onLog callback to bootstrap for direct framework integration
+      externalLogger: _onLog,
     );
-    // Ensure consistent onLog subscription when framework is created by SDK
-    if (_onLog != null && _logSubscription == null) {
-      final framework = _container<KomodoDefiFramework>();
-      _logSubscription = framework.logStream.listen(_onLog!);
-    }
+
     _isInitialized = true;
+
+    stopwatch.stop();
+    log(
+      'KomodoDefiSdk: Initialization completed in ${stopwatch.elapsedMilliseconds}ms',
+      name: 'KomodoDefiSdk',
+    );
   }
 
   /// Gets the current user's authentication options.
@@ -395,17 +399,11 @@ class KomodoDefiSdk with SecureRpcPasswordMixin {
     if (_isDisposed) return;
     _isDisposed = true;
 
-    // Always cancel log subscription even if SDK wasn't initialized
-    await _logSubscription?.cancel();
-    _logSubscription = null;
-
     if (!_isInitialized) return;
 
     _isInitialized = false;
     _initializationFuture = null;
 
-    // (Already cancelled above)
-
     await Future.wait([
       _disposeIfRegistered<KomodoDefiLocalAuth>((m) => m.dispose()),
       _disposeIfRegistered<AssetManager>((m) => m.dispose()),
diff --git a/packages/komodo_defi_sdk/lib/src/transaction_history/strategies/etherscan_transaction_history_strategy.dart b/packages/komodo_defi_sdk/lib/src/transaction_history/strategies/etherscan_transaction_history_strategy.dart
index cf407af9e..7ac610059 100644
--- a/packages/komodo_defi_sdk/lib/src/transaction_history/strategies/etherscan_transaction_history_strategy.dart
+++ b/packages/komodo_defi_sdk/lib/src/transaction_history/strategies/etherscan_transaction_history_strategy.dart
@@ -110,6 +110,11 @@ class EtherscanTransactionStrategy extends TransactionHistoryStrategy {
         total: allTransactions.length,
         totalPages: (allTransactions.length / paginatedResults.pageSize).ceil(),
         pageNumber: pagination is PagePagination ? pagination.pageNumber : null,
+        pagingOptions: switch (pagination) {
+          final PagePagination p => Pagination(pageNumber: p.pageNumber),
+          final TransactionBasedPagination t => Pagination(fromId: t.fromId),
+          _ => null,
+        },
         transactions: paginatedResults.transactions,
       );
     } catch (e) {
diff --git a/packages/komodo_defi_sdk/lib/src/transaction_history/strategies/zhtlc_transaction_strategy.dart b/packages/komodo_defi_sdk/lib/src/transaction_history/strategies/zhtlc_transaction_strategy.dart
index 1347210d6..6e3490ef6 100644
--- a/packages/komodo_defi_sdk/lib/src/transaction_history/strategies/zhtlc_transaction_strategy.dart
+++ b/packages/komodo_defi_sdk/lib/src/transaction_history/strategies/zhtlc_transaction_strategy.dart
@@ -6,8 +6,9 @@ class ZhtlcTransactionStrategy extends TransactionHistoryStrategy {
 
   @override
   Set<Type> get supportedPaginationModes => {
-        PagePagination,
-      };
+    PagePagination,
+    TransactionBasedPagination,
+  };
 
   @override
   Future<MyTxHistoryResponse> fetchTransactionHistory(
@@ -17,18 +18,25 @@ class ZhtlcTransactionStrategy extends TransactionHistoryStrategy {
   ) async {
     validatePagination(pagination);
 
-    if (pagination is! PagePagination) {
-      throw UnsupportedError(
-        'ZHTLC only supports page-based pagination',
-      );
-    }
+    final ({int limit, Pagination pagingOptions}) requestParams =
+        switch (pagination) {
+          final PagePagination p => (
+            limit: p.itemsPerPage,
+            pagingOptions: Pagination(pageNumber: p.pageNumber),
+          ),
+          final TransactionBasedPagination t => (
+            limit: t.itemCount,
+            pagingOptions: Pagination(fromId: t.fromId),
+          ),
+          _ => throw UnsupportedError(
+            'Pagination mode ${pagination.runtimeType} not supported',
+          ),
+        };
 
     return client.rpc.transactionHistory.zCoinTxHistory(
       coin: asset.id.id,
-      limit: pagination.itemsPerPage,
-      pagingOptions: Pagination(
-        pageNumber: pagination.pageNumber,
-      ),
+      limit: requestParams.limit,
+      pagingOptions: requestParams.pagingOptions,
     );
   }
 
diff --git a/packages/komodo_defi_sdk/lib/src/transaction_history/transaction_history_strategies.dart b/packages/komodo_defi_sdk/lib/src/transaction_history/transaction_history_strategies.dart
index c29f6e917..aefe6318c 100644
--- a/packages/komodo_defi_sdk/lib/src/transaction_history/transaction_history_strategies.dart
+++ b/packages/komodo_defi_sdk/lib/src/transaction_history/transaction_history_strategies.dart
@@ -8,22 +8,24 @@ import 'package:komodo_defi_types/komodo_defi_types.dart';
 class TransactionHistoryStrategyFactory {
   TransactionHistoryStrategyFactory(
     PubkeyManager pubkeyManager,
-    KomodoDefiLocalAuth auth,
-  ) : _strategies = [
-          EtherscanTransactionStrategy(pubkeyManager: pubkeyManager),
-          V2TransactionStrategy(auth),
-          const LegacyTransactionStrategy(),
-          const ZhtlcTransactionStrategy(),
-        ];
+    KomodoDefiLocalAuth auth, {
+    List<TransactionHistoryStrategy>? strategies,
+  }) : _strategies =
+           strategies ??
+           [
+             EtherscanTransactionStrategy(pubkeyManager: pubkeyManager),
+             V2TransactionStrategy(auth),
+             const LegacyTransactionStrategy(),
+             const ZhtlcTransactionStrategy(),
+           ];
 
   final List<TransactionHistoryStrategy> _strategies;
 
   TransactionHistoryStrategy forAsset(Asset asset) {
     final strategy = _strategies.firstWhere(
       (strategy) => strategy.supportsAsset(asset),
-      orElse: () => throw UnsupportedError(
-        'No strategy found for asset ${asset.id.id}',
-      ),
+      orElse: () =>
+          throw UnsupportedError('No strategy found for asset ${asset.id.id}'),
     );
 
     return strategy;
@@ -38,9 +40,9 @@ class V2TransactionStrategy extends TransactionHistoryStrategy {
 
   @override
   Set<Type> get supportedPaginationModes => {
-        PagePagination,
-        TransactionBasedPagination,
-      };
+    PagePagination,
+    TransactionBasedPagination,
+  };
 
   // TODO: Consider for the future how multi-account support will be handled.
   // The HistoryTarget could be added to the abstract strategy, but only if
@@ -58,13 +60,13 @@ class V2TransactionStrategy extends TransactionHistoryStrategy {
 
     return switch (pagination) {
       final PagePagination p => client.rpc.transactionHistory.myTxHistory(
-          coin: asset.id.id,
-          limit: p.itemsPerPage,
-          pagingOptions: Pagination(pageNumber: p.pageNumber),
-          target: isHdWallet
-              ? const HdHistoryTarget.accountId(0)
-              : IguanaHistoryTarget(),
-        ),
+        coin: asset.id.id,
+        limit: p.itemsPerPage,
+        pagingOptions: Pagination(pageNumber: p.pageNumber),
+        target: isHdWallet
+            ? const HdHistoryTarget.accountId(0)
+            : IguanaHistoryTarget(),
+      ),
       final TransactionBasedPagination t =>
         client.rpc.transactionHistory.myTxHistory(
           coin: asset.id.id,
@@ -75,8 +77,8 @@ class V2TransactionStrategy extends TransactionHistoryStrategy {
               : IguanaHistoryTarget(),
         ),
       _ => throw UnsupportedError(
-          'Pagination mode ${pagination.runtimeType} not supported',
-        ),
+        'Pagination mode ${pagination.runtimeType} not supported',
+      ),
     };
   }
 
@@ -97,9 +99,9 @@ class LegacyTransactionStrategy extends TransactionHistoryStrategy {
 
   @override
   Set<Type> get supportedPaginationModes => {
-        PagePagination,
-        TransactionBasedPagination,
-      };
+    PagePagination,
+    TransactionBasedPagination,
+  };
 
   @override
   Future<MyTxHistoryResponse> fetchTransactionHistory(
@@ -111,10 +113,10 @@ class LegacyTransactionStrategy extends TransactionHistoryStrategy {
 
     return switch (pagination) {
       final PagePagination p => client.rpc.transactionHistory.myTxHistoryLegacy(
-          coin: asset.id.id,
-          limit: p.itemsPerPage,
-          pageNumber: p.pageNumber,
-        ),
+        coin: asset.id.id,
+        limit: p.itemsPerPage,
+        pageNumber: p.pageNumber,
+      ),
       final TransactionBasedPagination t =>
         client.rpc.transactionHistory.myTxHistoryLegacy(
           coin: asset.id.id,
@@ -122,8 +124,8 @@ class LegacyTransactionStrategy extends TransactionHistoryStrategy {
           fromId: t.fromId,
         ),
       _ => throw UnsupportedError(
-          'Pagination mode ${pagination.runtimeType} not supported',
-        ),
+        'Pagination mode ${pagination.runtimeType} not supported',
+      ),
     };
   }
 
diff --git a/packages/komodo_defi_sdk/lib/src/withdrawals/withdrawal_manager.dart b/packages/komodo_defi_sdk/lib/src/withdrawals/withdrawal_manager.dart
index 579cd7553..5e48265b9 100644
--- a/packages/komodo_defi_sdk/lib/src/withdrawals/withdrawal_manager.dart
+++ b/packages/komodo_defi_sdk/lib/src/withdrawals/withdrawal_manager.dart
@@ -80,6 +80,7 @@ class WithdrawalManager {
     this._assetProvider,
     this._feeManager,
     this._activationCoordinator,
+    this._legacyManager,
   );
 
   /// Flag to enable/disable fee estimation features.
@@ -99,6 +100,7 @@ class WithdrawalManager {
   final IAssetProvider _assetProvider;
   final SharedActivationCoordinator _activationCoordinator;
   final FeeManager _feeManager;
+  final LegacyWithdrawalManager _legacyManager;
   final _activeWithdrawals = <int, StreamController<WithdrawalProgress>>{};
 
   /// Cancels an active withdrawal task.
@@ -485,29 +487,27 @@ class WithdrawalManager {
     WithdrawParameters parameters,
   ) async {
     try {
-      final asset =
-          _assetProvider.findAssetsByConfigId(parameters.asset).single;
+      final asset = _assetProvider
+          .findAssetsByConfigId(parameters.asset)
+          .single;
       final isTendermintProtocol = asset.protocol is TendermintProtocol;
 
       // Tendermint assets are not yet supported by the task-based API
       // and require a legacy implementation
       if (isTendermintProtocol) {
-        final legacyManager = LegacyWithdrawalManager(_client);
-        return await legacyManager.previewWithdrawal(parameters);
+        return await _legacyManager.previewWithdrawal(parameters);
       }
 
       final paramsWithFee = await _ensureFee(parameters, asset);
 
       // Use task-based approach for non-Tendermint assets
-      final stream = (await _client.rpc.withdraw.init(
-        paramsWithFee,
-      )).watch<WithdrawStatusResponse>(
-        getTaskStatus:
-            (int taskId) =>
+      final stream = (await _client.rpc.withdraw.init(paramsWithFee))
+          .watch<WithdrawStatusResponse>(
+            getTaskStatus: (int taskId) =>
                 _client.rpc.withdraw.status(taskId, forgetIfFinished: false),
-        isTaskComplete:
-            (WithdrawStatusResponse status) => status.status != 'InProgress',
-      );
+            isTaskComplete: (WithdrawStatusResponse status) =>
+                status.status != 'InProgress',
+          );
 
       final lastStatus = await stream.last;
 
@@ -610,15 +610,15 @@ class WithdrawalManager {
   Stream<WithdrawalProgress> withdraw(WithdrawParameters parameters) async* {
     int? taskId;
     try {
-      final asset =
-          _assetProvider.findAssetsByConfigId(parameters.asset).single;
+      final asset = _assetProvider
+          .findAssetsByConfigId(parameters.asset)
+          .single;
       final isTendermintProtocol = asset.protocol is TendermintProtocol;
 
       // Tendermint assets are not yet supported by the task-based API
       // and require a legacy implementation
       if (isTendermintProtocol) {
-        final legacyManager = LegacyWithdrawalManager(_client);
-        yield* legacyManager.withdraw(parameters);
+        yield* _legacyManager.withdraw(parameters);
         return;
       }
 
@@ -641,14 +641,12 @@ class WithdrawalManager {
       WithdrawStatusResponse? lastProgress;
 
       await for (final status in initResponse.watch<WithdrawStatusResponse>(
-        getTaskStatus:
-            (int taskId) async =>
-                lastProgress = await _client.rpc.withdraw.status(
-                  taskId,
-                  forgetIfFinished: false,
-                ),
-        isTaskComplete:
-            (WithdrawStatusResponse status) => status.status != 'InProgress',
+        getTaskStatus: (int taskId) async => lastProgress = await _client
+            .rpc
+            .withdraw
+            .status(taskId, forgetIfFinished: false),
+        isTaskComplete: (WithdrawStatusResponse status) =>
+            status.status != 'InProgress',
       )) {
         if (status.status == 'Error') {
           yield* Stream.error(
diff --git a/packages/komodo_defi_sdk/lib/src/zcash_params/_zcash_params_index.dart b/packages/komodo_defi_sdk/lib/src/zcash_params/_zcash_params_index.dart
new file mode 100644
index 000000000..b194c50e3
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/zcash_params/_zcash_params_index.dart
@@ -0,0 +1,15 @@
+// (Internal/private) Generated by the `index_generator` package with the `index_generator.yaml` configuration file.
+
+/// Internal/private classes related to ZCash parameters download functionality.
+library _zcash_params;
+
+export 'models/download_progress.dart';
+export 'models/download_result.dart';
+export 'models/zcash_params_config.dart';
+export 'platforms/mobile_zcash_params_downloader.dart';
+export 'platforms/unix_zcash_params_downloader.dart';
+export 'platforms/web_zcash_params_downloader.dart';
+export 'platforms/windows_zcash_params_downloader.dart';
+export 'services/zcash_params_download_service.dart';
+export 'zcash_params_downloader.dart';
+export 'zcash_params_downloader_factory.dart';
diff --git a/packages/komodo_defi_sdk/lib/src/zcash_params/models/download_progress.dart b/packages/komodo_defi_sdk/lib/src/zcash_params/models/download_progress.dart
new file mode 100644
index 000000000..662e2ce93
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/zcash_params/models/download_progress.dart
@@ -0,0 +1,42 @@
+import 'package:freezed_annotation/freezed_annotation.dart';
+
+part 'download_progress.freezed.dart';
+part 'download_progress.g.dart';
+
+/// Represents the progress of a ZCash parameter file download.
+@freezed
+abstract class DownloadProgress with _$DownloadProgress {
+  /// Creates a DownloadProgress instance.
+  const factory DownloadProgress({
+    /// The name of the file being downloaded.
+    required String fileName,
+
+    /// The number of bytes downloaded so far.
+    required int downloaded,
+
+    /// The total number of bytes to download.
+    required int total,
+  }) = _DownloadProgress;
+
+  const DownloadProgress._();
+
+  /// Creates a DownloadProgress instance from JSON.
+  factory DownloadProgress.fromJson(Map<String, dynamic> json) =>
+      _$DownloadProgressFromJson(json);
+
+  /// The download progress as a percentage (0.0 to 100.0).
+  double get percentage {
+    if (total <= 0) return 0;
+    return (downloaded / total) * 100;
+  }
+
+  /// Whether the download is complete.
+  bool get isComplete => downloaded >= total;
+
+  /// Human-readable representation of the download progress.
+  String get displayText {
+    final downloadedMB = (downloaded / (1024 * 1024)).toStringAsFixed(1);
+    final totalMB = (total / (1024 * 1024)).toStringAsFixed(1);
+    return '$fileName: ${percentage.toStringAsFixed(1)}% ($downloadedMB/$totalMB MB)';
+  }
+}
diff --git a/packages/komodo_defi_sdk/lib/src/zcash_params/models/download_progress.freezed.dart b/packages/komodo_defi_sdk/lib/src/zcash_params/models/download_progress.freezed.dart
new file mode 100644
index 000000000..0b1c201bc
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/zcash_params/models/download_progress.freezed.dart
@@ -0,0 +1,289 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+// coverage:ignore-file
+// ignore_for_file: type=lint
+// ignore_for_file: unused_element, deprecated_member_use, deprecated_member_use_from_same_package, use_function_type_syntax_for_parameters, unnecessary_const, avoid_init_to_null, invalid_override_different_default_values_named, prefer_expression_function_bodies, annotate_overrides, invalid_annotation_target, unnecessary_question_mark
+
+part of 'download_progress.dart';
+
+// **************************************************************************
+// FreezedGenerator
+// **************************************************************************
+
+// dart format off
+T _$identity<T>(T value) => value;
+
+/// @nodoc
+mixin _$DownloadProgress {
+
+/// The name of the file being downloaded.
+ String get fileName;/// The number of bytes downloaded so far.
+ int get downloaded;/// The total number of bytes to download.
+ int get total;
+/// Create a copy of DownloadProgress
+/// with the given fields replaced by the non-null parameter values.
+@JsonKey(includeFromJson: false, includeToJson: false)
+@pragma('vm:prefer-inline')
+$DownloadProgressCopyWith<DownloadProgress> get copyWith => _$DownloadProgressCopyWithImpl<DownloadProgress>(this as DownloadProgress, _$identity);
+
+  /// Serializes this DownloadProgress to a JSON map.
+  Map<String, dynamic> toJson();
+
+
+@override
+bool operator ==(Object other) {
+  return identical(this, other) || (other.runtimeType == runtimeType&&other is DownloadProgress&&(identical(other.fileName, fileName) || other.fileName == fileName)&&(identical(other.downloaded, downloaded) || other.downloaded == downloaded)&&(identical(other.total, total) || other.total == total));
+}
+
+@JsonKey(includeFromJson: false, includeToJson: false)
+@override
+int get hashCode => Object.hash(runtimeType,fileName,downloaded,total);
+
+@override
+String toString() {
+  return 'DownloadProgress(fileName: $fileName, downloaded: $downloaded, total: $total)';
+}
+
+
+}
+
+/// @nodoc
+abstract mixin class $DownloadProgressCopyWith<$Res>  {
+  factory $DownloadProgressCopyWith(DownloadProgress value, $Res Function(DownloadProgress) _then) = _$DownloadProgressCopyWithImpl;
+@useResult
+$Res call({
+ String fileName, int downloaded, int total
+});
+
+
+
+
+}
+/// @nodoc
+class _$DownloadProgressCopyWithImpl<$Res>
+    implements $DownloadProgressCopyWith<$Res> {
+  _$DownloadProgressCopyWithImpl(this._self, this._then);
+
+  final DownloadProgress _self;
+  final $Res Function(DownloadProgress) _then;
+
+/// Create a copy of DownloadProgress
+/// with the given fields replaced by the non-null parameter values.
+@pragma('vm:prefer-inline') @override $Res call({Object? fileName = null,Object? downloaded = null,Object? total = null,}) {
+  return _then(_self.copyWith(
+fileName: null == fileName ? _self.fileName : fileName // ignore: cast_nullable_to_non_nullable
+as String,downloaded: null == downloaded ? _self.downloaded : downloaded // ignore: cast_nullable_to_non_nullable
+as int,total: null == total ? _self.total : total // ignore: cast_nullable_to_non_nullable
+as int,
+  ));
+}
+
+}
+
+
+/// Adds pattern-matching-related methods to [DownloadProgress].
+extension DownloadProgressPatterns on DownloadProgress {
+/// A variant of `map` that fallback to returning `orElse`.
+///
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case final Subclass value:
+///     return ...;
+///   case _:
+///     return orElse();
+/// }
+/// ```
+
+@optionalTypeArgs TResult maybeMap<TResult extends Object?>(TResult Function( _DownloadProgress value)?  $default,{required TResult orElse(),}){
+final _that = this;
+switch (_that) {
+case _DownloadProgress() when $default != null:
+return $default(_that);case _:
+  return orElse();
+
+}
+}
+/// A `switch`-like method, using callbacks.
+///
+/// Callbacks receives the raw object, upcasted.
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case final Subclass value:
+///     return ...;
+///   case final Subclass2 value:
+///     return ...;
+/// }
+/// ```
+
+@optionalTypeArgs TResult map<TResult extends Object?>(TResult Function( _DownloadProgress value)  $default,){
+final _that = this;
+switch (_that) {
+case _DownloadProgress():
+return $default(_that);case _:
+  throw StateError('Unexpected subclass');
+
+}
+}
+/// A variant of `map` that fallback to returning `null`.
+///
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case final Subclass value:
+///     return ...;
+///   case _:
+///     return null;
+/// }
+/// ```
+
+@optionalTypeArgs TResult? mapOrNull<TResult extends Object?>(TResult? Function( _DownloadProgress value)?  $default,){
+final _that = this;
+switch (_that) {
+case _DownloadProgress() when $default != null:
+return $default(_that);case _:
+  return null;
+
+}
+}
+/// A variant of `when` that fallback to an `orElse` callback.
+///
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case Subclass(:final field):
+///     return ...;
+///   case _:
+///     return orElse();
+/// }
+/// ```
+
+@optionalTypeArgs TResult maybeWhen<TResult extends Object?>(TResult Function( String fileName,  int downloaded,  int total)?  $default,{required TResult orElse(),}) {final _that = this;
+switch (_that) {
+case _DownloadProgress() when $default != null:
+return $default(_that.fileName,_that.downloaded,_that.total);case _:
+  return orElse();
+
+}
+}
+/// A `switch`-like method, using callbacks.
+///
+/// As opposed to `map`, this offers destructuring.
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case Subclass(:final field):
+///     return ...;
+///   case Subclass2(:final field2):
+///     return ...;
+/// }
+/// ```
+
+@optionalTypeArgs TResult when<TResult extends Object?>(TResult Function( String fileName,  int downloaded,  int total)  $default,) {final _that = this;
+switch (_that) {
+case _DownloadProgress():
+return $default(_that.fileName,_that.downloaded,_that.total);case _:
+  throw StateError('Unexpected subclass');
+
+}
+}
+/// A variant of `when` that fallback to returning `null`
+///
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case Subclass(:final field):
+///     return ...;
+///   case _:
+///     return null;
+/// }
+/// ```
+
+@optionalTypeArgs TResult? whenOrNull<TResult extends Object?>(TResult? Function( String fileName,  int downloaded,  int total)?  $default,) {final _that = this;
+switch (_that) {
+case _DownloadProgress() when $default != null:
+return $default(_that.fileName,_that.downloaded,_that.total);case _:
+  return null;
+
+}
+}
+
+}
+
+/// @nodoc
+@JsonSerializable()
+
+class _DownloadProgress extends DownloadProgress {
+  const _DownloadProgress({required this.fileName, required this.downloaded, required this.total}): super._();
+  factory _DownloadProgress.fromJson(Map<String, dynamic> json) => _$DownloadProgressFromJson(json);
+
+/// The name of the file being downloaded.
+@override final  String fileName;
+/// The number of bytes downloaded so far.
+@override final  int downloaded;
+/// The total number of bytes to download.
+@override final  int total;
+
+/// Create a copy of DownloadProgress
+/// with the given fields replaced by the non-null parameter values.
+@override @JsonKey(includeFromJson: false, includeToJson: false)
+@pragma('vm:prefer-inline')
+_$DownloadProgressCopyWith<_DownloadProgress> get copyWith => __$DownloadProgressCopyWithImpl<_DownloadProgress>(this, _$identity);
+
+@override
+Map<String, dynamic> toJson() {
+  return _$DownloadProgressToJson(this, );
+}
+
+@override
+bool operator ==(Object other) {
+  return identical(this, other) || (other.runtimeType == runtimeType&&other is _DownloadProgress&&(identical(other.fileName, fileName) || other.fileName == fileName)&&(identical(other.downloaded, downloaded) || other.downloaded == downloaded)&&(identical(other.total, total) || other.total == total));
+}
+
+@JsonKey(includeFromJson: false, includeToJson: false)
+@override
+int get hashCode => Object.hash(runtimeType,fileName,downloaded,total);
+
+@override
+String toString() {
+  return 'DownloadProgress(fileName: $fileName, downloaded: $downloaded, total: $total)';
+}
+
+
+}
+
+/// @nodoc
+abstract mixin class _$DownloadProgressCopyWith<$Res> implements $DownloadProgressCopyWith<$Res> {
+  factory _$DownloadProgressCopyWith(_DownloadProgress value, $Res Function(_DownloadProgress) _then) = __$DownloadProgressCopyWithImpl;
+@override @useResult
+$Res call({
+ String fileName, int downloaded, int total
+});
+
+
+
+
+}
+/// @nodoc
+class __$DownloadProgressCopyWithImpl<$Res>
+    implements _$DownloadProgressCopyWith<$Res> {
+  __$DownloadProgressCopyWithImpl(this._self, this._then);
+
+  final _DownloadProgress _self;
+  final $Res Function(_DownloadProgress) _then;
+
+/// Create a copy of DownloadProgress
+/// with the given fields replaced by the non-null parameter values.
+@override @pragma('vm:prefer-inline') $Res call({Object? fileName = null,Object? downloaded = null,Object? total = null,}) {
+  return _then(_DownloadProgress(
+fileName: null == fileName ? _self.fileName : fileName // ignore: cast_nullable_to_non_nullable
+as String,downloaded: null == downloaded ? _self.downloaded : downloaded // ignore: cast_nullable_to_non_nullable
+as int,total: null == total ? _self.total : total // ignore: cast_nullable_to_non_nullable
+as int,
+  ));
+}
+
+
+}
+
+// dart format on
diff --git a/packages/komodo_defi_sdk/lib/src/zcash_params/models/download_progress.g.dart b/packages/komodo_defi_sdk/lib/src/zcash_params/models/download_progress.g.dart
new file mode 100644
index 000000000..51a9b07a3
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/zcash_params/models/download_progress.g.dart
@@ -0,0 +1,21 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'download_progress.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+_DownloadProgress _$DownloadProgressFromJson(Map<String, dynamic> json) =>
+    _DownloadProgress(
+      fileName: json['fileName'] as String,
+      downloaded: (json['downloaded'] as num).toInt(),
+      total: (json['total'] as num).toInt(),
+    );
+
+Map<String, dynamic> _$DownloadProgressToJson(_DownloadProgress instance) =>
+    <String, dynamic>{
+      'fileName': instance.fileName,
+      'downloaded': instance.downloaded,
+      'total': instance.total,
+    };
diff --git a/packages/komodo_defi_sdk/lib/src/zcash_params/models/download_result.dart b/packages/komodo_defi_sdk/lib/src/zcash_params/models/download_result.dart
new file mode 100644
index 000000000..caa7acccf
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/zcash_params/models/download_result.dart
@@ -0,0 +1,24 @@
+import 'package:freezed_annotation/freezed_annotation.dart';
+
+part 'download_result.freezed.dart';
+part 'download_result.g.dart';
+
+/// Represents the result of a ZCash parameters download operation.
+@freezed
+abstract class DownloadResult with _$DownloadResult {
+  /// Creates a successful download result.
+  const factory DownloadResult.success({
+    /// The path to the downloaded ZCash parameters directory.
+    required String paramsPath,
+  }) = DownloadResultSuccess;
+
+  /// Creates a failed download result with an error message.
+  const factory DownloadResult.failure({
+    /// Error message if the download failed.
+    required String error,
+  }) = DownloadResultFailure;
+
+  /// Creates a DownloadResult instance from JSON.
+  factory DownloadResult.fromJson(Map<String, dynamic> json) =>
+      _$DownloadResultFromJson(json);
+}
diff --git a/packages/komodo_defi_sdk/lib/src/zcash_params/models/download_result.freezed.dart b/packages/komodo_defi_sdk/lib/src/zcash_params/models/download_result.freezed.dart
new file mode 100644
index 000000000..b51776eb0
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/zcash_params/models/download_result.freezed.dart
@@ -0,0 +1,354 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+// coverage:ignore-file
+// ignore_for_file: type=lint
+// ignore_for_file: unused_element, deprecated_member_use, deprecated_member_use_from_same_package, use_function_type_syntax_for_parameters, unnecessary_const, avoid_init_to_null, invalid_override_different_default_values_named, prefer_expression_function_bodies, annotate_overrides, invalid_annotation_target, unnecessary_question_mark
+
+part of 'download_result.dart';
+
+// **************************************************************************
+// FreezedGenerator
+// **************************************************************************
+
+// dart format off
+T _$identity<T>(T value) => value;
+DownloadResult _$DownloadResultFromJson(
+  Map<String, dynamic> json
+) {
+        switch (json['runtimeType']) {
+                  case 'success':
+          return DownloadResultSuccess.fromJson(
+            json
+          );
+                case 'failure':
+          return DownloadResultFailure.fromJson(
+            json
+          );
+        
+          default:
+            throw CheckedFromJsonException(
+  json,
+  'runtimeType',
+  'DownloadResult',
+  'Invalid union type "${json['runtimeType']}"!'
+);
+        }
+      
+}
+
+/// @nodoc
+mixin _$DownloadResult {
+
+
+
+  /// Serializes this DownloadResult to a JSON map.
+  Map<String, dynamic> toJson();
+
+
+@override
+bool operator ==(Object other) {
+  return identical(this, other) || (other.runtimeType == runtimeType&&other is DownloadResult);
+}
+
+@JsonKey(includeFromJson: false, includeToJson: false)
+@override
+int get hashCode => runtimeType.hashCode;
+
+@override
+String toString() {
+  return 'DownloadResult()';
+}
+
+
+}
+
+/// @nodoc
+class $DownloadResultCopyWith<$Res>  {
+$DownloadResultCopyWith(DownloadResult _, $Res Function(DownloadResult) __);
+}
+
+
+/// Adds pattern-matching-related methods to [DownloadResult].
+extension DownloadResultPatterns on DownloadResult {
+/// A variant of `map` that fallback to returning `orElse`.
+///
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case final Subclass value:
+///     return ...;
+///   case _:
+///     return orElse();
+/// }
+/// ```
+
+@optionalTypeArgs TResult maybeMap<TResult extends Object?>({TResult Function( DownloadResultSuccess value)?  success,TResult Function( DownloadResultFailure value)?  failure,required TResult orElse(),}){
+final _that = this;
+switch (_that) {
+case DownloadResultSuccess() when success != null:
+return success(_that);case DownloadResultFailure() when failure != null:
+return failure(_that);case _:
+  return orElse();
+
+}
+}
+/// A `switch`-like method, using callbacks.
+///
+/// Callbacks receives the raw object, upcasted.
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case final Subclass value:
+///     return ...;
+///   case final Subclass2 value:
+///     return ...;
+/// }
+/// ```
+
+@optionalTypeArgs TResult map<TResult extends Object?>({required TResult Function( DownloadResultSuccess value)  success,required TResult Function( DownloadResultFailure value)  failure,}){
+final _that = this;
+switch (_that) {
+case DownloadResultSuccess():
+return success(_that);case DownloadResultFailure():
+return failure(_that);case _:
+  throw StateError('Unexpected subclass');
+
+}
+}
+/// A variant of `map` that fallback to returning `null`.
+///
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case final Subclass value:
+///     return ...;
+///   case _:
+///     return null;
+/// }
+/// ```
+
+@optionalTypeArgs TResult? mapOrNull<TResult extends Object?>({TResult? Function( DownloadResultSuccess value)?  success,TResult? Function( DownloadResultFailure value)?  failure,}){
+final _that = this;
+switch (_that) {
+case DownloadResultSuccess() when success != null:
+return success(_that);case DownloadResultFailure() when failure != null:
+return failure(_that);case _:
+  return null;
+
+}
+}
+/// A variant of `when` that fallback to an `orElse` callback.
+///
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case Subclass(:final field):
+///     return ...;
+///   case _:
+///     return orElse();
+/// }
+/// ```
+
+@optionalTypeArgs TResult maybeWhen<TResult extends Object?>({TResult Function( String paramsPath)?  success,TResult Function( String error)?  failure,required TResult orElse(),}) {final _that = this;
+switch (_that) {
+case DownloadResultSuccess() when success != null:
+return success(_that.paramsPath);case DownloadResultFailure() when failure != null:
+return failure(_that.error);case _:
+  return orElse();
+
+}
+}
+/// A `switch`-like method, using callbacks.
+///
+/// As opposed to `map`, this offers destructuring.
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case Subclass(:final field):
+///     return ...;
+///   case Subclass2(:final field2):
+///     return ...;
+/// }
+/// ```
+
+@optionalTypeArgs TResult when<TResult extends Object?>({required TResult Function( String paramsPath)  success,required TResult Function( String error)  failure,}) {final _that = this;
+switch (_that) {
+case DownloadResultSuccess():
+return success(_that.paramsPath);case DownloadResultFailure():
+return failure(_that.error);case _:
+  throw StateError('Unexpected subclass');
+
+}
+}
+/// A variant of `when` that fallback to returning `null`
+///
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case Subclass(:final field):
+///     return ...;
+///   case _:
+///     return null;
+/// }
+/// ```
+
+@optionalTypeArgs TResult? whenOrNull<TResult extends Object?>({TResult? Function( String paramsPath)?  success,TResult? Function( String error)?  failure,}) {final _that = this;
+switch (_that) {
+case DownloadResultSuccess() when success != null:
+return success(_that.paramsPath);case DownloadResultFailure() when failure != null:
+return failure(_that.error);case _:
+  return null;
+
+}
+}
+
+}
+
+/// @nodoc
+@JsonSerializable()
+
+class DownloadResultSuccess implements DownloadResult {
+  const DownloadResultSuccess({required this.paramsPath, final  String? $type}): $type = $type ?? 'success';
+  factory DownloadResultSuccess.fromJson(Map<String, dynamic> json) => _$DownloadResultSuccessFromJson(json);
+
+/// The path to the downloaded ZCash parameters directory.
+ final  String paramsPath;
+
+@JsonKey(name: 'runtimeType')
+final String $type;
+
+
+/// Create a copy of DownloadResult
+/// with the given fields replaced by the non-null parameter values.
+@JsonKey(includeFromJson: false, includeToJson: false)
+@pragma('vm:prefer-inline')
+$DownloadResultSuccessCopyWith<DownloadResultSuccess> get copyWith => _$DownloadResultSuccessCopyWithImpl<DownloadResultSuccess>(this, _$identity);
+
+@override
+Map<String, dynamic> toJson() {
+  return _$DownloadResultSuccessToJson(this, );
+}
+
+@override
+bool operator ==(Object other) {
+  return identical(this, other) || (other.runtimeType == runtimeType&&other is DownloadResultSuccess&&(identical(other.paramsPath, paramsPath) || other.paramsPath == paramsPath));
+}
+
+@JsonKey(includeFromJson: false, includeToJson: false)
+@override
+int get hashCode => Object.hash(runtimeType,paramsPath);
+
+@override
+String toString() {
+  return 'DownloadResult.success(paramsPath: $paramsPath)';
+}
+
+
+}
+
+/// @nodoc
+abstract mixin class $DownloadResultSuccessCopyWith<$Res> implements $DownloadResultCopyWith<$Res> {
+  factory $DownloadResultSuccessCopyWith(DownloadResultSuccess value, $Res Function(DownloadResultSuccess) _then) = _$DownloadResultSuccessCopyWithImpl;
+@useResult
+$Res call({
+ String paramsPath
+});
+
+
+
+
+}
+/// @nodoc
+class _$DownloadResultSuccessCopyWithImpl<$Res>
+    implements $DownloadResultSuccessCopyWith<$Res> {
+  _$DownloadResultSuccessCopyWithImpl(this._self, this._then);
+
+  final DownloadResultSuccess _self;
+  final $Res Function(DownloadResultSuccess) _then;
+
+/// Create a copy of DownloadResult
+/// with the given fields replaced by the non-null parameter values.
+@pragma('vm:prefer-inline') $Res call({Object? paramsPath = null,}) {
+  return _then(DownloadResultSuccess(
+paramsPath: null == paramsPath ? _self.paramsPath : paramsPath // ignore: cast_nullable_to_non_nullable
+as String,
+  ));
+}
+
+
+}
+
+/// @nodoc
+@JsonSerializable()
+
+class DownloadResultFailure implements DownloadResult {
+  const DownloadResultFailure({required this.error, final  String? $type}): $type = $type ?? 'failure';
+  factory DownloadResultFailure.fromJson(Map<String, dynamic> json) => _$DownloadResultFailureFromJson(json);
+
+/// Error message if the download failed.
+ final  String error;
+
+@JsonKey(name: 'runtimeType')
+final String $type;
+
+
+/// Create a copy of DownloadResult
+/// with the given fields replaced by the non-null parameter values.
+@JsonKey(includeFromJson: false, includeToJson: false)
+@pragma('vm:prefer-inline')
+$DownloadResultFailureCopyWith<DownloadResultFailure> get copyWith => _$DownloadResultFailureCopyWithImpl<DownloadResultFailure>(this, _$identity);
+
+@override
+Map<String, dynamic> toJson() {
+  return _$DownloadResultFailureToJson(this, );
+}
+
+@override
+bool operator ==(Object other) {
+  return identical(this, other) || (other.runtimeType == runtimeType&&other is DownloadResultFailure&&(identical(other.error, error) || other.error == error));
+}
+
+@JsonKey(includeFromJson: false, includeToJson: false)
+@override
+int get hashCode => Object.hash(runtimeType,error);
+
+@override
+String toString() {
+  return 'DownloadResult.failure(error: $error)';
+}
+
+
+}
+
+/// @nodoc
+abstract mixin class $DownloadResultFailureCopyWith<$Res> implements $DownloadResultCopyWith<$Res> {
+  factory $DownloadResultFailureCopyWith(DownloadResultFailure value, $Res Function(DownloadResultFailure) _then) = _$DownloadResultFailureCopyWithImpl;
+@useResult
+$Res call({
+ String error
+});
+
+
+
+
+}
+/// @nodoc
+class _$DownloadResultFailureCopyWithImpl<$Res>
+    implements $DownloadResultFailureCopyWith<$Res> {
+  _$DownloadResultFailureCopyWithImpl(this._self, this._then);
+
+  final DownloadResultFailure _self;
+  final $Res Function(DownloadResultFailure) _then;
+
+/// Create a copy of DownloadResult
+/// with the given fields replaced by the non-null parameter values.
+@pragma('vm:prefer-inline') $Res call({Object? error = null,}) {
+  return _then(DownloadResultFailure(
+error: null == error ? _self.error : error // ignore: cast_nullable_to_non_nullable
+as String,
+  ));
+}
+
+
+}
+
+// dart format on
diff --git a/packages/komodo_defi_sdk/lib/src/zcash_params/models/download_result.g.dart b/packages/komodo_defi_sdk/lib/src/zcash_params/models/download_result.g.dart
new file mode 100644
index 000000000..9eee288a0
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/zcash_params/models/download_result.g.dart
@@ -0,0 +1,32 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'download_result.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+DownloadResultSuccess _$DownloadResultSuccessFromJson(
+  Map<String, dynamic> json,
+) => DownloadResultSuccess(
+  paramsPath: json['paramsPath'] as String,
+  $type: json['runtimeType'] as String?,
+);
+
+Map<String, dynamic> _$DownloadResultSuccessToJson(
+  DownloadResultSuccess instance,
+) => <String, dynamic>{
+  'paramsPath': instance.paramsPath,
+  'runtimeType': instance.$type,
+};
+
+DownloadResultFailure _$DownloadResultFailureFromJson(
+  Map<String, dynamic> json,
+) => DownloadResultFailure(
+  error: json['error'] as String,
+  $type: json['runtimeType'] as String?,
+);
+
+Map<String, dynamic> _$DownloadResultFailureToJson(
+  DownloadResultFailure instance,
+) => <String, dynamic>{'error': instance.error, 'runtimeType': instance.$type};
diff --git a/packages/komodo_defi_sdk/lib/src/zcash_params/models/zcash_params_config.dart b/packages/komodo_defi_sdk/lib/src/zcash_params/models/zcash_params_config.dart
new file mode 100644
index 000000000..5168102d8
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/zcash_params/models/zcash_params_config.dart
@@ -0,0 +1,159 @@
+import 'package:freezed_annotation/freezed_annotation.dart';
+
+part 'zcash_params_config.freezed.dart';
+part 'zcash_params_config.g.dart';
+
+/// Configuration for a ZCash parameter file.
+@freezed
+abstract class ZcashParamFile with _$ZcashParamFile {
+  @JsonSerializable(fieldRename: FieldRename.snake)
+  /// Creates a ZCash parameter file configuration.
+  const factory ZcashParamFile({
+    /// The name of the parameter file.
+    required String fileName,
+
+    /// The expected SHA256 hash of the file for integrity verification.
+    required String sha256Hash,
+
+    /// The expected file size in bytes (optional, for progress reporting).
+    int? expectedSize,
+  }) = _ZcashParamFile;
+
+  const ZcashParamFile._();
+
+  /// Creates a ZcashParamFile instance from JSON.
+  factory ZcashParamFile.fromJson(Map<String, dynamic> json) =>
+      _$ZcashParamFileFromJson(json);
+}
+
+/// Configuration for ZCash parameter downloads.
+@freezed
+abstract class ZcashParamsConfig with _$ZcashParamsConfig {
+  @JsonSerializable(fieldRename: FieldRename.snake)
+  /// Creates a ZCash parameters configuration.
+  const factory ZcashParamsConfig({
+    /// List of ZCash parameter files to download.
+    required List<ZcashParamFile> paramFiles,
+
+    /// Primary download URL for ZCash parameters.
+    @Default('https://komodoplatform.com/downloads/') String primaryUrl,
+
+    /// Backup download URL for ZCash parameters.
+    @Default('https://z.cash/downloads/') String backupUrl,
+
+    /// Timeout duration for HTTP downloads in seconds.
+    @Default(1800) int downloadTimeoutSeconds, // 30 minutes
+    /// Maximum number of retry attempts for failed downloads.
+    @Default(3) int maxRetries,
+
+    /// Delay between retry attempts in seconds.
+    @Default(5) int retryDelaySeconds,
+
+    /// Buffer size for file downloads in bytes (1MB).
+    @Default(1048576) int downloadBufferSize,
+  }) = _ZcashParamsConfig;
+
+  const ZcashParamsConfig._();
+
+  /// Creates a ZcashParamsConfig instance from JSON.
+  factory ZcashParamsConfig.fromJson(Map<String, dynamic> json) =>
+      _$ZcashParamsConfigFromJson(json);
+
+  /// Default configuration instance with only sapling parameters.
+  static const ZcashParamsConfig defaultConfig = ZcashParamsConfig(
+    paramFiles: [
+      ZcashParamFile(
+        fileName: 'sapling-spend.params',
+        sha256Hash:
+            '8e48ffd23abb3a5fd9c5589204f32d9c31285a04b78096ba40a79b75677efc13',
+        expectedSize: 47958396,
+      ),
+      ZcashParamFile(
+        fileName: 'sapling-output.params',
+        sha256Hash:
+            '2f0ebbcbb9bb0bcffe95a397e7eba89c29eb4dde6191c339db88570e3f3fb0e4',
+        expectedSize: 3592860,
+      ),
+    ],
+  );
+
+  /// Extended configuration instance with all parameter files including sprout.
+  static const ZcashParamsConfig extendedConfig = ZcashParamsConfig(
+    paramFiles: [
+      ZcashParamFile(
+        fileName: 'sapling-spend.params',
+        sha256Hash:
+            '8e48ffd23abb3a5fd9c5589204f32d9c31285a04b78096ba40a79b75677efc13',
+        expectedSize: 47958396,
+      ),
+      ZcashParamFile(
+        fileName: 'sapling-output.params',
+        sha256Hash:
+            '2f0ebbcbb9bb0bcffe95a397e7eba89c29eb4dde6191c339db88570e3f3fb0e4',
+        expectedSize: 3592860,
+      ),
+      ZcashParamFile(
+        fileName: 'sprout-groth16.params',
+        sha256Hash:
+            'b685d700c60328498fbde589c8c7c484c722b788b265b72af448a5bf0ee55b50',
+        expectedSize: 725523612,
+      ),
+    ],
+  );
+
+  /// List of all download URLs in order of preference.
+  List<String> get downloadUrls => [primaryUrl, backupUrl];
+
+  /// Names of the ZCash parameter files that need to be downloaded.
+  List<String> get fileNames =>
+      paramFiles.map((file) => file.fileName).toList();
+
+  /// Timeout duration for HTTP downloads.
+  Duration get downloadTimeout => Duration(seconds: downloadTimeoutSeconds);
+
+  /// Delay between retry attempts.
+  Duration get retryDelay => Duration(seconds: retryDelaySeconds);
+
+  /// Gets the configuration for a given parameter file.
+  /// Returns null if the file is not found.
+  ZcashParamFile? getParamFile(String fileName) {
+    try {
+      return paramFiles.firstWhere((file) => file.fileName == fileName);
+    } catch (e) {
+      return null;
+    }
+  }
+
+  /// Gets the expected file size for a given parameter file.
+  /// Returns null if the file size is unknown.
+  int? getExpectedFileSize(String fileName) {
+    return getParamFile(fileName)?.expectedSize;
+  }
+
+  /// Gets the expected SHA256 hash for a given parameter file.
+  /// Returns null if the hash is unknown.
+  String? getExpectedHash(String fileName) {
+    return getParamFile(fileName)?.sha256Hash;
+  }
+
+  /// Gets the total expected download size for all parameter files.
+  int get totalExpectedSize {
+    return paramFiles
+        .where((file) => file.expectedSize != null)
+        .fold(0, (sum, file) => sum + file.expectedSize!);
+  }
+
+  /// Validates that a filename is a known ZCash parameter file.
+  bool isValidFileName(String fileName) {
+    return fileNames.contains(fileName);
+  }
+
+  /// Gets the full download URL for a parameter file from a base URL.
+  String getFileUrl(String baseUrl, String fileName) {
+    var url = baseUrl;
+    if (!url.endsWith('/')) {
+      url += '/';
+    }
+    return '$url$fileName';
+  }
+}
diff --git a/packages/komodo_defi_sdk/lib/src/zcash_params/models/zcash_params_config.freezed.dart b/packages/komodo_defi_sdk/lib/src/zcash_params/models/zcash_params_config.freezed.dart
new file mode 100644
index 000000000..032a4b14a
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/zcash_params/models/zcash_params_config.freezed.dart
@@ -0,0 +1,593 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+// coverage:ignore-file
+// ignore_for_file: type=lint
+// ignore_for_file: unused_element, deprecated_member_use, deprecated_member_use_from_same_package, use_function_type_syntax_for_parameters, unnecessary_const, avoid_init_to_null, invalid_override_different_default_values_named, prefer_expression_function_bodies, annotate_overrides, invalid_annotation_target, unnecessary_question_mark
+
+part of 'zcash_params_config.dart';
+
+// **************************************************************************
+// FreezedGenerator
+// **************************************************************************
+
+// dart format off
+T _$identity<T>(T value) => value;
+
+/// @nodoc
+mixin _$ZcashParamFile {
+
+/// The name of the parameter file.
+ String get fileName;/// The expected SHA256 hash of the file for integrity verification.
+ String get sha256Hash;/// The expected file size in bytes (optional, for progress reporting).
+ int? get expectedSize;
+/// Create a copy of ZcashParamFile
+/// with the given fields replaced by the non-null parameter values.
+@JsonKey(includeFromJson: false, includeToJson: false)
+@pragma('vm:prefer-inline')
+$ZcashParamFileCopyWith<ZcashParamFile> get copyWith => _$ZcashParamFileCopyWithImpl<ZcashParamFile>(this as ZcashParamFile, _$identity);
+
+  /// Serializes this ZcashParamFile to a JSON map.
+  Map<String, dynamic> toJson();
+
+
+@override
+bool operator ==(Object other) {
+  return identical(this, other) || (other.runtimeType == runtimeType&&other is ZcashParamFile&&(identical(other.fileName, fileName) || other.fileName == fileName)&&(identical(other.sha256Hash, sha256Hash) || other.sha256Hash == sha256Hash)&&(identical(other.expectedSize, expectedSize) || other.expectedSize == expectedSize));
+}
+
+@JsonKey(includeFromJson: false, includeToJson: false)
+@override
+int get hashCode => Object.hash(runtimeType,fileName,sha256Hash,expectedSize);
+
+@override
+String toString() {
+  return 'ZcashParamFile(fileName: $fileName, sha256Hash: $sha256Hash, expectedSize: $expectedSize)';
+}
+
+
+}
+
+/// @nodoc
+abstract mixin class $ZcashParamFileCopyWith<$Res>  {
+  factory $ZcashParamFileCopyWith(ZcashParamFile value, $Res Function(ZcashParamFile) _then) = _$ZcashParamFileCopyWithImpl;
+@useResult
+$Res call({
+ String fileName, String sha256Hash, int? expectedSize
+});
+
+
+
+
+}
+/// @nodoc
+class _$ZcashParamFileCopyWithImpl<$Res>
+    implements $ZcashParamFileCopyWith<$Res> {
+  _$ZcashParamFileCopyWithImpl(this._self, this._then);
+
+  final ZcashParamFile _self;
+  final $Res Function(ZcashParamFile) _then;
+
+/// Create a copy of ZcashParamFile
+/// with the given fields replaced by the non-null parameter values.
+@pragma('vm:prefer-inline') @override $Res call({Object? fileName = null,Object? sha256Hash = null,Object? expectedSize = freezed,}) {
+  return _then(_self.copyWith(
+fileName: null == fileName ? _self.fileName : fileName // ignore: cast_nullable_to_non_nullable
+as String,sha256Hash: null == sha256Hash ? _self.sha256Hash : sha256Hash // ignore: cast_nullable_to_non_nullable
+as String,expectedSize: freezed == expectedSize ? _self.expectedSize : expectedSize // ignore: cast_nullable_to_non_nullable
+as int?,
+  ));
+}
+
+}
+
+
+/// Adds pattern-matching-related methods to [ZcashParamFile].
+extension ZcashParamFilePatterns on ZcashParamFile {
+/// A variant of `map` that fallback to returning `orElse`.
+///
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case final Subclass value:
+///     return ...;
+///   case _:
+///     return orElse();
+/// }
+/// ```
+
+@optionalTypeArgs TResult maybeMap<TResult extends Object?>(TResult Function( _ZcashParamFile value)?  $default,{required TResult orElse(),}){
+final _that = this;
+switch (_that) {
+case _ZcashParamFile() when $default != null:
+return $default(_that);case _:
+  return orElse();
+
+}
+}
+/// A `switch`-like method, using callbacks.
+///
+/// Callbacks receives the raw object, upcasted.
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case final Subclass value:
+///     return ...;
+///   case final Subclass2 value:
+///     return ...;
+/// }
+/// ```
+
+@optionalTypeArgs TResult map<TResult extends Object?>(TResult Function( _ZcashParamFile value)  $default,){
+final _that = this;
+switch (_that) {
+case _ZcashParamFile():
+return $default(_that);case _:
+  throw StateError('Unexpected subclass');
+
+}
+}
+/// A variant of `map` that fallback to returning `null`.
+///
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case final Subclass value:
+///     return ...;
+///   case _:
+///     return null;
+/// }
+/// ```
+
+@optionalTypeArgs TResult? mapOrNull<TResult extends Object?>(TResult? Function( _ZcashParamFile value)?  $default,){
+final _that = this;
+switch (_that) {
+case _ZcashParamFile() when $default != null:
+return $default(_that);case _:
+  return null;
+
+}
+}
+/// A variant of `when` that fallback to an `orElse` callback.
+///
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case Subclass(:final field):
+///     return ...;
+///   case _:
+///     return orElse();
+/// }
+/// ```
+
+@optionalTypeArgs TResult maybeWhen<TResult extends Object?>(TResult Function( String fileName,  String sha256Hash,  int? expectedSize)?  $default,{required TResult orElse(),}) {final _that = this;
+switch (_that) {
+case _ZcashParamFile() when $default != null:
+return $default(_that.fileName,_that.sha256Hash,_that.expectedSize);case _:
+  return orElse();
+
+}
+}
+/// A `switch`-like method, using callbacks.
+///
+/// As opposed to `map`, this offers destructuring.
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case Subclass(:final field):
+///     return ...;
+///   case Subclass2(:final field2):
+///     return ...;
+/// }
+/// ```
+
+@optionalTypeArgs TResult when<TResult extends Object?>(TResult Function( String fileName,  String sha256Hash,  int? expectedSize)  $default,) {final _that = this;
+switch (_that) {
+case _ZcashParamFile():
+return $default(_that.fileName,_that.sha256Hash,_that.expectedSize);case _:
+  throw StateError('Unexpected subclass');
+
+}
+}
+/// A variant of `when` that fallback to returning `null`
+///
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case Subclass(:final field):
+///     return ...;
+///   case _:
+///     return null;
+/// }
+/// ```
+
+@optionalTypeArgs TResult? whenOrNull<TResult extends Object?>(TResult? Function( String fileName,  String sha256Hash,  int? expectedSize)?  $default,) {final _that = this;
+switch (_that) {
+case _ZcashParamFile() when $default != null:
+return $default(_that.fileName,_that.sha256Hash,_that.expectedSize);case _:
+  return null;
+
+}
+}
+
+}
+
+/// @nodoc
+
+@JsonSerializable(fieldRename: FieldRename.snake)
+class _ZcashParamFile extends ZcashParamFile {
+  const _ZcashParamFile({required this.fileName, required this.sha256Hash, this.expectedSize}): super._();
+  factory _ZcashParamFile.fromJson(Map<String, dynamic> json) => _$ZcashParamFileFromJson(json);
+
+/// The name of the parameter file.
+@override final  String fileName;
+/// The expected SHA256 hash of the file for integrity verification.
+@override final  String sha256Hash;
+/// The expected file size in bytes (optional, for progress reporting).
+@override final  int? expectedSize;
+
+/// Create a copy of ZcashParamFile
+/// with the given fields replaced by the non-null parameter values.
+@override @JsonKey(includeFromJson: false, includeToJson: false)
+@pragma('vm:prefer-inline')
+_$ZcashParamFileCopyWith<_ZcashParamFile> get copyWith => __$ZcashParamFileCopyWithImpl<_ZcashParamFile>(this, _$identity);
+
+@override
+Map<String, dynamic> toJson() {
+  return _$ZcashParamFileToJson(this, );
+}
+
+@override
+bool operator ==(Object other) {
+  return identical(this, other) || (other.runtimeType == runtimeType&&other is _ZcashParamFile&&(identical(other.fileName, fileName) || other.fileName == fileName)&&(identical(other.sha256Hash, sha256Hash) || other.sha256Hash == sha256Hash)&&(identical(other.expectedSize, expectedSize) || other.expectedSize == expectedSize));
+}
+
+@JsonKey(includeFromJson: false, includeToJson: false)
+@override
+int get hashCode => Object.hash(runtimeType,fileName,sha256Hash,expectedSize);
+
+@override
+String toString() {
+  return 'ZcashParamFile(fileName: $fileName, sha256Hash: $sha256Hash, expectedSize: $expectedSize)';
+}
+
+
+}
+
+/// @nodoc
+abstract mixin class _$ZcashParamFileCopyWith<$Res> implements $ZcashParamFileCopyWith<$Res> {
+  factory _$ZcashParamFileCopyWith(_ZcashParamFile value, $Res Function(_ZcashParamFile) _then) = __$ZcashParamFileCopyWithImpl;
+@override @useResult
+$Res call({
+ String fileName, String sha256Hash, int? expectedSize
+});
+
+
+
+
+}
+/// @nodoc
+class __$ZcashParamFileCopyWithImpl<$Res>
+    implements _$ZcashParamFileCopyWith<$Res> {
+  __$ZcashParamFileCopyWithImpl(this._self, this._then);
+
+  final _ZcashParamFile _self;
+  final $Res Function(_ZcashParamFile) _then;
+
+/// Create a copy of ZcashParamFile
+/// with the given fields replaced by the non-null parameter values.
+@override @pragma('vm:prefer-inline') $Res call({Object? fileName = null,Object? sha256Hash = null,Object? expectedSize = freezed,}) {
+  return _then(_ZcashParamFile(
+fileName: null == fileName ? _self.fileName : fileName // ignore: cast_nullable_to_non_nullable
+as String,sha256Hash: null == sha256Hash ? _self.sha256Hash : sha256Hash // ignore: cast_nullable_to_non_nullable
+as String,expectedSize: freezed == expectedSize ? _self.expectedSize : expectedSize // ignore: cast_nullable_to_non_nullable
+as int?,
+  ));
+}
+
+
+}
+
+
+/// @nodoc
+mixin _$ZcashParamsConfig {
+
+/// List of ZCash parameter files to download.
+ List<ZcashParamFile> get paramFiles;/// Primary download URL for ZCash parameters.
+ String get primaryUrl;/// Backup download URL for ZCash parameters.
+ String get backupUrl;/// Timeout duration for HTTP downloads in seconds.
+ int get downloadTimeoutSeconds;// 30 minutes
+/// Maximum number of retry attempts for failed downloads.
+ int get maxRetries;/// Delay between retry attempts in seconds.
+ int get retryDelaySeconds;/// Buffer size for file downloads in bytes (1MB).
+ int get downloadBufferSize;
+/// Create a copy of ZcashParamsConfig
+/// with the given fields replaced by the non-null parameter values.
+@JsonKey(includeFromJson: false, includeToJson: false)
+@pragma('vm:prefer-inline')
+$ZcashParamsConfigCopyWith<ZcashParamsConfig> get copyWith => _$ZcashParamsConfigCopyWithImpl<ZcashParamsConfig>(this as ZcashParamsConfig, _$identity);
+
+  /// Serializes this ZcashParamsConfig to a JSON map.
+  Map<String, dynamic> toJson();
+
+
+@override
+bool operator ==(Object other) {
+  return identical(this, other) || (other.runtimeType == runtimeType&&other is ZcashParamsConfig&&const DeepCollectionEquality().equals(other.paramFiles, paramFiles)&&(identical(other.primaryUrl, primaryUrl) || other.primaryUrl == primaryUrl)&&(identical(other.backupUrl, backupUrl) || other.backupUrl == backupUrl)&&(identical(other.downloadTimeoutSeconds, downloadTimeoutSeconds) || other.downloadTimeoutSeconds == downloadTimeoutSeconds)&&(identical(other.maxRetries, maxRetries) || other.maxRetries == maxRetries)&&(identical(other.retryDelaySeconds, retryDelaySeconds) || other.retryDelaySeconds == retryDelaySeconds)&&(identical(other.downloadBufferSize, downloadBufferSize) || other.downloadBufferSize == downloadBufferSize));
+}
+
+@JsonKey(includeFromJson: false, includeToJson: false)
+@override
+int get hashCode => Object.hash(runtimeType,const DeepCollectionEquality().hash(paramFiles),primaryUrl,backupUrl,downloadTimeoutSeconds,maxRetries,retryDelaySeconds,downloadBufferSize);
+
+@override
+String toString() {
+  return 'ZcashParamsConfig(paramFiles: $paramFiles, primaryUrl: $primaryUrl, backupUrl: $backupUrl, downloadTimeoutSeconds: $downloadTimeoutSeconds, maxRetries: $maxRetries, retryDelaySeconds: $retryDelaySeconds, downloadBufferSize: $downloadBufferSize)';
+}
+
+
+}
+
+/// @nodoc
+abstract mixin class $ZcashParamsConfigCopyWith<$Res>  {
+  factory $ZcashParamsConfigCopyWith(ZcashParamsConfig value, $Res Function(ZcashParamsConfig) _then) = _$ZcashParamsConfigCopyWithImpl;
+@useResult
+$Res call({
+ List<ZcashParamFile> paramFiles, String primaryUrl, String backupUrl, int downloadTimeoutSeconds, int maxRetries, int retryDelaySeconds, int downloadBufferSize
+});
+
+
+
+
+}
+/// @nodoc
+class _$ZcashParamsConfigCopyWithImpl<$Res>
+    implements $ZcashParamsConfigCopyWith<$Res> {
+  _$ZcashParamsConfigCopyWithImpl(this._self, this._then);
+
+  final ZcashParamsConfig _self;
+  final $Res Function(ZcashParamsConfig) _then;
+
+/// Create a copy of ZcashParamsConfig
+/// with the given fields replaced by the non-null parameter values.
+@pragma('vm:prefer-inline') @override $Res call({Object? paramFiles = null,Object? primaryUrl = null,Object? backupUrl = null,Object? downloadTimeoutSeconds = null,Object? maxRetries = null,Object? retryDelaySeconds = null,Object? downloadBufferSize = null,}) {
+  return _then(_self.copyWith(
+paramFiles: null == paramFiles ? _self.paramFiles : paramFiles // ignore: cast_nullable_to_non_nullable
+as List<ZcashParamFile>,primaryUrl: null == primaryUrl ? _self.primaryUrl : primaryUrl // ignore: cast_nullable_to_non_nullable
+as String,backupUrl: null == backupUrl ? _self.backupUrl : backupUrl // ignore: cast_nullable_to_non_nullable
+as String,downloadTimeoutSeconds: null == downloadTimeoutSeconds ? _self.downloadTimeoutSeconds : downloadTimeoutSeconds // ignore: cast_nullable_to_non_nullable
+as int,maxRetries: null == maxRetries ? _self.maxRetries : maxRetries // ignore: cast_nullable_to_non_nullable
+as int,retryDelaySeconds: null == retryDelaySeconds ? _self.retryDelaySeconds : retryDelaySeconds // ignore: cast_nullable_to_non_nullable
+as int,downloadBufferSize: null == downloadBufferSize ? _self.downloadBufferSize : downloadBufferSize // ignore: cast_nullable_to_non_nullable
+as int,
+  ));
+}
+
+}
+
+
+/// Adds pattern-matching-related methods to [ZcashParamsConfig].
+extension ZcashParamsConfigPatterns on ZcashParamsConfig {
+/// A variant of `map` that fallback to returning `orElse`.
+///
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case final Subclass value:
+///     return ...;
+///   case _:
+///     return orElse();
+/// }
+/// ```
+
+@optionalTypeArgs TResult maybeMap<TResult extends Object?>(TResult Function( _ZcashParamsConfig value)?  $default,{required TResult orElse(),}){
+final _that = this;
+switch (_that) {
+case _ZcashParamsConfig() when $default != null:
+return $default(_that);case _:
+  return orElse();
+
+}
+}
+/// A `switch`-like method, using callbacks.
+///
+/// Callbacks receives the raw object, upcasted.
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case final Subclass value:
+///     return ...;
+///   case final Subclass2 value:
+///     return ...;
+/// }
+/// ```
+
+@optionalTypeArgs TResult map<TResult extends Object?>(TResult Function( _ZcashParamsConfig value)  $default,){
+final _that = this;
+switch (_that) {
+case _ZcashParamsConfig():
+return $default(_that);case _:
+  throw StateError('Unexpected subclass');
+
+}
+}
+/// A variant of `map` that fallback to returning `null`.
+///
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case final Subclass value:
+///     return ...;
+///   case _:
+///     return null;
+/// }
+/// ```
+
+@optionalTypeArgs TResult? mapOrNull<TResult extends Object?>(TResult? Function( _ZcashParamsConfig value)?  $default,){
+final _that = this;
+switch (_that) {
+case _ZcashParamsConfig() when $default != null:
+return $default(_that);case _:
+  return null;
+
+}
+}
+/// A variant of `when` that fallback to an `orElse` callback.
+///
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case Subclass(:final field):
+///     return ...;
+///   case _:
+///     return orElse();
+/// }
+/// ```
+
+@optionalTypeArgs TResult maybeWhen<TResult extends Object?>(TResult Function( List<ZcashParamFile> paramFiles,  String primaryUrl,  String backupUrl,  int downloadTimeoutSeconds,  int maxRetries,  int retryDelaySeconds,  int downloadBufferSize)?  $default,{required TResult orElse(),}) {final _that = this;
+switch (_that) {
+case _ZcashParamsConfig() when $default != null:
+return $default(_that.paramFiles,_that.primaryUrl,_that.backupUrl,_that.downloadTimeoutSeconds,_that.maxRetries,_that.retryDelaySeconds,_that.downloadBufferSize);case _:
+  return orElse();
+
+}
+}
+/// A `switch`-like method, using callbacks.
+///
+/// As opposed to `map`, this offers destructuring.
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case Subclass(:final field):
+///     return ...;
+///   case Subclass2(:final field2):
+///     return ...;
+/// }
+/// ```
+
+@optionalTypeArgs TResult when<TResult extends Object?>(TResult Function( List<ZcashParamFile> paramFiles,  String primaryUrl,  String backupUrl,  int downloadTimeoutSeconds,  int maxRetries,  int retryDelaySeconds,  int downloadBufferSize)  $default,) {final _that = this;
+switch (_that) {
+case _ZcashParamsConfig():
+return $default(_that.paramFiles,_that.primaryUrl,_that.backupUrl,_that.downloadTimeoutSeconds,_that.maxRetries,_that.retryDelaySeconds,_that.downloadBufferSize);case _:
+  throw StateError('Unexpected subclass');
+
+}
+}
+/// A variant of `when` that fallback to returning `null`
+///
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case Subclass(:final field):
+///     return ...;
+///   case _:
+///     return null;
+/// }
+/// ```
+
+@optionalTypeArgs TResult? whenOrNull<TResult extends Object?>(TResult? Function( List<ZcashParamFile> paramFiles,  String primaryUrl,  String backupUrl,  int downloadTimeoutSeconds,  int maxRetries,  int retryDelaySeconds,  int downloadBufferSize)?  $default,) {final _that = this;
+switch (_that) {
+case _ZcashParamsConfig() when $default != null:
+return $default(_that.paramFiles,_that.primaryUrl,_that.backupUrl,_that.downloadTimeoutSeconds,_that.maxRetries,_that.retryDelaySeconds,_that.downloadBufferSize);case _:
+  return null;
+
+}
+}
+
+}
+
+/// @nodoc
+
+@JsonSerializable(fieldRename: FieldRename.snake)
+class _ZcashParamsConfig extends ZcashParamsConfig {
+  const _ZcashParamsConfig({required final  List<ZcashParamFile> paramFiles, this.primaryUrl = 'https://komodoplatform.com/downloads/', this.backupUrl = 'https://z.cash/downloads/', this.downloadTimeoutSeconds = 1800, this.maxRetries = 3, this.retryDelaySeconds = 5, this.downloadBufferSize = 1048576}): _paramFiles = paramFiles,super._();
+  factory _ZcashParamsConfig.fromJson(Map<String, dynamic> json) => _$ZcashParamsConfigFromJson(json);
+
+/// List of ZCash parameter files to download.
+ final  List<ZcashParamFile> _paramFiles;
+/// List of ZCash parameter files to download.
+@override List<ZcashParamFile> get paramFiles {
+  if (_paramFiles is EqualUnmodifiableListView) return _paramFiles;
+  // ignore: implicit_dynamic_type
+  return EqualUnmodifiableListView(_paramFiles);
+}
+
+/// Primary download URL for ZCash parameters.
+@override@JsonKey() final  String primaryUrl;
+/// Backup download URL for ZCash parameters.
+@override@JsonKey() final  String backupUrl;
+/// Timeout duration for HTTP downloads in seconds.
+@override@JsonKey() final  int downloadTimeoutSeconds;
+// 30 minutes
+/// Maximum number of retry attempts for failed downloads.
+@override@JsonKey() final  int maxRetries;
+/// Delay between retry attempts in seconds.
+@override@JsonKey() final  int retryDelaySeconds;
+/// Buffer size for file downloads in bytes (1MB).
+@override@JsonKey() final  int downloadBufferSize;
+
+/// Create a copy of ZcashParamsConfig
+/// with the given fields replaced by the non-null parameter values.
+@override @JsonKey(includeFromJson: false, includeToJson: false)
+@pragma('vm:prefer-inline')
+_$ZcashParamsConfigCopyWith<_ZcashParamsConfig> get copyWith => __$ZcashParamsConfigCopyWithImpl<_ZcashParamsConfig>(this, _$identity);
+
+@override
+Map<String, dynamic> toJson() {
+  return _$ZcashParamsConfigToJson(this, );
+}
+
+@override
+bool operator ==(Object other) {
+  return identical(this, other) || (other.runtimeType == runtimeType&&other is _ZcashParamsConfig&&const DeepCollectionEquality().equals(other._paramFiles, _paramFiles)&&(identical(other.primaryUrl, primaryUrl) || other.primaryUrl == primaryUrl)&&(identical(other.backupUrl, backupUrl) || other.backupUrl == backupUrl)&&(identical(other.downloadTimeoutSeconds, downloadTimeoutSeconds) || other.downloadTimeoutSeconds == downloadTimeoutSeconds)&&(identical(other.maxRetries, maxRetries) || other.maxRetries == maxRetries)&&(identical(other.retryDelaySeconds, retryDelaySeconds) || other.retryDelaySeconds == retryDelaySeconds)&&(identical(other.downloadBufferSize, downloadBufferSize) || other.downloadBufferSize == downloadBufferSize));
+}
+
+@JsonKey(includeFromJson: false, includeToJson: false)
+@override
+int get hashCode => Object.hash(runtimeType,const DeepCollectionEquality().hash(_paramFiles),primaryUrl,backupUrl,downloadTimeoutSeconds,maxRetries,retryDelaySeconds,downloadBufferSize);
+
+@override
+String toString() {
+  return 'ZcashParamsConfig(paramFiles: $paramFiles, primaryUrl: $primaryUrl, backupUrl: $backupUrl, downloadTimeoutSeconds: $downloadTimeoutSeconds, maxRetries: $maxRetries, retryDelaySeconds: $retryDelaySeconds, downloadBufferSize: $downloadBufferSize)';
+}
+
+
+}
+
+/// @nodoc
+abstract mixin class _$ZcashParamsConfigCopyWith<$Res> implements $ZcashParamsConfigCopyWith<$Res> {
+  factory _$ZcashParamsConfigCopyWith(_ZcashParamsConfig value, $Res Function(_ZcashParamsConfig) _then) = __$ZcashParamsConfigCopyWithImpl;
+@override @useResult
+$Res call({
+ List<ZcashParamFile> paramFiles, String primaryUrl, String backupUrl, int downloadTimeoutSeconds, int maxRetries, int retryDelaySeconds, int downloadBufferSize
+});
+
+
+
+
+}
+/// @nodoc
+class __$ZcashParamsConfigCopyWithImpl<$Res>
+    implements _$ZcashParamsConfigCopyWith<$Res> {
+  __$ZcashParamsConfigCopyWithImpl(this._self, this._then);
+
+  final _ZcashParamsConfig _self;
+  final $Res Function(_ZcashParamsConfig) _then;
+
+/// Create a copy of ZcashParamsConfig
+/// with the given fields replaced by the non-null parameter values.
+@override @pragma('vm:prefer-inline') $Res call({Object? paramFiles = null,Object? primaryUrl = null,Object? backupUrl = null,Object? downloadTimeoutSeconds = null,Object? maxRetries = null,Object? retryDelaySeconds = null,Object? downloadBufferSize = null,}) {
+  return _then(_ZcashParamsConfig(
+paramFiles: null == paramFiles ? _self._paramFiles : paramFiles // ignore: cast_nullable_to_non_nullable
+as List<ZcashParamFile>,primaryUrl: null == primaryUrl ? _self.primaryUrl : primaryUrl // ignore: cast_nullable_to_non_nullable
+as String,backupUrl: null == backupUrl ? _self.backupUrl : backupUrl // ignore: cast_nullable_to_non_nullable
+as String,downloadTimeoutSeconds: null == downloadTimeoutSeconds ? _self.downloadTimeoutSeconds : downloadTimeoutSeconds // ignore: cast_nullable_to_non_nullable
+as int,maxRetries: null == maxRetries ? _self.maxRetries : maxRetries // ignore: cast_nullable_to_non_nullable
+as int,retryDelaySeconds: null == retryDelaySeconds ? _self.retryDelaySeconds : retryDelaySeconds // ignore: cast_nullable_to_non_nullable
+as int,downloadBufferSize: null == downloadBufferSize ? _self.downloadBufferSize : downloadBufferSize // ignore: cast_nullable_to_non_nullable
+as int,
+  ));
+}
+
+
+}
+
+// dart format on
diff --git a/packages/komodo_defi_sdk/lib/src/zcash_params/models/zcash_params_config.g.dart b/packages/komodo_defi_sdk/lib/src/zcash_params/models/zcash_params_config.g.dart
new file mode 100644
index 000000000..12eba1e7e
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/zcash_params/models/zcash_params_config.g.dart
@@ -0,0 +1,49 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'zcash_params_config.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+_ZcashParamFile _$ZcashParamFileFromJson(Map<String, dynamic> json) =>
+    _ZcashParamFile(
+      fileName: json['file_name'] as String,
+      sha256Hash: json['sha256_hash'] as String,
+      expectedSize: (json['expected_size'] as num?)?.toInt(),
+    );
+
+Map<String, dynamic> _$ZcashParamFileToJson(_ZcashParamFile instance) =>
+    <String, dynamic>{
+      'file_name': instance.fileName,
+      'sha256_hash': instance.sha256Hash,
+      'expected_size': instance.expectedSize,
+    };
+
+_ZcashParamsConfig _$ZcashParamsConfigFromJson(Map<String, dynamic> json) =>
+    _ZcashParamsConfig(
+      paramFiles: (json['param_files'] as List<dynamic>)
+          .map((e) => ZcashParamFile.fromJson(e as Map<String, dynamic>))
+          .toList(),
+      primaryUrl:
+          json['primary_url'] as String? ??
+          'https://komodoplatform.com/downloads/',
+      backupUrl: json['backup_url'] as String? ?? 'https://z.cash/downloads/',
+      downloadTimeoutSeconds:
+          (json['download_timeout_seconds'] as num?)?.toInt() ?? 1800,
+      maxRetries: (json['max_retries'] as num?)?.toInt() ?? 3,
+      retryDelaySeconds: (json['retry_delay_seconds'] as num?)?.toInt() ?? 5,
+      downloadBufferSize:
+          (json['download_buffer_size'] as num?)?.toInt() ?? 1048576,
+    );
+
+Map<String, dynamic> _$ZcashParamsConfigToJson(_ZcashParamsConfig instance) =>
+    <String, dynamic>{
+      'param_files': instance.paramFiles,
+      'primary_url': instance.primaryUrl,
+      'backup_url': instance.backupUrl,
+      'download_timeout_seconds': instance.downloadTimeoutSeconds,
+      'max_retries': instance.maxRetries,
+      'retry_delay_seconds': instance.retryDelaySeconds,
+      'download_buffer_size': instance.downloadBufferSize,
+    };
diff --git a/packages/komodo_defi_sdk/lib/src/zcash_params/platforms/mobile_zcash_params_downloader.dart b/packages/komodo_defi_sdk/lib/src/zcash_params/platforms/mobile_zcash_params_downloader.dart
new file mode 100644
index 000000000..233ea27f5
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/zcash_params/platforms/mobile_zcash_params_downloader.dart
@@ -0,0 +1,212 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:flutter/foundation.dart';
+import 'package:komodo_defi_sdk/src/_internal_exports.dart'
+    show ZcashParamsConfig;
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_progress.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_result.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/services/zcash_params_download_service.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/zcash_params_downloader.dart';
+import 'package:path/path.dart' as path;
+import 'package:path_provider/path_provider.dart';
+
+/// Mobile platform implementation of ZCash parameters downloader.
+///
+/// Downloads ZCash parameters to the application documents directory
+/// on both iOS and Android platforms:
+/// - iOS: Application Documents directory (within app sandbox)
+/// - Android: Application Documents directory (app-private storage)
+///
+/// This implementation handles mobile-specific path resolution and
+/// delegates downloading logic to the injected download service.
+class MobileZcashParamsDownloader extends ZcashParamsDownloader {
+  /// Creates a Mobile ZCash parameters downloader.
+  ///
+  /// [downloadService] can be provided for custom download logic, otherwise
+  /// a default implementation is used.
+  /// [directoryFactory] and [fileFactory] can be provided for
+  /// custom file system operations, useful for testing.
+  /// [config] allows overriding the default ZCash parameters configuration.
+  /// If not provided, a default configuration with known parameter files
+  /// and their hashes is used.
+  /// See [ZcashParamsConfig] for details.
+  MobileZcashParamsDownloader({
+    ZcashParamsDownloadService? downloadService,
+    Directory Function(String)? directoryFactory,
+    File Function(String)? fileFactory,
+    bool enableHashValidation = true,
+    super.config,
+  }) : _downloadService =
+           downloadService ??
+           DefaultZcashParamsDownloadService(
+             enableHashValidation: enableHashValidation,
+           ),
+       _directoryFactory = directoryFactory ?? Directory.new,
+       _fileFactory = fileFactory ?? File.new;
+
+  final ZcashParamsDownloadService _downloadService;
+  final Directory Function(String) _directoryFactory;
+  final File Function(String) _fileFactory;
+
+  final StreamController<DownloadProgress> _progressController =
+      StreamController<DownloadProgress>.broadcast();
+
+  bool _isDisposed = false;
+
+  bool _isDownloading = false;
+  bool _isCancelled = false;
+
+  @override
+  Future<DownloadResult> downloadParams() async {
+    if (_isDownloading) {
+      return const DownloadResult.failure(
+        error: 'Download already in progress',
+      );
+    }
+
+    _isDownloading = true;
+    _isCancelled = false;
+
+    try {
+      final paramsPath = await getParamsPath();
+      if (paramsPath == null) {
+        return const DownloadResult.failure(
+          error: 'Unable to determine parameters path',
+        );
+      }
+
+      // Create directory if it doesn't exist
+      await _downloadService.ensureDirectoryExists(
+        paramsPath,
+        _directoryFactory,
+      );
+
+      // Check which files need to be downloaded
+      final missingFiles = await _downloadService.getMissingFiles(
+        paramsPath,
+        _fileFactory,
+        config,
+      );
+
+      if (missingFiles.isEmpty) {
+        return DownloadResult.success(paramsPath: paramsPath);
+      }
+
+      // Download missing files
+      final downloadSuccess = await _downloadService.downloadMissingFiles(
+        paramsPath,
+        missingFiles,
+        _progressController,
+        () => _isCancelled,
+        config,
+      );
+
+      if (!downloadSuccess) {
+        return const DownloadResult.failure(
+          error: 'Failed to download one or more parameter files',
+        );
+      }
+
+      return DownloadResult.success(paramsPath: paramsPath);
+    } catch (e) {
+      return DownloadResult.failure(error: 'Download failed: ${e.toString()}');
+    } finally {
+      _isDownloading = false;
+      _isCancelled = false;
+    }
+  }
+
+  @override
+  Future<String?> getParamsPath() async {
+    try {
+      final documentsDirectory = await getApplicationDocumentsDirectory();
+      return path.join(documentsDirectory.path, 'ZcashParams');
+    } catch (e) {
+      if (kDebugMode) {
+        print('Error getting application documents directory: $e');
+      }
+      return null;
+    }
+  }
+
+  @override
+  Future<bool> areParamsAvailable() async {
+    final paramsPath = await getParamsPath();
+    if (paramsPath == null) return false;
+
+    final missingFiles = await _downloadService.getMissingFiles(
+      paramsPath,
+      _fileFactory,
+      config,
+    );
+
+    return missingFiles.isEmpty;
+  }
+
+  @override
+  Stream<DownloadProgress> get downloadProgress => _progressController.stream;
+
+  @override
+  Future<bool> cancelDownload() async {
+    if (_isDownloading) {
+      _isCancelled = true;
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  Future<bool> validateParams() async {
+    final paramsPath = await getParamsPath();
+    if (paramsPath == null) return false;
+
+    return _downloadService.validateFiles(paramsPath, _fileFactory, config);
+  }
+
+  @override
+  Future<bool> validateFileHash(String filePath, String expectedHash) async {
+    return _downloadService.validateFileHash(
+      filePath,
+      expectedHash,
+      _fileFactory,
+    );
+  }
+
+  @override
+  Future<String?> getFileHash(String filePath) async {
+    return _downloadService.getFileHash(filePath, _fileFactory);
+  }
+
+  @override
+  Future<bool> clearParams() async {
+    final paramsPath = await getParamsPath();
+    if (paramsPath == null) return false;
+
+    return _downloadService.clearFiles(paramsPath, _directoryFactory);
+  }
+
+  /// Disposes of resources used by this downloader.
+  @override
+  void dispose() {
+    if (_isDisposed) {
+      return;
+    }
+
+    _isDisposed = true;
+
+    try {
+      _downloadService.dispose();
+    } catch (_) {
+      // Ignore errors from download service disposal
+    }
+
+    try {
+      if (!_progressController.isClosed) {
+        _progressController.close();
+      }
+    } catch (_) {
+      // Ignore errors from closing progress controller
+    }
+  }
+}
diff --git a/packages/komodo_defi_sdk/lib/src/zcash_params/platforms/unix_zcash_params_downloader.dart b/packages/komodo_defi_sdk/lib/src/zcash_params/platforms/unix_zcash_params_downloader.dart
new file mode 100644
index 000000000..51467e3dd
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/zcash_params/platforms/unix_zcash_params_downloader.dart
@@ -0,0 +1,229 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:flutter/foundation.dart';
+import 'package:komodo_defi_sdk/src/_internal_exports.dart'
+    show ZcashParamsConfig;
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_progress.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_result.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/services/zcash_params_download_service.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/zcash_params_downloader.dart';
+import 'package:path/path.dart' as path;
+import 'package:path_provider/path_provider.dart';
+
+/// Unix platform implementation of ZCash parameters downloader.
+///
+/// Downloads ZCash parameters to platform-specific directories:
+/// - macOS: `$HOME/Library/Application Support/ZcashParams`
+/// - Linux: `$HOME/.zcash-params`
+///
+/// If the HOME environment variable is not available, falls back to the
+/// application documents directory: `Documents/ZcashParams`
+///
+/// This implementation handles Unix-specific path resolution and
+/// delegates downloading logic to the injected download service.
+class UnixZcashParamsDownloader extends ZcashParamsDownloader {
+  /// Creates a Unix ZCash parameters downloader.
+  ///
+  /// [downloadService] can be provided for custom download logic, otherwise
+  /// a default implementation is used.
+  /// [directoryFactory] and [fileFactory] can be provided for
+  /// custom file system operations, useful for testing.
+  /// [config] allows overriding the default ZCash parameters configuration.
+  /// If not provided, a default configuration with known parameter files
+  /// and their hashes is used.
+  /// See [ZcashParamsConfig] for details.
+  /// [homeDirectoryOverride] allows specifying a custom home directory path
+  /// when the HOME environment variable is not available or needs to be overridden.
+  UnixZcashParamsDownloader({
+    ZcashParamsDownloadService? downloadService,
+    Directory Function(String)? directoryFactory,
+    File Function(String)? fileFactory,
+    bool enableHashValidation = true,
+    String? homeDirectoryOverride,
+    super.config,
+  }) : _downloadService =
+           downloadService ??
+           DefaultZcashParamsDownloadService(
+             enableHashValidation: enableHashValidation,
+           ),
+       _directoryFactory = directoryFactory ?? Directory.new,
+       _fileFactory = fileFactory ?? File.new,
+       _homeDirectoryOverride = homeDirectoryOverride;
+
+  final ZcashParamsDownloadService _downloadService;
+  final Directory Function(String) _directoryFactory;
+  final File Function(String) _fileFactory;
+  final String? _homeDirectoryOverride;
+
+  final StreamController<DownloadProgress> _progressController =
+      StreamController<DownloadProgress>.broadcast();
+
+  bool _isDisposed = false;
+
+  bool _isDownloading = false;
+  bool _isCancelled = false;
+
+  @override
+  Future<DownloadResult> downloadParams() async {
+    if (_isDownloading) {
+      return const DownloadResult.failure(
+        error: 'Download already in progress',
+      );
+    }
+
+    _isDownloading = true;
+    _isCancelled = false;
+
+    try {
+      final paramsPath = await getParamsPath();
+      if (paramsPath == null) {
+        return const DownloadResult.failure(
+          error: 'Unable to determine parameters path',
+        );
+      }
+
+      // Create directory if it doesn't exist
+      await _downloadService.ensureDirectoryExists(
+        paramsPath,
+        _directoryFactory,
+      );
+
+      // Check which files need to be downloaded
+      final missingFiles = await _downloadService.getMissingFiles(
+        paramsPath,
+        _fileFactory,
+        config,
+      );
+
+      if (missingFiles.isEmpty) {
+        return DownloadResult.success(paramsPath: paramsPath);
+      }
+
+      // Download missing files
+      final downloadSuccess = await _downloadService.downloadMissingFiles(
+        paramsPath,
+        missingFiles,
+        _progressController,
+        () => _isCancelled,
+        config,
+      );
+
+      if (!downloadSuccess) {
+        return const DownloadResult.failure(
+          error: 'Failed to download one or more parameter files',
+        );
+      }
+
+      return DownloadResult.success(paramsPath: paramsPath);
+    } finally {
+      _isDownloading = false;
+      _isCancelled = false;
+    }
+  }
+
+  @override
+  Future<String?> getParamsPath() async {
+    final home = _homeDirectoryOverride ?? Platform.environment['HOME'];
+
+    if (home != null) {
+      if (Platform.isMacOS) {
+        return path.join(home, 'Library', 'Application Support', 'ZcashParams');
+      } else {
+        // Linux and other Unix-like systems
+        return path.join(home, '.zcash-params');
+      }
+    }
+
+    // Fallback to application documents directory if HOME is not available
+    try {
+      final documentsDirectory = await getApplicationDocumentsDirectory();
+      return path.join(documentsDirectory.path, 'ZcashParams');
+    } catch (e) {
+      if (kDebugMode) {
+        print('Error getting application documents directory: $e');
+      }
+      return null;
+    }
+  }
+
+  @override
+  Future<bool> areParamsAvailable() async {
+    final paramsPath = await getParamsPath();
+    if (paramsPath == null) return false;
+
+    final missingFiles = await _downloadService.getMissingFiles(
+      paramsPath,
+      _fileFactory,
+      config,
+    );
+
+    return missingFiles.isEmpty;
+  }
+
+  @override
+  Stream<DownloadProgress> get downloadProgress => _progressController.stream;
+
+  @override
+  Future<bool> cancelDownload() async {
+    if (_isDownloading) {
+      _isCancelled = true;
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  Future<bool> validateParams() async {
+    final paramsPath = await getParamsPath();
+    if (paramsPath == null) return false;
+
+    return _downloadService.validateFiles(paramsPath, _fileFactory, config);
+  }
+
+  @override
+  Future<bool> validateFileHash(String filePath, String expectedHash) async {
+    return _downloadService.validateFileHash(
+      filePath,
+      expectedHash,
+      _fileFactory,
+    );
+  }
+
+  @override
+  Future<String?> getFileHash(String filePath) async {
+    return _downloadService.getFileHash(filePath, _fileFactory);
+  }
+
+  @override
+  Future<bool> clearParams() async {
+    final paramsPath = await getParamsPath();
+    if (paramsPath == null) return false;
+
+    return _downloadService.clearFiles(paramsPath, _directoryFactory);
+  }
+
+  /// Disposes of resources used by this downloader.
+  @override
+  void dispose() {
+    if (_isDisposed) {
+      return;
+    }
+
+    _isDisposed = true;
+
+    try {
+      _downloadService.dispose();
+    } catch (_) {
+      // Ignore errors from download service disposal
+    }
+
+    try {
+      if (!_progressController.isClosed) {
+        _progressController.close();
+      }
+    } catch (_) {
+      // Ignore errors from closing progress controller
+    }
+  }
+}
diff --git a/packages/komodo_defi_sdk/lib/src/zcash_params/platforms/web_zcash_params_downloader.dart b/packages/komodo_defi_sdk/lib/src/zcash_params/platforms/web_zcash_params_downloader.dart
new file mode 100644
index 000000000..cc3da2b1d
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/zcash_params/platforms/web_zcash_params_downloader.dart
@@ -0,0 +1,78 @@
+import 'dart:async';
+
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_progress.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_result.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/zcash_params_downloader.dart';
+
+/// Web platform implementation of ZCash parameters downloader.
+///
+/// The Web platform doesn't require ZCash parameters to be downloaded locally
+/// since it cannot access the local file system in the same way as native platforms.
+/// This implementation provides a no-op interface that always indicates success.
+class WebZcashParamsDownloader extends ZcashParamsDownloader {
+  /// Creates a new [WebZcashParamsDownloader] instance.
+  WebZcashParamsDownloader({super.config});
+
+  final StreamController<DownloadProgress> _progressController =
+      StreamController<DownloadProgress>.broadcast();
+
+  @override
+  Future<DownloadResult> downloadParams() async {
+    // Web platform doesn't need to download ZCash parameters
+    return const DownloadResult.success(paramsPath: 'web-virtual-path');
+  }
+
+  @override
+  Future<String?> getParamsPath() async {
+    // Web platform doesn't use local file paths for ZCash parameters
+    return null;
+  }
+
+  @override
+  Future<bool> areParamsAvailable() async {
+    // Web platform always considers parameters "available" since
+    // they're not needed
+    return true;
+  }
+
+  @override
+  Stream<DownloadProgress> get downloadProgress => _progressController.stream;
+
+  @override
+  Future<bool> cancelDownload() async {
+    // No downloads to cancel on web platform
+    return false;
+  }
+
+  @override
+  Future<bool> validateParams() async {
+    // No parameters to validate on web platform
+    return true;
+  }
+
+  @override
+  Future<bool> clearParams() async {
+    // No parameters to clear on web platform
+    return true;
+  }
+
+  @override
+  Future<bool> validateFileHash(String filePath, String expectedHash) async {
+    // No file hash validation needed on web platform
+    return true;
+  }
+
+  @override
+  Future<String?> getFileHash(String filePath) async {
+    // No file hash computation needed on web platform
+    return null;
+  }
+
+  /// Disposes of resources used by this downloader.
+  @override
+  void dispose() {
+    if (!_progressController.isClosed) {
+      _progressController.close();
+    }
+  }
+}
diff --git a/packages/komodo_defi_sdk/lib/src/zcash_params/platforms/windows_zcash_params_downloader.dart b/packages/komodo_defi_sdk/lib/src/zcash_params/platforms/windows_zcash_params_downloader.dart
new file mode 100644
index 000000000..511be60a5
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/zcash_params/platforms/windows_zcash_params_downloader.dart
@@ -0,0 +1,179 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_progress.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_result.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/services/zcash_params_download_service.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/zcash_params_downloader.dart';
+import 'package:path/path.dart' as path;
+
+/// Windows platform implementation of ZCash parameters downloader.
+///
+/// Downloads ZCash parameters to the Windows APPDATA directory:
+/// `%APPDATA%\ZcashParams`
+///
+/// This implementation handles Windows-specific path resolution and
+/// delegates downloading logic to the injected download service.
+class WindowsZcashParamsDownloader extends ZcashParamsDownloader {
+  /// Creates a Windows ZCash parameters downloader.
+  ///
+  /// [downloadService] can be provided for custom download logic, otherwise
+  /// a default implementation is used.
+  /// [directoryFactory] and [fileFactory] can be provided for
+  /// custom file system operations, useful for testing.
+  /// [config] allows overriding the default ZCash parameters configuration.
+  /// If not provided, a default configuration with known parameter files
+  /// and their hashes is used.
+  WindowsZcashParamsDownloader({
+    ZcashParamsDownloadService? downloadService,
+    Directory Function(String)? directoryFactory,
+    File Function(String)? fileFactory,
+    bool enableHashValidation = true,
+    super.config,
+  }) : _downloadService =
+           downloadService ??
+           DefaultZcashParamsDownloadService(
+             enableHashValidation: enableHashValidation,
+           ),
+       _directoryFactory = directoryFactory ?? Directory.new,
+       _fileFactory = fileFactory ?? File.new;
+
+  final ZcashParamsDownloadService _downloadService;
+  final Directory Function(String) _directoryFactory;
+  final File Function(String) _fileFactory;
+
+  final StreamController<DownloadProgress> _progressController =
+      StreamController<DownloadProgress>.broadcast();
+
+  bool _isDownloading = false;
+  bool _isCancelled = false;
+
+  @override
+  Future<DownloadResult> downloadParams() async {
+    if (_isDownloading) {
+      return const DownloadResult.failure(
+        error: 'Download already in progress',
+      );
+    }
+
+    _isDownloading = true;
+    _isCancelled = false;
+
+    final paramsPath = await getParamsPath();
+    if (paramsPath == null) {
+      _isDownloading = false;
+      _isCancelled = false;
+      return const DownloadResult.failure(
+        error: 'Unable to determine parameters path',
+      );
+    }
+
+    // Create directory if it doesn't exist
+    await _downloadService.ensureDirectoryExists(paramsPath, _directoryFactory);
+
+    // Check which files need to be downloaded
+    final missingFiles = await _downloadService.getMissingFiles(
+      paramsPath,
+      _fileFactory,
+      config,
+    );
+
+    if (missingFiles.isEmpty) {
+      _isDownloading = false;
+      _isCancelled = false;
+      return DownloadResult.success(paramsPath: paramsPath);
+    }
+
+    // Download missing files
+    final downloadSuccess = await _downloadService.downloadMissingFiles(
+      paramsPath,
+      missingFiles,
+      _progressController,
+      () => _isCancelled,
+      config,
+    );
+
+    _isDownloading = false;
+    _isCancelled = false;
+
+    if (!downloadSuccess) {
+      return const DownloadResult.failure(
+        error: 'Failed to download one or more parameter files',
+      );
+    }
+
+    return DownloadResult.success(paramsPath: paramsPath);
+  }
+
+  @override
+  Future<String?> getParamsPath() async {
+    final appData = Platform.environment['APPDATA'];
+    if (appData == null) {
+      return null;
+    }
+    return path.join(appData, 'ZcashParams');
+  }
+
+  @override
+  Future<bool> areParamsAvailable() async {
+    final paramsPath = await getParamsPath();
+    if (paramsPath == null) return false;
+
+    final missingFiles = await _downloadService.getMissingFiles(
+      paramsPath,
+      _fileFactory,
+      config,
+    );
+
+    return missingFiles.isEmpty;
+  }
+
+  @override
+  Future<bool> validateFileHash(String filePath, String expectedHash) async {
+    return _downloadService.validateFileHash(
+      filePath,
+      expectedHash,
+      _fileFactory,
+    );
+  }
+
+  @override
+  Future<String?> getFileHash(String filePath) async {
+    return _downloadService.getFileHash(filePath, _fileFactory);
+  }
+
+  @override
+  Stream<DownloadProgress> get downloadProgress => _progressController.stream;
+
+  @override
+  Future<bool> cancelDownload() async {
+    if (_isDownloading) {
+      _isCancelled = true;
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  Future<bool> validateParams() async {
+    final paramsPath = await getParamsPath();
+    if (paramsPath == null) return false;
+
+    return _downloadService.validateFiles(paramsPath, _fileFactory, config);
+  }
+
+  @override
+  Future<bool> clearParams() async {
+    final paramsPath = await getParamsPath();
+    if (paramsPath == null) return false;
+
+    return _downloadService.clearFiles(paramsPath, _directoryFactory);
+  }
+
+  /// Disposes of resources used by this downloader.
+  @override
+  void dispose() {
+    _downloadService.dispose();
+    _progressController.close();
+  }
+}
diff --git a/packages/komodo_defi_sdk/lib/src/zcash_params/services/zcash_params_download_service.dart b/packages/komodo_defi_sdk/lib/src/zcash_params/services/zcash_params_download_service.dart
new file mode 100644
index 000000000..7b6a02600
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/zcash_params/services/zcash_params_download_service.dart
@@ -0,0 +1,600 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:crypto/crypto.dart' show sha256;
+import 'package:http/http.dart' as http;
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_progress.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/models/zcash_params_config.dart';
+import 'package:komodo_defi_types/komodo_defi_type_utils.dart'
+    show ExponentialBackoff, retry;
+import 'package:logging/logging.dart';
+import 'package:path/path.dart' as path;
+
+/// Interface for ZCash parameters download functionality.
+///
+/// This service provides the common downloading logic that can be shared
+/// across different platform implementations.
+abstract class ZcashParamsDownloadService {
+  /// Downloads missing parameter files to the specified directory.
+  ///
+  /// Returns true if all files were downloaded successfully, false otherwise.
+  /// Progress is reported through the [progressStream].
+  Future<bool> downloadMissingFiles(
+    String destinationDirectory,
+    List<String> missingFiles,
+    StreamController<DownloadProgress> progressController,
+    bool Function() isCancelled,
+    ZcashParamsConfig config,
+  );
+
+  /// Checks which parameter files are missing from the destination directory.
+  Future<List<String>> getMissingFiles(
+    String destinationDirectory,
+    File Function(String) fileFactory,
+    ZcashParamsConfig config,
+  );
+
+  /// Creates the destination directory if it doesn't exist.
+  Future<void> ensureDirectoryExists(
+    String directoryPath,
+    Directory Function(String) directoryFactory,
+  );
+
+  /// Validates that all parameter files exist and have valid hashes.
+  Future<bool> validateFiles(
+    String directoryPath,
+    File Function(String) fileFactory,
+    ZcashParamsConfig config,
+  );
+
+  /// Validates the SHA256 hash of a specific file.
+  Future<bool> validateFileHash(
+    String filePath,
+    String expectedHash,
+    File Function(String) fileFactory,
+  );
+
+  /// Gets the SHA256 hash of a file.
+  Future<String?> getFileHash(
+    String filePath,
+    File Function(String) fileFactory,
+  );
+
+  /// Gets the file size from HTTP headers without downloading.
+  Future<int?> getRemoteFileSize(String url);
+
+  /// Clears all parameter files from the directory.
+  Future<bool> clearFiles(
+    String directoryPath,
+    Directory Function(String) directoryFactory,
+  );
+
+  /// Disposes of resources used by this service.
+  void dispose();
+}
+
+/// Default implementation of ZcashParamsDownloadService.
+class DefaultZcashParamsDownloadService implements ZcashParamsDownloadService {
+  /// Creates a DefaultZcashParamsDownloadService instance.
+  DefaultZcashParamsDownloadService({
+    http.Client? httpClient,
+    this.enableHashValidation = true,
+  }) : _httpClient = httpClient ?? http.Client();
+
+  static final Logger _logger = Logger('ZcashParamsDownloadService');
+  final http.Client _httpClient;
+
+  /// Whether hash validation is enabled for this service instance.
+  final bool enableHashValidation;
+
+  @override
+  Future<bool> downloadMissingFiles(
+    String destinationDirectory,
+    List<String> missingFiles,
+    StreamController<DownloadProgress> progressController,
+    bool Function() isCancelled,
+    ZcashParamsConfig config,
+  ) async {
+    _logger.info(
+      'Starting download of ${missingFiles.length} missing files '
+      'to $destinationDirectory',
+    );
+
+    try {
+      for (final fileName in missingFiles) {
+        if (isCancelled()) {
+          _logger.warning('Download cancelled for file: $fileName');
+          return false;
+        }
+
+        final success = await _downloadFile(
+          fileName,
+          destinationDirectory,
+          progressController,
+          isCancelled,
+          config,
+        );
+
+        if (!success) {
+          _logger.severe('Failed to download file: $fileName');
+          return false;
+        }
+
+        _logger.fine('Successfully downloaded file: $fileName');
+      }
+
+      _logger.info('Successfully downloaded all ${missingFiles.length} files');
+      return true;
+    } catch (e, stackTrace) {
+      _logger.severe('Error during download process', e, stackTrace);
+      return false;
+    }
+  }
+
+  @override
+  Future<List<String>> getMissingFiles(
+    String destinationDirectory,
+    File Function(String) fileFactory,
+    ZcashParamsConfig config,
+  ) async {
+    _logger.fine(
+      'Checking for missing files in directory: $destinationDirectory',
+    );
+
+    try {
+      final missingFiles = <String>[];
+
+      for (final fileName in config.fileNames) {
+        final file = fileFactory(path.join(destinationDirectory, fileName));
+        if (!file.existsSync()) {
+          _logger.fine('File not found: $fileName');
+          missingFiles.add(fileName);
+        } else if (enableHashValidation) {
+          // Check if file hash is valid only if validation is enabled
+          final paramFile = config.getParamFile(fileName);
+          if (paramFile != null) {
+            final isValid = await validateFileHash(
+              file.path,
+              paramFile.sha256Hash,
+              fileFactory,
+            );
+            if (!isValid) {
+              _logger.warning('File hash validation failed for: $fileName');
+              missingFiles.add(fileName);
+            }
+          }
+        }
+      }
+
+      _logger.info(
+        'Found ${missingFiles.length} missing files: ${missingFiles.join(', ')}',
+      );
+      return missingFiles;
+    } catch (e, stackTrace) {
+      _logger.severe('Error checking for missing files', e, stackTrace);
+      return config.fileNames;
+    }
+  }
+
+  @override
+  Future<void> ensureDirectoryExists(
+    String directoryPath,
+    Directory Function(String) directoryFactory,
+  ) async {
+    _logger.fine('Ensuring directory exists: $directoryPath');
+
+    try {
+      final directory = directoryFactory(directoryPath);
+      if (!directory.existsSync()) {
+        _logger.info('Creating directory: $directoryPath');
+        await directory.create(recursive: true);
+      }
+    } catch (e, stackTrace) {
+      _logger.severe('Error creating directory: $directoryPath', e, stackTrace);
+      rethrow;
+    }
+  }
+
+  @override
+  Future<bool> validateFiles(
+    String directoryPath,
+    File Function(String) fileFactory,
+    ZcashParamsConfig config,
+  ) async {
+    _logger.fine('Validating all files in directory: $directoryPath');
+
+    try {
+      for (final paramFile in config.paramFiles) {
+        final file = fileFactory(path.join(directoryPath, paramFile.fileName));
+
+        if (!file.existsSync()) {
+          _logger.warning(
+            'File does not exist during validation: ${paramFile.fileName}',
+          );
+          return false;
+        }
+
+        if (enableHashValidation) {
+          final isValid = await validateFileHash(
+            file.path,
+            paramFile.sha256Hash,
+            fileFactory,
+          );
+          if (!isValid) {
+            _logger.warning(
+              'File hash validation failed: ${paramFile.fileName}',
+            );
+            return false;
+          }
+        }
+      }
+
+      _logger.info('All files validated successfully');
+      return true;
+    } catch (e, stackTrace) {
+      _logger.severe('Error during file validation', e, stackTrace);
+      return false;
+    }
+  }
+
+  @override
+  Future<bool> validateFileHash(
+    String filePath,
+    String expectedHash,
+    File Function(String) fileFactory,
+  ) async {
+    _logger.fine('Validating hash for file: $filePath');
+
+    try {
+      final actualHash = await getFileHash(filePath, fileFactory);
+      if (actualHash == null) {
+        _logger.warning('Could not calculate hash for file: $filePath');
+        return false;
+      }
+
+      final isValid = actualHash.toLowerCase() == expectedHash.toLowerCase();
+      if (!isValid) {
+        _logger.warning(
+          'Hash mismatch for $filePath. Expected: $expectedHash, Actual: $actualHash',
+        );
+      } else {
+        _logger.fine('Hash validation successful for: $filePath');
+      }
+
+      return isValid;
+    } catch (e, stackTrace) {
+      _logger.severe(
+        'Error validating file hash for: $filePath',
+        e,
+        stackTrace,
+      );
+      return false;
+    }
+  }
+
+  @override
+  Future<String?> getFileHash(
+    String filePath,
+    File Function(String) fileFactory,
+  ) async {
+    _logger.fine('Calculating hash for file: $filePath');
+
+    try {
+      final file = fileFactory(filePath);
+      if (!file.existsSync()) {
+        _logger.fine('File does not exist for hash calculation: $filePath');
+        return null;
+      }
+
+      final stream = file.openRead();
+      final digest = await sha256.bind(stream).first;
+
+      // Ensure lowercase hex string to match Rust format!("{:x}", hasher.finalize())
+      final hash = digest.toString().toLowerCase();
+      _logger.fine('Hash calculated for $filePath: $hash');
+      return hash;
+    } catch (e, stackTrace) {
+      _logger.severe(
+        'Error calculating file hash for: $filePath',
+        e,
+        stackTrace,
+      );
+      return null;
+    }
+  }
+
+  @override
+  Future<int?> getRemoteFileSize(String url) async {
+    _logger.fine('Getting remote file size for: $url');
+
+    try {
+      final response = await _httpClient.head(Uri.parse(url));
+      if (response.statusCode == 200) {
+        final contentLength = response.headers['content-length'];
+        if (contentLength != null) {
+          final size = int.tryParse(contentLength);
+          _logger.fine('Remote file size for $url: $size bytes');
+          return size;
+        }
+      }
+      _logger.warning(
+        'Could not get remote file size for $url, status: ${response.statusCode}',
+      );
+    } catch (e, stackTrace) {
+      _logger.warning(
+        'Error getting remote file size for: $url',
+        e,
+        stackTrace,
+      );
+    }
+    return null;
+  }
+
+  @override
+  Future<bool> clearFiles(
+    String directoryPath,
+    Directory Function(String) directoryFactory,
+  ) async {
+    _logger.info('Clearing files from directory: $directoryPath');
+
+    try {
+      final directory = directoryFactory(directoryPath);
+      if (directory.existsSync()) {
+        await directory.delete(recursive: true);
+        _logger.info('Successfully cleared directory: $directoryPath');
+      } else {
+        _logger.fine(
+          'Directory does not exist, nothing to clear: $directoryPath',
+        );
+      }
+      return true;
+    } catch (e, stackTrace) {
+      _logger.severe(
+        'Error clearing files from directory: $directoryPath',
+        e,
+        stackTrace,
+      );
+      return false;
+    }
+  }
+
+  /// Downloads a single parameter file.
+  Future<bool> _downloadFile(
+    String fileName,
+    String destinationDirectory,
+    StreamController<DownloadProgress> progressController,
+    bool Function() isCancelled,
+    ZcashParamsConfig config,
+  ) async {
+    final destinationPath = path.join(destinationDirectory, fileName);
+    final paramFile = config.getParamFile(fileName);
+
+    _logger.info('Starting download of file: $fileName');
+
+    // Try primary URL first, then backup URLs
+    for (final baseUrl in config.downloadUrls) {
+      if (isCancelled()) {
+        _logger.warning('Download cancelled for file: $fileName');
+        return false;
+      }
+
+      final fileUrl = config.getFileUrl(baseUrl, fileName);
+      _logger.info('Attempting download from URL: $fileUrl');
+
+      try {
+        // Get file size dynamically
+        _logger.fine('Getting remote file size for: $fileUrl');
+        final remoteSize = await getRemoteFileSize(fileUrl);
+        final expectedSize = remoteSize ?? paramFile?.expectedSize;
+        _logger
+          ..fine('Remote file size: $remoteSize, expected size: $expectedSize')
+          ..info('Starting download from URL with retry: $fileUrl');
+
+        final success = await retry(
+          () => _downloadFromUrl(
+            fileUrl,
+            destinationPath,
+            fileName,
+            expectedSize,
+            progressController,
+            isCancelled,
+            config,
+          ),
+          maxAttempts: 3,
+          backoffStrategy: ExponentialBackoff(
+            initialDelay: const Duration(seconds: 1),
+            maxDelay: const Duration(seconds: 30),
+            withJitter: true,
+          ),
+          onRetry: (attempt, error, delay) {
+            _logger.warning(
+              'Retry attempt $attempt for $fileName from $fileUrl after '
+              '$delay due to: $error',
+            );
+          },
+        );
+        _logger.info(
+          'Download from URL completed: $fileUrl, success: $success',
+        );
+
+        if (success) {
+          // Validate downloaded file hash if enabled
+          if (enableHashValidation && paramFile != null) {
+            final isValid = await validateFileHash(
+              destinationPath,
+              paramFile.sha256Hash,
+              File.new,
+            );
+            if (!isValid) {
+              _logger.warning(
+                'Downloaded file hash validation failed for $fileName, '
+                'trying next URL',
+              );
+              // Delete invalid file and try next URL
+              final file = File(destinationPath);
+              if (file.existsSync()) {
+                await file.delete();
+              }
+              continue;
+            }
+            _logger.info(
+              'Successfully downloaded and validated file: $fileName',
+            );
+          } else {
+            _logger.info(
+              'Successfully downloaded file: $fileName (hash validation '
+              '${enableHashValidation ? 'passed' : 'disabled'})',
+            );
+          }
+          return true;
+        }
+      } catch (e, stackTrace) {
+        _logger.warning(
+          'Error downloading from $fileUrl for file $fileName',
+          e,
+          stackTrace,
+        );
+        continue;
+      }
+    }
+
+    _logger.severe(
+      'Failed to download file from all available URLs: $fileName',
+    );
+    return false;
+  }
+
+  /// Downloads a file from a specific URL.
+  Future<bool> _downloadFromUrl(
+    String url,
+    String destinationPath,
+    String fileName,
+    int? expectedSize,
+    StreamController<DownloadProgress> progressController,
+    bool Function() isCancelled,
+    ZcashParamsConfig config,
+  ) async {
+    http.StreamedResponse? response;
+    IOSink? sink;
+    bool success = false;
+    final file = File(destinationPath);
+
+    _logger.info('Starting HTTP download from URL: $url to $destinationPath');
+
+    try {
+      final request = http.Request('GET', Uri.parse(url));
+      request.headers['User-Agent'] = 'ZcashParamsDownloader/1.0';
+
+      response = await _httpClient
+          .send(request)
+          .timeout(config.downloadTimeout);
+
+      if (response.statusCode != 200) {
+        _logger.warning('HTTP error ${response.statusCode} for URL: $url');
+        return false;
+      }
+
+      sink = file.openWrite();
+
+      int downloaded = 0;
+      final total = expectedSize ?? response.contentLength ?? 0;
+      _logger.fine('Downloading $fileName: $total bytes expected');
+
+      _logger.info('Starting to process download stream for: $fileName');
+      var chunkCount = 0;
+      await for (final chunk in response.stream) {
+        chunkCount++;
+        if (chunkCount % 100 == 0) {
+          _logger.finer(
+            'Processed $chunkCount chunks for $fileName, '
+            'downloaded: $downloaded bytes',
+          );
+        }
+
+        if (isCancelled()) {
+          _logger.warning(
+            'Download cancelled for $fileName at $downloaded bytes',
+          );
+          return false;
+        }
+
+        // Write chunk directly to avoid corruption
+        sink.add(chunk);
+        downloaded += chunk.length;
+
+        // Report progress
+        if (total > 0) {
+          progressController.add(
+            DownloadProgress(
+              fileName: fileName,
+              downloaded: downloaded,
+              total: total,
+            ),
+          );
+        }
+      }
+      _logger.info(
+        'Finished processing download stream for: $fileName, '
+        'total chunks: $chunkCount',
+      );
+
+      // Final progress update
+      progressController.add(
+        DownloadProgress(
+          fileName: fileName,
+          downloaded: downloaded,
+          total: downloaded,
+        ),
+      );
+
+      _logger.fine('Successfully downloaded $fileName: $downloaded bytes');
+      success = true;
+      return true;
+    } on TimeoutException catch (e, stackTrace) {
+      _logger.warning(
+        'Download timeout for $fileName from $url',
+        e,
+        stackTrace,
+      );
+      return false;
+    } catch (e, stackTrace) {
+      _logger.severe('Error downloading $fileName from $url', e, stackTrace);
+      return false;
+    } finally {
+      // Close sink if it's open
+      if (sink != null) {
+        try {
+          _logger.fine('Closing file sink for: $fileName');
+          await sink.close();
+          _logger.fine('File sink closed successfully for: $fileName');
+        } catch (e) {
+          _logger.warning('Error closing sink for $fileName: $e');
+        }
+      }
+
+      // Clean up partial file on failure
+      if (!success && file.existsSync()) {
+        try {
+          await file.delete();
+          _logger.fine('Deleted partial file: $destinationPath');
+        } catch (e) {
+          _logger.warning('Failed to delete partial file $destinationPath: $e');
+        }
+      }
+
+      // Clean up response stream
+      try {
+        await response?.stream.listen(null).cancel();
+      } catch (e) {
+        _logger.fine('Error cancelling response stream: $e');
+      }
+    }
+  }
+
+  /// Disposes of resources used by this service.
+  @override
+  void dispose() {
+    _logger.fine('Disposing ZcashParamsDownloadService');
+    _httpClient.close();
+  }
+}
diff --git a/packages/komodo_defi_sdk/lib/src/zcash_params/zcash_params_downloader.dart b/packages/komodo_defi_sdk/lib/src/zcash_params/zcash_params_downloader.dart
new file mode 100644
index 000000000..0fba66de0
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/zcash_params/zcash_params_downloader.dart
@@ -0,0 +1,163 @@
+import 'dart:async';
+
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_progress.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_result.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/models/zcash_params_config.dart';
+
+/// Abstract base class for platform-specific ZCash parameters downloaders.
+///
+/// This class defines the contract that all platform implementations must follow.
+/// Each platform (Windows, Unix, Web) has its own specific implementation that
+/// handles the platform's unique requirements for ZCash parameter management.
+abstract class ZcashParamsDownloader {
+  /// Creates a ZCash parameters downloader with the given configuration.
+  const ZcashParamsDownloader({ZcashParamsConfig? config})
+    : config = config ?? _defaultConfig;
+
+  /// Configuration for ZCash parameter downloads.
+  final ZcashParamsConfig config;
+
+  /// Default configuration with known ZCash parameter files and their hashes.
+  static const ZcashParamsConfig _defaultConfig =
+      ZcashParamsConfig.defaultConfig;
+
+  /// Downloads ZCash parameters if they are not already available.
+  ///
+  /// Returns a [DownloadResult] indicating whether the operation was successful.
+  /// For platforms that don't require ZCash parameters (like Web), this should
+  /// return a successful result immediately.
+  ///
+  /// The implementation should:
+  /// - Check if parameters already exist locally
+  /// - Create necessary directories if they don't exist
+  /// - Download missing parameter files from configured URLs
+  /// - Report progress through the [downloadProgress] stream
+  /// - Handle network failures gracefully with retries and fallback URLs
+  /// - Return the path to the parameters directory on success
+  ///
+  /// Throws:
+  /// - [StateError] if required environment variables are missing (APPDATA on Windows, HOME on Unix)
+  /// - [FileSystemException] if directory creation or file operations fail
+  /// - [IOException] if file I/O operations fail
+  /// - [SocketException] for network connectivity issues
+  /// - [TimeoutException] if download operations timeout
+  /// - [HttpException] for HTTP-related errors
+  /// - [ArgumentError] for invalid path operations
+  Future<DownloadResult> downloadParams();
+
+  /// Gets the platform-specific path where ZCash parameters should be stored.
+  ///
+  /// Returns null for platforms that don't use local ZCash parameters (like Web).
+  /// For other platforms, returns the full path to the directory where
+  /// parameter files are stored.
+  ///
+  /// Examples:
+  /// - Windows: `C:\Users\Username\AppData\Roaming\ZcashParams`
+  /// - macOS: `/Users/Username/Library/Application Support/ZcashParams`
+  /// - Linux: `/home/username/.zcash-params`
+  /// - Web: `null`
+  ///
+  /// Throws:
+  /// - [StateError] if required environment variables are missing (APPDATA on Windows, HOME on Unix)
+  /// - [ArgumentError] for invalid path operations
+  Future<String?> getParamsPath();
+
+  /// Checks if all required ZCash parameters are available locally.
+  ///
+  /// Returns true if all parameter files exist and are valid, false otherwise.
+  /// For platforms that don't require parameters (like Web), this should
+  /// always return true.
+  ///
+  /// The implementation should verify that:
+  /// - The parameters directory exists
+  /// - All required parameter files are present
+  /// - Files are not corrupted (optional, basic size check)
+  ///
+  /// Throws:
+  /// - [StateError] if required environment variables are missing
+  /// - [FileSystemException] if file system operations fail
+  /// - [IOException] if file access operations fail
+  /// - [ArgumentError] for invalid path operations
+  Future<bool> areParamsAvailable();
+
+  /// Stream that reports download progress for parameter files.
+  ///
+  /// Emits [DownloadProgress] events during the download process to allow
+  /// UI components to display progress to the user. The stream should emit:
+  /// - Progress updates during file downloads
+  /// - Completion events when files finish downloading
+  ///
+  /// The stream should be broadcast to allow multiple listeners.
+  Stream<DownloadProgress> get downloadProgress;
+
+  /// Cancels any ongoing download operation.
+  ///
+  /// This method should gracefully stop any in-progress downloads and clean up
+  /// temporary files. After cancellation, subsequent calls to [downloadParams]
+  /// should start fresh.
+  ///
+  /// Returns true if a download was cancelled, false if no download was in progress.
+  Future<bool> cancelDownload();
+
+  /// Validates the integrity of downloaded parameter files.
+  ///
+  /// This method verifies that downloaded files are valid and not corrupted by:
+  /// - Checking file sizes against expected values
+  /// - Verifying SHA256 checksums against expected hashes
+  /// - Ensuring all required files are present
+  ///
+  /// Returns true if all files are valid, false if any issues are detected.
+  ///
+  /// Throws:
+  /// - [StateError] if required environment variables are missing
+  /// - [FileSystemException] if file system operations fail
+  /// - [IOException] if file access or hashing operations fail
+  /// - [ArgumentError] for invalid path operations
+  Future<bool> validateParams();
+
+  /// Validates the SHA256 hash of a specific parameter file.
+  ///
+  /// [filePath] is the full path to the file to validate.
+  /// [expectedHash] is the expected SHA256 hash in hexadecimal format.
+  ///
+  /// Returns true if the file's hash matches the expected hash, false otherwise.
+  /// Returns false if the file doesn't exist or cannot be read.
+  ///
+  /// Throws:
+  /// - [FileSystemException] if file system operations fail
+  /// - [IOException] if file access or hashing operations fail
+  /// - [ArgumentError] for invalid file paths
+  Future<bool> validateFileHash(String filePath, String expectedHash);
+
+  /// Gets the SHA256 hash of a file.
+  ///
+  /// [filePath] is the full path to the file to hash.
+  ///
+  /// Returns the SHA256 hash in hexadecimal format, or null if the file
+  /// doesn't exist or cannot be read.
+  ///
+  /// Throws:
+  /// - [FileSystemException] if file system operations fail
+  /// - [IOException] if file access or hashing operations fail
+  /// - [ArgumentError] for invalid file paths
+  Future<String?> getFileHash(String filePath);
+
+  /// Clears all downloaded parameter files.
+  ///
+  /// This method removes all parameter files from the local storage directory.
+  /// Useful for troubleshooting or forcing a fresh download.
+  ///
+  /// Returns true if files were successfully cleared, false if there was an error.
+  ///
+  /// Throws:
+  /// - [StateError] if required environment variables are missing
+  /// - [FileSystemException] if directory deletion operations fail
+  /// - [IOException] if file system operations fail
+  /// - [ArgumentError] for invalid path operations
+  Future<bool> clearParams();
+
+  /// Disposes of the downloader.
+  ///
+  /// This method should be called to release any resources used by the downloader.
+  void dispose();
+}
diff --git a/packages/komodo_defi_sdk/lib/src/zcash_params/zcash_params_downloader_factory.dart b/packages/komodo_defi_sdk/lib/src/zcash_params/zcash_params_downloader_factory.dart
new file mode 100644
index 000000000..fff6c6ddf
--- /dev/null
+++ b/packages/komodo_defi_sdk/lib/src/zcash_params/zcash_params_downloader_factory.dart
@@ -0,0 +1,213 @@
+import 'dart:io';
+
+import 'package:flutter/foundation.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/models/zcash_params_config.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/platforms/mobile_zcash_params_downloader.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/platforms/unix_zcash_params_downloader.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/platforms/web_zcash_params_downloader.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/platforms/windows_zcash_params_downloader.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/services/zcash_params_download_service.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/zcash_params_downloader.dart';
+
+/// Factory class for creating platform-specific ZCash parameters downloaders.
+///
+/// This factory automatically detects the current platform and returns the
+/// appropriate downloader implementation:
+/// - Web: [WebZcashParamsDownloader] (no-op implementation)
+/// - Windows: [WindowsZcashParamsDownloader] (downloads to %APPDATA%\ZcashParams)
+/// - macOS/Linux: [UnixZcashParamsDownloader] (downloads to platform-specific paths)
+/// - iOS/Android: [MobileZcashParamsDownloader] (downloads to app documents directory)
+class ZcashParamsDownloaderFactory {
+  const ZcashParamsDownloaderFactory._();
+
+  /// Creates a platform-specific ZCash parameters downloader.
+  ///
+  /// The factory automatically detects the current platform and returns
+  /// the appropriate implementation. This method should be used as the
+  /// primary entry point for obtaining a downloader instance.
+  ///
+  /// Returns:
+  /// - [WebZcashParamsDownloader] for web platforms
+  /// - [WindowsZcashParamsDownloader] for Windows platforms
+  /// - [UnixZcashParamsDownloader] for macOS and Linux platforms
+  /// - [MobileZcashParamsDownloader] for iOS and Android platforms
+  ///
+  /// Example usage:
+  /// ```dart
+  /// final downloader = ZcashParamsDownloaderFactory.create();
+  /// final result = await downloader.downloadParams();
+  /// ```
+  static ZcashParamsDownloader create({
+    ZcashParamsDownloadService? downloadService,
+    ZcashParamsConfig? config,
+    bool enableHashValidation = true,
+  }) {
+    if (kIsWeb || kIsWasm) {
+      return WebZcashParamsDownloader(config: config);
+    }
+
+    if (Platform.isWindows) {
+      return WindowsZcashParamsDownloader(
+        downloadService: downloadService,
+        config: config,
+        enableHashValidation: enableHashValidation,
+      );
+    }
+
+    if (Platform.isIOS || Platform.isAndroid) {
+      return MobileZcashParamsDownloader(
+        downloadService: downloadService,
+        config: config,
+        enableHashValidation: enableHashValidation,
+      );
+    }
+
+    // macOS, Linux, and other Unix-like platforms
+    return UnixZcashParamsDownloader(
+      downloadService: downloadService,
+      config: config,
+      enableHashValidation: enableHashValidation,
+    );
+  }
+
+  /// Creates a downloader for a specific platform type.
+  ///
+  /// This method is primarily useful for testing or when you need to
+  /// create a downloader for a platform other than the current one.
+  ///
+  /// [platformType] - The target platform type
+  ///
+  /// Throws [ArgumentError] if an unsupported platform type is provided.
+  static ZcashParamsDownloader createForPlatform(
+    ZcashParamsPlatform platformType, {
+    ZcashParamsDownloadService? downloadService,
+    ZcashParamsConfig? config,
+    bool enableHashValidation = true,
+  }) {
+    switch (platformType) {
+      case ZcashParamsPlatform.web:
+        return WebZcashParamsDownloader(config: config);
+      case ZcashParamsPlatform.windows:
+        return WindowsZcashParamsDownloader(
+          downloadService: downloadService,
+          config: config,
+          enableHashValidation: enableHashValidation,
+        );
+      case ZcashParamsPlatform.mobile:
+        return MobileZcashParamsDownloader(
+          downloadService: downloadService,
+          config: config,
+          enableHashValidation: enableHashValidation,
+        );
+      case ZcashParamsPlatform.unix:
+        return UnixZcashParamsDownloader(
+          downloadService: downloadService,
+          config: config,
+          enableHashValidation: enableHashValidation,
+        );
+    }
+  }
+
+  /// Detects the current platform and returns the corresponding enum value.
+  ///
+  /// This method can be useful for logging, debugging, or when you need to
+  /// know which platform-specific implementation will be used without
+  /// actually creating the downloader.
+  static ZcashParamsPlatform detectPlatform() {
+    if (kIsWeb || kIsWasm) {
+      return ZcashParamsPlatform.web;
+    }
+
+    if (Platform.isWindows) {
+      return ZcashParamsPlatform.windows;
+    }
+
+    if (Platform.isIOS || Platform.isAndroid) {
+      return ZcashParamsPlatform.mobile;
+    }
+
+    return ZcashParamsPlatform.unix;
+  }
+
+  /// Checks if the current platform requires ZCash parameter downloads.
+  ///
+  /// Returns false for web platforms (which don't need local parameters)
+  /// and true for all other platforms.
+  static bool get requiresDownload {
+    return !kIsWeb && !kIsWasm;
+  }
+
+  /// Gets the expected parameters directory path for the current platform.
+  ///
+  /// This is a convenience method that creates a downloader instance and
+  /// immediately gets its parameters path. For repeated operations, it's
+  /// more efficient to create a single downloader instance and reuse it.
+  ///
+  /// Returns null for web platforms.
+  static Future<String?> getDefaultParamsPath() async {
+    final downloader = create();
+    try {
+      return await downloader.getParamsPath();
+    } finally {
+      downloader.dispose();
+    }
+  }
+}
+
+/// Enumeration of supported platforms for ZCash parameter downloads.
+enum ZcashParamsPlatform {
+  /// Web platform - no local parameter downloads needed
+  web,
+
+  /// Windows platform - downloads to %APPDATA%\ZcashParams
+  windows,
+
+  /// Mobile platforms (iOS, Android) - downloads to app documents directory
+  mobile,
+
+  /// Unix-like platforms (macOS, Linux) - downloads to platform-specific paths
+  unix,
+}
+
+/// Extension methods for [ZcashParamsPlatform] enum.
+extension ZcashParamsPlatformExtension on ZcashParamsPlatform {
+  /// Human-readable name for the platform.
+  String get displayName {
+    switch (this) {
+      case ZcashParamsPlatform.web:
+        return 'Web';
+      case ZcashParamsPlatform.windows:
+        return 'Windows';
+      case ZcashParamsPlatform.mobile:
+        return 'Mobile';
+      case ZcashParamsPlatform.unix:
+        return 'Unix/Linux';
+    }
+  }
+
+  /// Whether this platform requires parameter downloads.
+  bool get requiresDownload {
+    switch (this) {
+      case ZcashParamsPlatform.web:
+        return false;
+      case ZcashParamsPlatform.windows:
+      case ZcashParamsPlatform.mobile:
+      case ZcashParamsPlatform.unix:
+        return true;
+    }
+  }
+
+  /// Expected parameters directory name for this platform.
+  String? get defaultDirectoryName {
+    switch (this) {
+      case ZcashParamsPlatform.web:
+        return null;
+      case ZcashParamsPlatform.windows:
+        return 'ZcashParams';
+      case ZcashParamsPlatform.mobile:
+        return 'ZcashParams';
+      case ZcashParamsPlatform.unix:
+        return null; // Varies by Unix platform
+    }
+  }
+}
diff --git a/packages/komodo_defi_sdk/pubspec.yaml b/packages/komodo_defi_sdk/pubspec.yaml
index 9854b3ecb..f0e8c4ba2 100644
--- a/packages/komodo_defi_sdk/pubspec.yaml
+++ b/packages/komodo_defi_sdk/pubspec.yaml
@@ -14,12 +14,18 @@ resolution: workspace
 
 dependencies:
   collection: ^1.18.0
+  crypto: ^3.0.6 # from transitive to direct for file hash checks
   decimal: ^3.2.1
   flutter:
     sdk: flutter
   flutter_secure_storage: ^10.0.0-beta.4
+  freezed_annotation: ^3.0.0
   get_it: ^8.0.3
+  hive_ce: ^2.11.3
+  hive_ce_flutter: ^2.3.2
   http: ^1.4.0
+  json_annotation: ^4.9.0
+
   komodo_cex_market_data: ^0.0.3+1
   komodo_coins: ^0.3.1+2
   komodo_defi_framework: ^0.3.1+2
@@ -28,16 +34,21 @@ dependencies:
   komodo_defi_types: ^0.3.2+1
   komodo_ui: ^0.3.0+3
 
+  logging: ^1.3.0
   mutex: ^3.1.0
+  path: ^1.9.1
+  path_provider: ^2.1.5
   provider: ^6.1.2
   shared_preferences: ^2.3.2
-
-  logging: ^1.3.0
-  path: ^1.9.1
 dev_dependencies:
-  index_generator: ^4.0.1
+  build_runner: ^2.4.14
   fake_async: ^1.3.3
+  freezed: ^3.0.4
+  hive_ce_generator: ^1.9.3
+  index_generator: ^4.0.1
+  json_serializable: ^6.7.1
   mocktail: ^1.0.4
+  path_provider_platform_interface: ^2.1.2
   # test: ^1.25.7
   test: ^1.25.7
   very_good_analysis: ^9.0.0
diff --git a/packages/komodo_defi_sdk/test/transaction_history/transaction_history_strategies_test.dart b/packages/komodo_defi_sdk/test/transaction_history/transaction_history_strategies_test.dart
new file mode 100644
index 000000000..fc6d33587
--- /dev/null
+++ b/packages/komodo_defi_sdk/test/transaction_history/transaction_history_strategies_test.dart
@@ -0,0 +1,74 @@
+import 'package:komodo_defi_local_auth/komodo_defi_local_auth.dart';
+import 'package:komodo_defi_sdk/src/pubkeys/pubkey_manager.dart';
+import 'package:komodo_defi_sdk/src/transaction_history/strategies/etherscan_transaction_history_strategy.dart';
+import 'package:komodo_defi_sdk/src/transaction_history/strategies/zhtlc_transaction_strategy.dart';
+import 'package:komodo_defi_sdk/src/transaction_history/transaction_history_strategies.dart';
+import 'package:komodo_defi_types/komodo_defi_types.dart';
+import 'package:mocktail/mocktail.dart';
+import 'package:test/test.dart';
+
+class _MockPubkeyManager extends Mock implements PubkeyManager {}
+
+class _MockLocalAuth extends Mock implements KomodoDefiLocalAuth {}
+
+Asset _createZhtlcAsset() {
+  final protocol = ZhtlcProtocol.fromJson({
+    'type': 'ZHTLC',
+    'electrum_servers': [
+      {'url': 'lightwalletd.pirate.black', 'port': 9067, 'protocol': 'SSL'},
+    ],
+  });
+
+  return Asset(
+    id: AssetId(
+      id: 'ARRR',
+      name: 'Pirate Chain',
+      symbol: AssetSymbol(assetConfigId: 'ARRR'),
+      chainId: AssetChainId(chainId: 1),
+      derivationPath: null,
+      subClass: CoinSubClass.zhtlc,
+    ),
+    protocol: protocol,
+    isWalletOnly: false,
+    signMessagePrefix: null,
+  );
+}
+
+void main() {
+  late PubkeyManager pubkeyManager;
+  late KomodoDefiLocalAuth auth;
+
+  setUp(() {
+    pubkeyManager = _MockPubkeyManager();
+    auth = _MockLocalAuth();
+  });
+
+  group('TransactionHistoryStrategyFactory', () {
+    test('selects ZHTLC strategy for ZHTLC asset', () {
+      final factory = TransactionHistoryStrategyFactory(pubkeyManager, auth);
+      final asset = _createZhtlcAsset();
+
+      final strategy = factory.forAsset(asset);
+
+      expect(strategy, isA<ZhtlcTransactionStrategy>());
+    });
+
+    test('ZHTLC strategy wins regardless of registration order', () {
+      final asset = _createZhtlcAsset();
+      final factory = TransactionHistoryStrategyFactory(
+        pubkeyManager,
+        auth,
+        strategies: [
+          const LegacyTransactionStrategy(),
+          V2TransactionStrategy(auth),
+          EtherscanTransactionStrategy(pubkeyManager: pubkeyManager),
+          const ZhtlcTransactionStrategy(),
+        ],
+      );
+
+      final strategy = factory.forAsset(asset);
+
+      expect(strategy, isA<ZhtlcTransactionStrategy>());
+    });
+  });
+}
diff --git a/packages/komodo_defi_sdk/test/zcash_params/integration/mobile_integration_test.dart b/packages/komodo_defi_sdk/test/zcash_params/integration/mobile_integration_test.dart
new file mode 100644
index 000000000..ed8e203b9
--- /dev/null
+++ b/packages/komodo_defi_sdk/test/zcash_params/integration/mobile_integration_test.dart
@@ -0,0 +1,336 @@
+import 'dart:io';
+
+import 'package:flutter_test/flutter_test.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_result.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/platforms/mobile_zcash_params_downloader.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/zcash_params_downloader_factory.dart';
+import 'package:mocktail/mocktail.dart';
+import 'package:path_provider_platform_interface/path_provider_platform_interface.dart';
+import 'package:plugin_platform_interface/plugin_platform_interface.dart';
+
+class MockPathProviderPlatform extends Mock
+    with MockPlatformInterfaceMixin
+    implements PathProviderPlatform {}
+
+void main() {
+  group('Mobile Platform Integration Tests', () {
+    late MockPathProviderPlatform mockPathProvider;
+
+    setUp(() {
+      mockPathProvider = MockPathProviderPlatform();
+      PathProviderPlatform.instance = mockPathProvider;
+    });
+
+    group('Factory Integration', () {
+      test('creates mobile downloader for mobile platform enum', () {
+        final downloader = ZcashParamsDownloaderFactory.createForPlatform(
+          ZcashParamsPlatform.mobile,
+        );
+
+        expect(downloader, isA<MobileZcashParamsDownloader>());
+        expect(downloader.runtimeType, equals(MobileZcashParamsDownloader));
+      });
+
+      test('mobile platform enum properties are correct', () {
+        const platform = ZcashParamsPlatform.mobile;
+
+        expect(platform.displayName, equals('Mobile'));
+        expect(platform.requiresDownload, isTrue);
+        expect(platform.defaultDirectoryName, equals('ZcashParams'));
+      });
+
+      test('mobile downloader uses path provider correctly', () async {
+        const testDocumentsPath = '/test/documents';
+        const expectedParamsPath = '/test/documents/ZcashParams';
+
+        when(
+          () => mockPathProvider.getApplicationDocumentsPath(),
+        ).thenAnswer((_) async => testDocumentsPath);
+
+        final downloader =
+            ZcashParamsDownloaderFactory.createForPlatform(
+                  ZcashParamsPlatform.mobile,
+                )
+                as MobileZcashParamsDownloader;
+
+        final paramsPath = await downloader.getParamsPath();
+
+        expect(paramsPath, equals(expectedParamsPath));
+        verify(() => mockPathProvider.getApplicationDocumentsPath()).called(1);
+
+        // Clean up
+        downloader.dispose();
+      });
+
+      test(
+        'mobile downloader handles path provider errors gracefully',
+        () async {
+          when(
+            () => mockPathProvider.getApplicationDocumentsPath(),
+          ).thenThrow(Exception('Platform not supported'));
+
+          final downloader =
+              ZcashParamsDownloaderFactory.createForPlatform(
+                    ZcashParamsPlatform.mobile,
+                  )
+                  as MobileZcashParamsDownloader;
+
+          final paramsPath = await downloader.getParamsPath();
+
+          expect(paramsPath, isNull);
+
+          // Clean up
+          downloader.dispose();
+        },
+      );
+    });
+
+    group('End-to-End Workflow', () {
+      test(
+        'mobile downloader completes full workflow when path is available',
+        () async {
+          const testDocumentsPath = '/test/documents';
+
+          when(
+            () => mockPathProvider.getApplicationDocumentsPath(),
+          ).thenAnswer((_) async => testDocumentsPath);
+
+          final downloader = ZcashParamsDownloaderFactory.createForPlatform(
+            ZcashParamsPlatform.mobile,
+          );
+
+          // Test path resolution
+          final paramsPath = await downloader.getParamsPath();
+          expect(paramsPath, isNotNull);
+          expect(paramsPath, contains('ZcashParams'));
+
+          // Test availability check (should work even if files don't exist)
+          final available = await downloader.areParamsAvailable();
+          expect(available, isA<bool>());
+
+          // Test download progress stream
+          final progressStream = downloader.downloadProgress;
+          expect(progressStream, isA<Stream>());
+          expect(progressStream.isBroadcast, isTrue);
+
+          // Test cancellation when no download is active
+          final cancelResult = await downloader.cancelDownload();
+          expect(cancelResult, isFalse);
+
+          // Clean up
+          downloader.dispose();
+        },
+      );
+
+      test(
+        'mobile downloader fails gracefully when path is unavailable',
+        () async {
+          when(
+            () => mockPathProvider.getApplicationDocumentsPath(),
+          ).thenThrow(Exception('No documents directory'));
+
+          final downloader = ZcashParamsDownloaderFactory.createForPlatform(
+            ZcashParamsPlatform.mobile,
+          );
+
+          // All path-dependent operations should fail gracefully
+          expect(await downloader.getParamsPath(), isNull);
+          expect(await downloader.areParamsAvailable(), isFalse);
+          expect(await downloader.validateParams(), isFalse);
+          expect(await downloader.clearParams(), isFalse);
+
+          final downloadResult = await downloader.downloadParams();
+          downloadResult.maybeWhen(
+            success: (path) => fail('Expected failure but got success'),
+            failure: (error) =>
+                expect(error, contains('Unable to determine parameters path')),
+            orElse: () => fail('Unexpected result type'),
+          );
+
+          // Clean up
+          downloader.dispose();
+        },
+      );
+    });
+
+    group('Platform Compatibility', () {
+      test('mobile platform is included in all platform values', () {
+        final allPlatforms = ZcashParamsPlatform.values;
+
+        expect(allPlatforms, contains(ZcashParamsPlatform.mobile));
+        expect(
+          allPlatforms.length,
+          greaterThanOrEqualTo(4),
+        ); // web, windows, mobile, unix
+      });
+
+      test('mobile platform factory method works with all parameters', () {
+        // Test with all optional parameters
+        final downloader = ZcashParamsDownloaderFactory.createForPlatform(
+          ZcashParamsPlatform.mobile,
+          downloadService: null, // Should use default
+          config: null, // Should use default
+          enableHashValidation: false, // Should be passed through
+        );
+
+        expect(downloader, isA<MobileZcashParamsDownloader>());
+
+        // Clean up
+        downloader.dispose();
+      });
+
+      test('multiple mobile downloaders can be created independently', () {
+        when(
+          () => mockPathProvider.getApplicationDocumentsPath(),
+        ).thenAnswer((_) async => '/test/documents');
+
+        final downloader1 = ZcashParamsDownloaderFactory.createForPlatform(
+          ZcashParamsPlatform.mobile,
+        );
+        final downloader2 = ZcashParamsDownloaderFactory.createForPlatform(
+          ZcashParamsPlatform.mobile,
+        );
+
+        expect(downloader1, isA<MobileZcashParamsDownloader>());
+        expect(downloader2, isA<MobileZcashParamsDownloader>());
+        expect(downloader1, isNot(same(downloader2)));
+
+        // Clean up
+        downloader1.dispose();
+        downloader2.dispose();
+      });
+    });
+
+    group('Error Scenarios', () {
+      test('handles path provider returning empty string', () async {
+        when(
+          () => mockPathProvider.getApplicationDocumentsPath(),
+        ).thenAnswer((_) async => '');
+
+        final downloader =
+            ZcashParamsDownloaderFactory.createForPlatform(
+                  ZcashParamsPlatform.mobile,
+                )
+                as MobileZcashParamsDownloader;
+
+        final paramsPath = await downloader.getParamsPath();
+
+        // Should still create a valid path even with empty base
+        expect(paramsPath, equals('ZcashParams'));
+
+        // Clean up
+        downloader.dispose();
+      });
+
+      test('handles path provider returning null-like values', () async {
+        // Test with various problematic return values
+        final problematicPaths = [
+          () => throw StateError('No documents directory available'),
+          () => throw ArgumentError('Invalid path'),
+          () => throw const FileSystemException('Permission denied', '/path'),
+        ];
+
+        for (final pathProvider in problematicPaths) {
+          when(
+            () => mockPathProvider.getApplicationDocumentsPath(),
+          ).thenAnswer((_) async => pathProvider());
+
+          final downloader =
+              ZcashParamsDownloaderFactory.createForPlatform(
+                    ZcashParamsPlatform.mobile,
+                  )
+                  as MobileZcashParamsDownloader;
+
+          final paramsPath = await downloader.getParamsPath();
+          expect(paramsPath, isNull);
+
+          // Clean up
+          downloader.dispose();
+        }
+      });
+
+      test(
+        'disposed downloader continues to work for basic operations',
+        () async {
+          when(
+            () => mockPathProvider.getApplicationDocumentsPath(),
+          ).thenAnswer((_) async => '/test/documents');
+
+          final downloader =
+              ZcashParamsDownloaderFactory.createForPlatform(
+                    ZcashParamsPlatform.mobile,
+                  )
+                  as MobileZcashParamsDownloader;
+
+          // Dispose the downloader
+          downloader.dispose();
+
+          // Basic operations should still work
+          final paramsPath = await downloader.getParamsPath();
+          expect(paramsPath, isNotNull);
+
+          // Multiple dispose calls should be safe
+          expect(() => downloader.dispose(), returnsNormally);
+          expect(() => downloader.dispose(), returnsNormally);
+        },
+      );
+    });
+
+    group('Performance and Resource Management', () {
+      test('creating many mobile downloaders does not leak resources', () {
+        when(
+          () => mockPathProvider.getApplicationDocumentsPath(),
+        ).thenAnswer((_) async => '/test/documents');
+
+        final downloaders = <MobileZcashParamsDownloader>[];
+
+        // Create many downloaders
+        for (int i = 0; i < 100; i++) {
+          final downloader =
+              ZcashParamsDownloaderFactory.createForPlatform(
+                    ZcashParamsPlatform.mobile,
+                  )
+                  as MobileZcashParamsDownloader;
+          downloaders.add(downloader);
+        }
+
+        expect(downloaders.length, equals(100));
+
+        // All should be different instances
+        for (int i = 0; i < downloaders.length; i++) {
+          for (int j = i + 1; j < downloaders.length; j++) {
+            expect(downloaders[i], isNot(same(downloaders[j])));
+          }
+        }
+
+        // Clean up all
+        for (final downloader in downloaders) {
+          expect(() => downloader.dispose(), returnsNormally);
+        }
+      });
+
+      test('path provider is called efficiently', () async {
+        when(
+          () => mockPathProvider.getApplicationDocumentsPath(),
+        ).thenAnswer((_) async => '/test/documents');
+
+        final downloader =
+            ZcashParamsDownloaderFactory.createForPlatform(
+                  ZcashParamsPlatform.mobile,
+                )
+                as MobileZcashParamsDownloader;
+
+        // Make multiple calls to getParamsPath
+        await downloader.getParamsPath();
+        await downloader.getParamsPath();
+        await downloader.getParamsPath();
+
+        // Path provider should be called each time (no caching in this implementation)
+        verify(() => mockPathProvider.getApplicationDocumentsPath()).called(3);
+
+        // Clean up
+        downloader.dispose();
+      });
+    });
+  });
+}
diff --git a/packages/komodo_defi_sdk/test/zcash_params/models/download_progress_test.dart b/packages/komodo_defi_sdk/test/zcash_params/models/download_progress_test.dart
new file mode 100644
index 000000000..2718c1a80
--- /dev/null
+++ b/packages/komodo_defi_sdk/test/zcash_params/models/download_progress_test.dart
@@ -0,0 +1,359 @@
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_progress.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('DownloadProgress', () {
+    group('constructor', () {
+      test('creates instance with all parameters', () {
+        const progress = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 500,
+          total: 1000,
+        );
+
+        expect(progress.fileName, equals('test.params'));
+        expect(progress.downloaded, equals(500));
+        expect(progress.total, equals(1000));
+      });
+
+      test('creates instance with zero values', () {
+        const progress = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 0,
+          total: 0,
+        );
+
+        expect(progress.fileName, equals('test.params'));
+        expect(progress.downloaded, equals(0));
+        expect(progress.total, equals(0));
+      });
+    });
+
+    group('percentage', () {
+      test('calculates correct percentage for normal values', () {
+        const progress = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 500,
+          total: 1000,
+        );
+
+        expect(progress.percentage, equals(50.0));
+      });
+
+      test('returns 100% when downloaded equals total', () {
+        const progress = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 1000,
+          total: 1000,
+        );
+
+        expect(progress.percentage, equals(100.0));
+      });
+
+      test('returns 0% when total is zero', () {
+        const progress = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 100,
+          total: 0,
+        );
+
+        expect(progress.percentage, equals(0.0));
+      });
+
+      test('returns 0% when total is negative', () {
+        const progress = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 100,
+          total: -1000,
+        );
+
+        expect(progress.percentage, equals(0.0));
+      });
+
+      test('handles fractional percentages', () {
+        const progress = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 333,
+          total: 1000,
+        );
+
+        expect(progress.percentage, closeTo(33.3, 0.1));
+      });
+
+      test('can exceed 100% if downloaded > total', () {
+        const progress = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 1500,
+          total: 1000,
+        );
+
+        expect(progress.percentage, equals(150.0));
+      });
+    });
+
+    group('isComplete', () {
+      test('returns true when downloaded equals total', () {
+        const progress = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 1000,
+          total: 1000,
+        );
+
+        expect(progress.isComplete, isTrue);
+      });
+
+      test('returns true when downloaded exceeds total', () {
+        const progress = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 1500,
+          total: 1000,
+        );
+
+        expect(progress.isComplete, isTrue);
+      });
+
+      test('returns false when downloaded is less than total', () {
+        const progress = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 500,
+          total: 1000,
+        );
+
+        expect(progress.isComplete, isFalse);
+      });
+
+      test('returns true when both are zero', () {
+        const progress = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 0,
+          total: 0,
+        );
+
+        expect(progress.isComplete, isTrue);
+      });
+    });
+
+    group('displayText', () {
+      test('formats display text correctly for normal values', () {
+        const progress = DownloadProgress(
+          fileName: 'sapling-spend.params',
+          downloaded: 50 * 1024 * 1024, // 50 MB
+          total: 100 * 1024 * 1024, // 100 MB
+        );
+
+        expect(
+          progress.displayText,
+          equals('sapling-spend.params: 50.0% (50.0/100.0 MB)'),
+        );
+      });
+
+      test('formats display text for partial MB values', () {
+        const progress = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 1536 * 1024, // 1.5 MB
+          total: 3 * 1024 * 1024, // 3 MB
+        );
+
+        expect(progress.displayText, equals('test.params: 50.0% (1.5/3.0 MB)'));
+      });
+
+      test('formats display text for small files', () {
+        const progress = DownloadProgress(
+          fileName: 'small.params',
+          downloaded: 512 * 1024, // 0.5 MB
+          total: 1024 * 1024, // 1 MB
+        );
+
+        expect(
+          progress.displayText,
+          equals('small.params: 50.0% (0.5/1.0 MB)'),
+        );
+      });
+
+      test('handles zero total size', () {
+        const progress = DownloadProgress(
+          fileName: 'unknown.params',
+          downloaded: 1024 * 1024, // 1 MB
+          total: 0,
+        );
+
+        expect(
+          progress.displayText,
+          equals('unknown.params: 0.0% (1.0/0.0 MB)'),
+        );
+      });
+    });
+
+    group('toString', () {
+      test('returns formatted string representation', () {
+        const progress = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 500,
+          total: 1000,
+        );
+
+        final str = progress.toString();
+        expect(str, contains('DownloadProgress'));
+        expect(str, contains('test.params'));
+        expect(str, contains('500'));
+        expect(str, contains('1000'));
+      });
+
+      test('handles zero values', () {
+        const progress = DownloadProgress(
+          fileName: 'empty.params',
+          downloaded: 0,
+          total: 0,
+        );
+
+        final str = progress.toString();
+        expect(str, contains('DownloadProgress'));
+        expect(str, contains('empty.params'));
+        expect(str, contains('0'));
+      });
+    });
+
+    group('equality', () {
+      test('returns true for identical progress objects', () {
+        const progress1 = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 500,
+          total: 1000,
+        );
+        const progress2 = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 500,
+          total: 1000,
+        );
+
+        expect(progress1, equals(progress2));
+        expect(progress1.hashCode, equals(progress2.hashCode));
+      });
+
+      test('returns false for different file names', () {
+        const progress1 = DownloadProgress(
+          fileName: 'test1.params',
+          downloaded: 500,
+          total: 1000,
+        );
+        const progress2 = DownloadProgress(
+          fileName: 'test2.params',
+          downloaded: 500,
+          total: 1000,
+        );
+
+        expect(progress1, isNot(equals(progress2)));
+      });
+
+      test('returns false for different downloaded values', () {
+        const progress1 = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 500,
+          total: 1000,
+        );
+        const progress2 = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 600,
+          total: 1000,
+        );
+
+        expect(progress1, isNot(equals(progress2)));
+      });
+
+      test('returns false for different total values', () {
+        const progress1 = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 500,
+          total: 1000,
+        );
+        const progress2 = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 500,
+          total: 2000,
+        );
+
+        expect(progress1, isNot(equals(progress2)));
+      });
+
+      test('returns true for same instance', () {
+        const progress = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 500,
+          total: 1000,
+        );
+
+        expect(progress, equals(progress));
+      });
+
+      test('returns false for different types', () {
+        const progress = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: 500,
+          total: 1000,
+        );
+
+        expect(progress, isNot(equals('not a progress object')));
+      });
+    });
+
+    group('edge cases', () {
+      test('handles empty file name', () {
+        const progress = DownloadProgress(
+          fileName: '',
+          downloaded: 500,
+          total: 1000,
+        );
+
+        expect(progress.fileName, equals(''));
+        expect(progress.percentage, equals(50.0));
+      });
+
+      test('handles very large file sizes', () {
+        const progress = DownloadProgress(
+          fileName: 'huge.params',
+          downloaded: 1024 * 1024 * 1024 * 5, // 5 GB
+          total: 1024 * 1024 * 1024 * 10, // 10 GB
+        );
+
+        expect(progress.percentage, equals(50.0));
+        expect(progress.isComplete, isFalse);
+      });
+
+      test('handles negative downloaded value', () {
+        const progress = DownloadProgress(
+          fileName: 'test.params',
+          downloaded: -100,
+          total: 1000,
+        );
+
+        expect(progress.percentage, equals(-10.0));
+        expect(progress.isComplete, isFalse);
+      });
+
+      test('handles very long file name', () {
+        final longFileName = 'very-long-file-name' * 10 + '.params';
+        final progress = DownloadProgress(
+          fileName: longFileName,
+          downloaded: 500,
+          total: 1000,
+        );
+
+        expect(progress.fileName, equals(longFileName));
+        expect(progress.percentage, equals(50.0));
+      });
+    });
+
+    group('JSON serialization', () {
+      test('JSON round-trip', () {
+        const original = DownloadProgress(
+          fileName: 'a.params',
+          downloaded: 42,
+          total: 100,
+        );
+        final json = original.toJson();
+        final restored = DownloadProgress.fromJson(json);
+        expect(restored, equals(original));
+      });
+    });
+  });
+}
diff --git a/packages/komodo_defi_sdk/test/zcash_params/models/download_result_test.dart b/packages/komodo_defi_sdk/test/zcash_params/models/download_result_test.dart
new file mode 100644
index 000000000..955c6a1c2
--- /dev/null
+++ b/packages/komodo_defi_sdk/test/zcash_params/models/download_result_test.dart
@@ -0,0 +1,291 @@
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_result.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('DownloadResult', () {
+    group('success constructor', () {
+      test('creates successful result with path', () {
+        const result = DownloadResult.success(paramsPath: '/test/path');
+
+        expect(result, isA<DownloadResultSuccess>());
+        result.when(
+          success: (paramsPath) {
+            expect(paramsPath, equals('/test/path'));
+          },
+          failure: (error) {
+            fail('Expected success but got failure');
+          },
+        );
+      });
+
+      test('creates successful result with empty path', () {
+        const result = DownloadResult.success(paramsPath: '');
+
+        expect(result, isA<DownloadResultSuccess>());
+        result.when(
+          success: (paramsPath) {
+            expect(paramsPath, equals(''));
+          },
+          failure: (error) {
+            fail('Expected success but got failure');
+          },
+        );
+      });
+    });
+
+    group('failure constructor', () {
+      test('creates failed result with error message', () {
+        const result = DownloadResult.failure(error: 'Download failed');
+
+        expect(result, isA<DownloadResultFailure>());
+        result.when(
+          success: (paramsPath) {
+            fail('Expected failure but got success');
+          },
+          failure: (error) {
+            expect(error, equals('Download failed'));
+          },
+        );
+      });
+
+      test('creates failed result with empty error', () {
+        const result = DownloadResult.failure(error: '');
+
+        expect(result, isA<DownloadResultFailure>());
+        result.when(
+          success: (paramsPath) {
+            fail('Expected failure but got success');
+          },
+          failure: (error) {
+            expect(error, equals(''));
+          },
+        );
+      });
+    });
+
+    group('pattern matching', () {
+      test('when method works correctly for success', () {
+        const result = DownloadResult.success(paramsPath: '/test/path');
+
+        final output = result.when(
+          success: (paramsPath) => 'Success: $paramsPath',
+          failure: (error) => 'Failure: $error',
+        );
+
+        expect(output, equals('Success: /test/path'));
+      });
+
+      test('when method works correctly for failure', () {
+        const result = DownloadResult.failure(error: 'Test error');
+
+        final output = result.when(
+          success: (paramsPath) => 'Success: $paramsPath',
+          failure: (error) => 'Failure: $error',
+        );
+
+        expect(output, equals('Failure: Test error'));
+      });
+
+      test('maybeWhen method works correctly', () {
+        const result = DownloadResult.success(paramsPath: '/test/path');
+
+        final output = result.maybeWhen(
+          success: (paramsPath) => 'Success: $paramsPath',
+          orElse: () => 'Unknown',
+        );
+
+        expect(output, equals('Success: /test/path'));
+      });
+
+      test('map method works correctly', () {
+        const result = DownloadResult.success(paramsPath: '/test/path');
+
+        final output = result.map(
+          success: (success) => 'Success with path: ${success.paramsPath}',
+          failure: (failure) => 'Failure with error: ${failure.error}',
+        );
+
+        expect(output, equals('Success with path: /test/path'));
+      });
+    });
+
+    group('copyWith', () {
+      test('copyWith works for success result', () {
+        const original = DownloadResult.success(paramsPath: '/original/path');
+
+        original.map(
+          success: (successResult) {
+            final copied = successResult.copyWith();
+            expect(copied, equals(successResult));
+            expect(identical(copied, successResult), isFalse);
+            return null;
+          },
+          failure: (_) {
+            fail('Expected success but got failure');
+            return null;
+          },
+        );
+      });
+
+      test('copyWith works for failure result', () {
+        const original = DownloadResult.failure(error: 'Original error');
+
+        original.map(
+          success: (_) {
+            fail('Expected failure but got success');
+            return null;
+          },
+          failure: (failureResult) {
+            final copied = failureResult.copyWith();
+            expect(copied, equals(failureResult));
+            expect(identical(copied, failureResult), isFalse);
+            return null;
+          },
+        );
+      });
+    });
+
+    group('equality and hashCode', () {
+      test('returns true for identical successful results', () {
+        const result1 = DownloadResult.success(paramsPath: '/test/path');
+        const result2 = DownloadResult.success(paramsPath: '/test/path');
+
+        expect(result1, equals(result2));
+        expect(result1.hashCode, equals(result2.hashCode));
+      });
+
+      test('returns true for identical failed results', () {
+        const result1 = DownloadResult.failure(error: 'Test error');
+        const result2 = DownloadResult.failure(error: 'Test error');
+
+        expect(result1, equals(result2));
+        expect(result1.hashCode, equals(result2.hashCode));
+      });
+
+      test('returns false for success vs failure', () {
+        const result1 = DownloadResult.success(paramsPath: '/test/path');
+        const result2 = DownloadResult.failure(error: 'Test error');
+
+        expect(result1, isNot(equals(result2)));
+      });
+
+      test('returns false for different paths', () {
+        const result1 = DownloadResult.success(paramsPath: '/test/path1');
+        const result2 = DownloadResult.success(paramsPath: '/test/path2');
+
+        expect(result1, isNot(equals(result2)));
+      });
+
+      test('returns false for different errors', () {
+        const result1 = DownloadResult.failure(error: 'Error 1');
+        const result2 = DownloadResult.failure(error: 'Error 2');
+
+        expect(result1, isNot(equals(result2)));
+      });
+
+      test('returns true for same instance', () {
+        const result = DownloadResult.success(paramsPath: '/test/path');
+
+        expect(result, equals(result));
+      });
+
+      test('returns false for different types', () {
+        const result = DownloadResult.success(paramsPath: '/test/path');
+
+        expect(result, isNot(equals('not a download result')));
+      });
+    });
+
+    group('JSON serialization', () {
+      test('can serialize and deserialize success result', () {
+        const original = DownloadResult.success(paramsPath: '/test/path');
+        final json = original.toJson();
+        final deserialized = DownloadResult.fromJson(json);
+
+        expect(deserialized, equals(original));
+      });
+
+      test('can serialize and deserialize failure result', () {
+        const original = DownloadResult.failure(error: 'Test error');
+        final json = original.toJson();
+        final deserialized = DownloadResult.fromJson(json);
+
+        expect(deserialized, equals(original));
+      });
+    });
+
+    group('toString', () {
+      test('returns meaningful string for success', () {
+        const result = DownloadResult.success(paramsPath: '/test/path');
+        final str = result.toString();
+
+        expect(str, contains('DownloadResult'));
+        expect(str, contains('/test/path'));
+      });
+
+      test('returns meaningful string for failure', () {
+        const result = DownloadResult.failure(error: 'Test error');
+        final str = result.toString();
+
+        expect(str, contains('DownloadResult'));
+        expect(str, contains('Test error'));
+      });
+    });
+
+    group('edge cases', () {
+      test('handles very long path', () {
+        final longPath = '/very/long/path' * 100;
+        final result = DownloadResult.success(paramsPath: longPath)
+          ..when(
+            success: (paramsPath) {
+              expect(paramsPath, equals(longPath));
+            },
+            failure: (error) {
+              fail('Expected success but got failure');
+            },
+          );
+      });
+
+      test('handles very long error message', () {
+        final longError = 'Very long error message ' * 100;
+        final result = DownloadResult.failure(error: longError)
+          ..when(
+            success: (paramsPath) {
+              fail('Expected failure but got success');
+            },
+            failure: (error) {
+              expect(error, equals(longError));
+            },
+          );
+      });
+
+      test('handles unicode characters in path', () {
+        const unicodePath = '/test/ñáéíóú/中文/🚀/path';
+        const result = DownloadResult.success(paramsPath: unicodePath);
+
+        result..when(
+          success: (paramsPath) {
+            expect(paramsPath, equals(unicodePath));
+          },
+          failure: (error) {
+            fail('Expected success but got failure');
+          },
+        );
+      });
+
+      test('handles unicode characters in error', () {
+        const unicodeError = 'Error with ñáéíóú and 中文 and 🚀';
+        const result = DownloadResult.failure(error: unicodeError);
+
+        result.when(
+          success: (paramsPath) {
+            fail('Expected failure but got success');
+          },
+          failure: (error) {
+            expect(error, equals(unicodeError));
+          },
+        );
+      });
+    });
+  });
+}
diff --git a/packages/komodo_defi_sdk/test/zcash_params/models/zcash_params_config_test.dart b/packages/komodo_defi_sdk/test/zcash_params/models/zcash_params_config_test.dart
new file mode 100644
index 000000000..b82535dac
--- /dev/null
+++ b/packages/komodo_defi_sdk/test/zcash_params/models/zcash_params_config_test.dart
@@ -0,0 +1,565 @@
+import 'package:komodo_defi_sdk/src/zcash_params/models/zcash_params_config.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('ZcashParamFile', () {
+    group('constructor', () {
+      test('creates instance with all parameters', () {
+        const file = ZcashParamFile(
+          fileName: 'test.params',
+          sha256Hash: 'abc123',
+          expectedSize: 1024,
+        );
+
+        expect(file.fileName, equals('test.params'));
+        expect(file.sha256Hash, equals('abc123'));
+        expect(file.expectedSize, equals(1024));
+      });
+
+      test('creates instance without expected size', () {
+        const file = ZcashParamFile(
+          fileName: 'test.params',
+          sha256Hash: 'abc123',
+        );
+
+        expect(file.fileName, equals('test.params'));
+        expect(file.sha256Hash, equals('abc123'));
+        expect(file.expectedSize, isNull);
+      });
+    });
+
+    group('JSON serialization', () {
+      test('can serialize and deserialize', () {
+        const original = ZcashParamFile(
+          fileName: 'test.params',
+          sha256Hash: 'abc123',
+          expectedSize: 1024,
+        );
+
+        final json = original.toJson();
+        final deserialized = ZcashParamFile.fromJson(json);
+
+        expect(deserialized, equals(original));
+      });
+
+      test('handles null expected size', () {
+        const original = ZcashParamFile(
+          fileName: 'test.params',
+          sha256Hash: 'abc123',
+        );
+
+        final json = original.toJson();
+        final deserialized = ZcashParamFile.fromJson(json);
+
+        expect(deserialized, equals(original));
+        expect(deserialized.expectedSize, isNull);
+      });
+    });
+
+    group('equality', () {
+      test('returns true for identical files', () {
+        const file1 = ZcashParamFile(
+          fileName: 'test.params',
+          sha256Hash: 'abc123',
+          expectedSize: 1024,
+        );
+        const file2 = ZcashParamFile(
+          fileName: 'test.params',
+          sha256Hash: 'abc123',
+          expectedSize: 1024,
+        );
+
+        expect(file1, equals(file2));
+        expect(file1.hashCode, equals(file2.hashCode));
+      });
+
+      test('returns false for different files', () {
+        const file1 = ZcashParamFile(
+          fileName: 'test1.params',
+          sha256Hash: 'abc123',
+        );
+        const file2 = ZcashParamFile(
+          fileName: 'test2.params',
+          sha256Hash: 'abc123',
+        );
+
+        expect(file1, isNot(equals(file2)));
+      });
+    });
+
+    group('copyWith', () {
+      test('creates copy with modifications', () {
+        const original = ZcashParamFile(
+          fileName: 'test.params',
+          sha256Hash: 'abc123',
+          expectedSize: 1024,
+        );
+
+        final copied = original.copyWith(fileName: 'modified.params');
+
+        expect(copied.fileName, equals('modified.params'));
+        expect(copied.sha256Hash, equals('abc123'));
+        expect(copied.expectedSize, equals(1024));
+        expect(copied, isNot(equals(original)));
+      });
+    });
+  });
+
+  group('ZcashParamsConfig', () {
+    late ZcashParamsConfig config;
+
+    setUp(() {
+      config = ZcashParamsConfig.defaultConfig;
+    });
+
+    group('constructor', () {
+      test('creates instance with all parameters', () {
+        expect(
+          config.primaryUrl,
+          equals('https://komodoplatform.com/downloads/'),
+        );
+        expect(config.backupUrl, equals('https://z.cash/downloads/'));
+        expect(config.downloadTimeoutSeconds, equals(1800));
+        expect(config.maxRetries, equals(3));
+        expect(config.retryDelaySeconds, equals(5));
+        expect(config.downloadBufferSize, equals(1048576));
+        expect(config.paramFiles.length, equals(2));
+      });
+
+      test('creates instance with custom values', () {
+        const customConfig = ZcashParamsConfig(
+          paramFiles: [],
+          primaryUrl: 'https://custom.com/',
+          backupUrl: 'https://backup.com/',
+          downloadTimeoutSeconds: 3600,
+          maxRetries: 5,
+          retryDelaySeconds: 10,
+          downloadBufferSize: 2097152,
+        );
+
+        expect(customConfig.primaryUrl, equals('https://custom.com/'));
+        expect(customConfig.backupUrl, equals('https://backup.com/'));
+        expect(customConfig.downloadTimeoutSeconds, equals(3600));
+        expect(customConfig.maxRetries, equals(5));
+        expect(customConfig.retryDelaySeconds, equals(10));
+        expect(customConfig.downloadBufferSize, equals(2097152));
+        expect(customConfig.paramFiles, isEmpty);
+      });
+    });
+
+    group('default configuration', () {
+      test('has correct default values', () {
+        expect(
+          ZcashParamsConfig.defaultConfig.primaryUrl,
+          equals('https://komodoplatform.com/downloads/'),
+        );
+        expect(
+          ZcashParamsConfig.defaultConfig.backupUrl,
+          equals('https://z.cash/downloads/'),
+        );
+        expect(ZcashParamsConfig.defaultConfig.paramFiles.length, equals(2));
+      });
+
+      test('has all required parameter files', () {
+        final fileNames = ZcashParamsConfig.defaultConfig.fileNames;
+        expect(fileNames, contains('sapling-spend.params'));
+        expect(fileNames, contains('sapling-output.params'));
+      });
+
+      test('does not include sprout-groth16.params', () {
+        final fileNames = ZcashParamsConfig.defaultConfig.fileNames;
+        expect(fileNames, isNot(contains('sprout-groth16.params')));
+      });
+
+      test('all parameter files have hashes', () {
+        for (final file in ZcashParamsConfig.defaultConfig.paramFiles) {
+          expect(file.sha256Hash, isNotEmpty);
+          expect(file.sha256Hash.length, equals(64)); // SHA256 is 64 hex chars
+        }
+      });
+    });
+
+    group('extended configuration', () {
+      test('has correct default values', () {
+        expect(
+          ZcashParamsConfig.extendedConfig.primaryUrl,
+          equals('https://komodoplatform.com/downloads/'),
+        );
+        expect(
+          ZcashParamsConfig.extendedConfig.backupUrl,
+          equals('https://z.cash/downloads/'),
+        );
+        expect(ZcashParamsConfig.extendedConfig.paramFiles.length, equals(3));
+      });
+
+      test('has all parameter files including sprout', () {
+        final fileNames = ZcashParamsConfig.extendedConfig.fileNames;
+        expect(fileNames, contains('sapling-spend.params'));
+        expect(fileNames, contains('sapling-output.params'));
+        expect(fileNames, contains('sprout-groth16.params'));
+      });
+
+      test('all parameter files have hashes', () {
+        for (final file in ZcashParamsConfig.extendedConfig.paramFiles) {
+          expect(file.sha256Hash, isNotEmpty);
+          expect(file.sha256Hash.length, equals(64)); // SHA256 is 64 hex chars
+        }
+      });
+
+      test('fileNames returns correct list', () {
+        expect(
+          ZcashParamsConfig.extendedConfig.fileNames,
+          equals([
+            'sapling-spend.params',
+            'sapling-output.params',
+            'sprout-groth16.params',
+          ]),
+        );
+      });
+
+      test('totalExpectedSize calculates correctly', () {
+        final expectedTotal = ZcashParamsConfig.extendedConfig.paramFiles
+            .where((file) => file.expectedSize != null)
+            .fold(0, (sum, file) => sum + file.expectedSize!);
+
+        expect(
+          ZcashParamsConfig.extendedConfig.totalExpectedSize,
+          equals(expectedTotal),
+        );
+        expect(
+          ZcashParamsConfig.extendedConfig.totalExpectedSize,
+          greaterThan(700 * 1024 * 1024),
+        ); // > 700MB
+      });
+    });
+
+    group('computed properties', () {
+      test('downloadUrls returns correct list', () {
+        expect(
+          config.downloadUrls,
+          equals([
+            'https://komodoplatform.com/downloads/',
+            'https://z.cash/downloads/',
+          ]),
+        );
+      });
+
+      test('fileNames returns correct list', () {
+        expect(
+          config.fileNames,
+          equals(['sapling-spend.params', 'sapling-output.params']),
+        );
+      });
+
+      test('downloadTimeout returns correct duration', () {
+        expect(config.downloadTimeout, equals(const Duration(seconds: 1800)));
+      });
+
+      test('retryDelay returns correct duration', () {
+        expect(config.retryDelay, equals(const Duration(seconds: 5)));
+      });
+
+      test('totalExpectedSize calculates correctly', () {
+        final expectedTotal = config.paramFiles
+            .where((file) => file.expectedSize != null)
+            .fold(0, (sum, file) => sum + file.expectedSize!);
+
+        expect(config.totalExpectedSize, equals(expectedTotal));
+      });
+    });
+
+    group('getParamFile', () {
+      test('returns correct file for known file names', () {
+        final file = config.getParamFile('sapling-spend.params');
+        expect(file, isNotNull);
+        expect(file!.fileName, equals('sapling-spend.params'));
+        expect(
+          file.sha256Hash,
+          equals(
+            '8e48ffd23abb3a5fd9c5589204f32d9c31285a04b78096ba40a79b75677efc13',
+          ),
+        );
+      });
+
+      test('returns null for unknown file names', () {
+        final file = config.getParamFile('unknown.params');
+        expect(file, isNull);
+      });
+
+      test('returns null for empty string', () {
+        final file = config.getParamFile('');
+        expect(file, isNull);
+      });
+
+      test('is case sensitive', () {
+        final file = config.getParamFile('SAPLING-SPEND.PARAMS');
+        expect(file, isNull);
+      });
+    });
+
+    group('getExpectedFileSize', () {
+      test('returns correct size for known files', () {
+        final size = config.getExpectedFileSize('sapling-spend.params');
+        expect(size, equals(47958396));
+      });
+
+      test('returns null for unknown files', () {
+        final size = config.getExpectedFileSize('unknown.params');
+        expect(size, isNull);
+      });
+
+      test('returns null for files without expected size', () {
+        const configWithoutSize = ZcashParamsConfig(
+          paramFiles: [
+            ZcashParamFile(fileName: 'test.params', sha256Hash: 'abc123'),
+          ],
+        );
+
+        final size = configWithoutSize.getExpectedFileSize('test.params');
+        expect(size, isNull);
+      });
+    });
+
+    group('getExpectedHash', () {
+      test('returns correct hash for known files', () {
+        final hash = config.getExpectedHash('sapling-spend.params');
+        expect(
+          hash,
+          equals(
+            '8e48ffd23abb3a5fd9c5589204f32d9c31285a04b78096ba40a79b75677efc13',
+          ),
+        );
+      });
+
+      test('returns null for unknown files', () {
+        final hash = config.getExpectedHash('unknown.params');
+        expect(hash, isNull);
+      });
+
+      test('returns null for empty file name', () {
+        final hash = config.getExpectedHash('');
+        expect(hash, isNull);
+      });
+    });
+
+    group('isValidFileName', () {
+      test('returns true for all known file names', () {
+        for (final fileName in config.fileNames) {
+          expect(
+            config.isValidFileName(fileName),
+            isTrue,
+            reason: '$fileName should be valid',
+          );
+        }
+      });
+
+      test('returns false for unknown file names', () {
+        expect(config.isValidFileName('unknown.params'), isFalse);
+        expect(config.isValidFileName('test.txt'), isFalse);
+        expect(config.isValidFileName(''), isFalse);
+      });
+
+      test('is case sensitive', () {
+        expect(config.isValidFileName('SAPLING-SPEND.PARAMS'), isFalse);
+        expect(config.isValidFileName('Sapling-Spend.Params'), isFalse);
+      });
+    });
+
+    group('getFileUrl', () {
+      test('constructs correct URL with trailing slash', () {
+        const baseUrl = 'https://example.com/';
+        const fileName = 'test.params';
+
+        final url = config.getFileUrl(baseUrl, fileName);
+        expect(url, equals('https://example.com/test.params'));
+      });
+
+      test('adds trailing slash when missing', () {
+        const baseUrl = 'https://example.com';
+        const fileName = 'test.params';
+
+        final url = config.getFileUrl(baseUrl, fileName);
+        expect(url, equals('https://example.com/test.params'));
+      });
+
+      test('works with primary URL', () {
+        const fileName = 'sapling-spend.params';
+
+        final url = config.getFileUrl(config.primaryUrl, fileName);
+        expect(
+          url,
+          equals('https://komodoplatform.com/downloads/sapling-spend.params'),
+        );
+      });
+
+      test('works with backup URL', () {
+        const fileName = 'sapling-output.params';
+
+        final url = config.getFileUrl(config.backupUrl, fileName);
+        expect(url, equals('https://z.cash/downloads/sapling-output.params'));
+      });
+
+      test('handles empty file name', () {
+        const baseUrl = 'https://example.com/';
+        const fileName = '';
+
+        final url = config.getFileUrl(baseUrl, fileName);
+        expect(url, equals('https://example.com/'));
+      });
+
+      test('handles multiple trailing slashes', () {
+        const baseUrl = 'https://example.com///';
+        const fileName = 'test.params';
+
+        final url = config.getFileUrl(baseUrl, fileName);
+        expect(url, equals('https://example.com///test.params'));
+      });
+    });
+
+    // TODO: Fix JSON serialization for nested objects
+    // group('JSON serialization', () {
+    //   test('can serialize and deserialize complete config', () {
+    //     final json = config.toJson();
+    //     final deserialized = ZcashParamsConfig.fromJson(json);
+
+    //     expect(deserialized, equals(config));
+    //     expect(
+    //       deserialized.paramFiles.length,
+    //       equals(config.paramFiles.length),
+    //     );
+
+    //     for (int i = 0; i < config.paramFiles.length; i++) {
+    //       expect(deserialized.paramFiles[i], equals(config.paramFiles[i]));
+    //     }
+    //   });
+
+    //   test('handles empty param files list', () {
+    //     const emptyConfig = ZcashParamsConfig(paramFiles: []);
+    //     final json = emptyConfig.toJson();
+    //     final deserialized = ZcashParamsConfig.fromJson(json);
+
+    //     expect(deserialized, equals(emptyConfig));
+    //     expect(deserialized.paramFiles, isEmpty);
+    //   });
+    // });
+
+    group('equality and hashCode', () {
+      test('returns true for identical configs', () {
+        final config2 = ZcashParamsConfig(
+          paramFiles: config.paramFiles,
+          primaryUrl: config.primaryUrl,
+          backupUrl: config.backupUrl,
+          downloadTimeoutSeconds: config.downloadTimeoutSeconds,
+          maxRetries: config.maxRetries,
+          retryDelaySeconds: config.retryDelaySeconds,
+          downloadBufferSize: config.downloadBufferSize,
+        );
+
+        expect(config2, equals(config));
+        expect(config2.hashCode, equals(config.hashCode));
+      });
+
+      test('returns false for different configs', () {
+        const config2 = ZcashParamsConfig(
+          paramFiles: [],
+          primaryUrl: 'https://different.com/',
+        );
+
+        expect(config2, isNot(equals(config)));
+      });
+    });
+
+    group('copyWith', () {
+      test('creates copy with modifications', () {
+        final copied = config.copyWith(primaryUrl: 'https://modified.com/');
+
+        expect(copied.primaryUrl, equals('https://modified.com/'));
+        expect(copied.backupUrl, equals(config.backupUrl));
+        expect(copied.paramFiles, equals(config.paramFiles));
+        expect(copied, isNot(equals(config)));
+      });
+
+      test('creates identical copy when no modifications', () {
+        final copied = config.copyWith();
+
+        expect(copied, equals(config));
+        expect(identical(copied, config), isFalse);
+      });
+    });
+
+    group('edge cases', () {
+      test('handles very long file names', () {
+        final longFileName = 'very-long-file-name' * 10 + '.params';
+        expect(config.isValidFileName(longFileName), isFalse);
+        expect(config.getExpectedFileSize(longFileName), isNull);
+      });
+
+      test('handles special characters in URLs', () {
+        const baseUrl = 'https://example.com/path with spaces/';
+        const fileName = 'test.params';
+
+        final url = config.getFileUrl(baseUrl, fileName);
+        expect(url, equals('https://example.com/path with spaces/test.params'));
+      });
+
+      test('validates all expected file sizes are reasonable', () {
+        for (final file in config.paramFiles) {
+          if (file.expectedSize != null) {
+            expect(
+              file.expectedSize,
+              greaterThan(1024 * 1024),
+              reason: '${file.fileName} should be at least 1MB',
+            );
+            expect(
+              file.expectedSize,
+              lessThan(1024 * 1024 * 1024),
+              reason: '${file.fileName} should be less than 1GB',
+            );
+          }
+        }
+      });
+
+      test('validates all hashes are correct format', () {
+        for (final file in config.paramFiles) {
+          expect(file.sha256Hash.length, equals(64));
+          expect(RegExp(r'^[a-f0-9]+$').hasMatch(file.sha256Hash), isTrue);
+        }
+      });
+    });
+
+    group('consistency checks', () {
+      test('all URLs are properly formatted', () {
+        for (final url in config.downloadUrls) {
+          expect(url.startsWith('https://'), isTrue);
+          expect(Uri.tryParse(url), isNotNull);
+        }
+      });
+
+      test('all file names have correct extension', () {
+        for (final fileName in config.fileNames) {
+          expect(
+            fileName.endsWith('.params'),
+            isTrue,
+            reason: 'File $fileName should have .params extension',
+          );
+        }
+      });
+
+      test('timeout values are reasonable', () {
+        expect(config.downloadTimeoutSeconds, greaterThan(0));
+        expect(config.downloadTimeoutSeconds, lessThan(7200)); // < 2 hours
+
+        expect(config.retryDelaySeconds, greaterThan(0));
+        expect(config.retryDelaySeconds, lessThan(60)); // < 1 minute
+
+        expect(config.maxRetries, greaterThan(0));
+        expect(config.maxRetries, lessThan(10));
+      });
+
+      test('buffer size is reasonable', () {
+        expect(config.downloadBufferSize, greaterThan(1024)); // > 1KB
+        expect(config.downloadBufferSize, lessThan(10 * 1024 * 1024)); // < 10MB
+      });
+    });
+  });
+}
diff --git a/packages/komodo_defi_sdk/test/zcash_params/platform_implementations/mobile_zcash_params_downloader_test.dart b/packages/komodo_defi_sdk/test/zcash_params/platform_implementations/mobile_zcash_params_downloader_test.dart
new file mode 100644
index 000000000..dd144a15e
--- /dev/null
+++ b/packages/komodo_defi_sdk/test/zcash_params/platform_implementations/mobile_zcash_params_downloader_test.dart
@@ -0,0 +1,460 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:flutter_test/flutter_test.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_progress.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_result.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/models/zcash_params_config.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/platforms/mobile_zcash_params_downloader.dart';
+import 'package:mocktail/mocktail.dart';
+import 'package:path_provider_platform_interface/path_provider_platform_interface.dart';
+import 'package:plugin_platform_interface/plugin_platform_interface.dart';
+
+import '../test_helpers/mock_classes.dart';
+
+class MockPathProviderPlatform extends Mock
+    with MockPlatformInterfaceMixin
+    implements PathProviderPlatform {}
+
+void main() {
+  group('MobileZcashParamsDownloader', () {
+    late MockZcashParamsDownloadService mockDownloadService;
+    late MockPathProviderPlatform mockPathProvider;
+    late MobileZcashParamsDownloader downloader;
+    late Directory testDirectory;
+    late File testFile;
+
+    const testDirectoryPath = '/test/documents/ZcashParams';
+    const testFilePath = '/test/documents/ZcashParams/test.params';
+    const testDocumentsPath = '/test/documents';
+
+    setUpAll(() {
+      registerFallbackValue(Directory(''));
+      registerFallbackValue(File(''));
+      registerFallbackValue(ZcashParamsConfig.defaultConfig);
+      registerFallbackValue(StreamController<DownloadProgress>());
+    });
+
+    setUp(() {
+      mockDownloadService = MockZcashParamsDownloadService();
+      mockPathProvider = MockPathProviderPlatform();
+      testDirectory = MockDirectory();
+      testFile = MockFile();
+
+      // Setup path provider mock
+      PathProviderPlatform.instance = mockPathProvider;
+      when(
+        () => mockPathProvider.getApplicationDocumentsPath(),
+      ).thenAnswer((_) async => testDocumentsPath);
+
+      downloader = MobileZcashParamsDownloader(
+        downloadService: mockDownloadService,
+        directoryFactory: (_) => testDirectory,
+        fileFactory: (_) => testFile,
+      );
+    });
+
+    tearDown(() {
+      downloader.dispose();
+    });
+
+    group('getParamsPath', () {
+      test('returns correct path in application documents directory', () async {
+        final path = await downloader.getParamsPath();
+
+        expect(path, equals(testDirectoryPath));
+        verify(() => mockPathProvider.getApplicationDocumentsPath()).called(1);
+      });
+
+      test('returns null when path provider throws exception', () async {
+        when(
+          () => mockPathProvider.getApplicationDocumentsPath(),
+        ).thenThrow(Exception('Path provider error'));
+
+        final path = await downloader.getParamsPath();
+
+        expect(path, isNull);
+      });
+    });
+
+    group('downloadParams', () {
+      setUp(() {
+        when(
+          () => mockDownloadService.ensureDirectoryExists(any(), any()),
+        ).thenAnswer((_) async {});
+
+        when(
+          () => mockDownloadService.getMissingFiles(any(), any(), any()),
+        ).thenAnswer((_) async => []);
+      });
+
+      test('succeeds when no files are missing', () async {
+        final result = await downloader.downloadParams();
+
+        expect(result, isA<DownloadResultSuccess>());
+        result.when(
+          success: (paramsPath) {
+            expect(paramsPath, equals(testDirectoryPath));
+          },
+          failure: (error) {
+            fail('Expected success but got failure: $error');
+          },
+        );
+
+        verify(
+          () => mockDownloadService.ensureDirectoryExists(
+            testDirectoryPath,
+            any(),
+          ),
+        ).called(1);
+
+        verify(
+          () => mockDownloadService.getMissingFiles(
+            testDirectoryPath,
+            any(),
+            any(),
+          ),
+        ).called(1);
+      });
+
+      test('downloads missing files successfully', () async {
+        const missingFiles = ['sapling-spend.params', 'sapling-output.params'];
+
+        when(
+          () => mockDownloadService.getMissingFiles(any(), any(), any()),
+        ).thenAnswer((_) async => missingFiles);
+
+        when(
+          () => mockDownloadService.downloadMissingFiles(
+            any(),
+            any(),
+            any(),
+            any(),
+            any(),
+          ),
+        ).thenAnswer((_) async => true);
+
+        final result = await downloader.downloadParams();
+
+        expect(result, isA<DownloadResultSuccess>());
+
+        verify(
+          () => mockDownloadService.downloadMissingFiles(
+            testDirectoryPath,
+            missingFiles,
+            any(),
+            any(),
+            any(),
+          ),
+        ).called(1);
+      });
+
+      test('fails when download service fails', () async {
+        const missingFiles = ['sapling-spend.params'];
+
+        when(
+          () => mockDownloadService.getMissingFiles(any(), any(), any()),
+        ).thenAnswer((_) async => missingFiles);
+
+        when(
+          () => mockDownloadService.downloadMissingFiles(
+            any(),
+            any(),
+            any(),
+            any(),
+            any(),
+          ),
+        ).thenAnswer((_) async => false);
+
+        final result = await downloader.downloadParams();
+
+        expect(result, isA<DownloadResultFailure>());
+        result.when(
+          success: (paramsPath) {
+            fail('Expected failure but got success: $paramsPath');
+          },
+          failure: (error) {
+            expect(
+              error,
+              equals('Failed to download one or more parameter files'),
+            );
+          },
+        );
+      });
+
+      test('fails when getParamsPath returns null', () async {
+        when(
+          () => mockPathProvider.getApplicationDocumentsPath(),
+        ).thenThrow(Exception('Path error'));
+
+        final result = await downloader.downloadParams();
+
+        expect(result, isA<DownloadResultFailure>());
+        result.when(
+          success: (paramsPath) {
+            fail('Expected failure but got success: $paramsPath');
+          },
+          failure: (error) {
+            expect(error, equals('Unable to determine parameters path'));
+          },
+        );
+      });
+
+      test('prevents concurrent downloads', () async {
+        when(
+          () => mockDownloadService.getMissingFiles(any(), any(), any()),
+        ).thenAnswer((_) async {
+          // Simulate slow operation
+          await Future<void>.delayed(const Duration(milliseconds: 100));
+          return <String>[];
+        });
+
+        // Start first download
+        final future1 = downloader.downloadParams();
+
+        // Start second download immediately
+        final future2 = downloader.downloadParams();
+
+        final results = await Future.wait([future1, future2]);
+
+        // First should succeed, second should fail with "already in progress"
+        expect(results[0], isA<DownloadResultSuccess>());
+        expect(results[1], isA<DownloadResultFailure>());
+
+        results[1].when(
+          success: (paramsPath) {
+            fail('Expected failure but got success: $paramsPath');
+          },
+          failure: (error) {
+            expect(error, equals('Download already in progress'));
+          },
+        );
+      });
+    });
+
+    group('areParamsAvailable', () {
+      test('returns true when no files are missing', () async {
+        when(
+          () => mockDownloadService.getMissingFiles(any(), any(), any()),
+        ).thenAnswer((_) async => []);
+
+        final available = await downloader.areParamsAvailable();
+
+        expect(available, isTrue);
+      });
+
+      test('returns false when files are missing', () async {
+        when(
+          () => mockDownloadService.getMissingFiles(any(), any(), any()),
+        ).thenAnswer((_) async => ['sapling-spend.params']);
+
+        final available = await downloader.areParamsAvailable();
+
+        expect(available, isFalse);
+      });
+
+      test('returns false when getParamsPath returns null', () async {
+        when(
+          () => mockPathProvider.getApplicationDocumentsPath(),
+        ).thenThrow(Exception('Path error'));
+
+        final available = await downloader.areParamsAvailable();
+
+        expect(available, isFalse);
+      });
+    });
+
+    group('validateParams', () {
+      test('delegates to download service', () async {
+        when(
+          () => mockDownloadService.validateFiles(any(), any(), any()),
+        ).thenAnswer((_) async => true);
+
+        final result = await downloader.validateParams();
+
+        expect(result, isTrue);
+        verify(
+          () => mockDownloadService.validateFiles(
+            testDirectoryPath,
+            any(),
+            any(),
+          ),
+        ).called(1);
+      });
+
+      test('returns false when getParamsPath returns null', () async {
+        when(
+          () => mockPathProvider.getApplicationDocumentsPath(),
+        ).thenThrow(Exception('Path error'));
+
+        final result = await downloader.validateParams();
+
+        expect(result, isFalse);
+      });
+    });
+
+    group('validateFileHash', () {
+      test('delegates to download service', () async {
+        const filePath = '/test/file.params';
+        const expectedHash = 'abcd1234';
+
+        when(
+          () => mockDownloadService.validateFileHash(any(), any(), any()),
+        ).thenAnswer((_) async => true);
+
+        final result = await downloader.validateFileHash(
+          filePath,
+          expectedHash,
+        );
+
+        expect(result, isTrue);
+        verify(
+          () => mockDownloadService.validateFileHash(
+            filePath,
+            expectedHash,
+            any(),
+          ),
+        ).called(1);
+      });
+    });
+
+    group('getFileHash', () {
+      test('delegates to download service', () async {
+        const filePath = '/test/file.params';
+        const expectedHash = 'abcd1234';
+
+        when(
+          () => mockDownloadService.getFileHash(any(), any()),
+        ).thenAnswer((_) async => expectedHash);
+
+        final result = await downloader.getFileHash(filePath);
+
+        expect(result, equals(expectedHash));
+        verify(
+          () => mockDownloadService.getFileHash(filePath, any()),
+        ).called(1);
+      });
+    });
+
+    group('clearParams', () {
+      test('delegates to download service', () async {
+        when(
+          () => mockDownloadService.clearFiles(any(), any()),
+        ).thenAnswer((_) async => true);
+
+        final result = await downloader.clearParams();
+
+        expect(result, isTrue);
+        verify(
+          () => mockDownloadService.clearFiles(testDirectoryPath, any()),
+        ).called(1);
+      });
+
+      test('returns false when getParamsPath returns null', () async {
+        when(
+          () => mockPathProvider.getApplicationDocumentsPath(),
+        ).thenThrow(Exception('Path error'));
+
+        final result = await downloader.clearParams();
+
+        expect(result, isFalse);
+      });
+    });
+
+    group('downloadProgress', () {
+      test('provides broadcast stream', () {
+        final stream = downloader.downloadProgress;
+
+        expect(stream, isA<Stream<DownloadProgress>>());
+        expect(stream.isBroadcast, isTrue);
+      });
+    });
+
+    group('cancelDownload', () {
+      test('returns false when no download is in progress', () async {
+        final result = await downloader.cancelDownload();
+
+        expect(result, isFalse);
+      });
+
+      test('returns true and cancels when download is in progress', () async {
+        when(
+          () => mockDownloadService.getMissingFiles(any(), any(), any()),
+        ).thenAnswer((_) async => ['test.params']);
+
+        when(
+          () => mockDownloadService.downloadMissingFiles(
+            any(),
+            any(),
+            any(),
+            any(),
+            any(),
+          ),
+        ).thenAnswer((invocation) async {
+          final isCancelledCallback =
+              invocation.positionalArguments[3] as bool Function();
+
+          // Simulate checking cancellation during download
+          await Future<void>.delayed(const Duration(milliseconds: 50));
+          if (isCancelledCallback()) {
+            return false;
+          }
+          return true;
+        });
+
+        when(
+          () => mockDownloadService.ensureDirectoryExists(any(), any()),
+        ).thenAnswer((_) async {});
+
+        // Start download
+        final downloadFuture = downloader.downloadParams();
+
+        // Cancel after short delay
+        await Future<void>.delayed(const Duration(milliseconds: 25));
+        final cancelResult = await downloader.cancelDownload();
+
+        expect(cancelResult, isTrue);
+
+        // Download should fail due to cancellation
+        final downloadResult = await downloadFuture;
+        expect(downloadResult, isA<DownloadResultFailure>());
+      });
+    });
+
+    group('dispose', () {
+      test('disposes download service and closes progress controller', () {
+        // Verify no exception is thrown
+        expect(() => downloader.dispose(), returnsNormally);
+
+        // Multiple dispose calls should be safe
+        expect(() => downloader.dispose(), returnsNormally);
+      });
+    });
+
+    group('error handling', () {
+      test('handles download service exceptions gracefully', () async {
+        when(
+          () => mockDownloadService.ensureDirectoryExists(any(), any()),
+        ).thenThrow(Exception('Directory creation failed'));
+
+        final result = await downloader.downloadParams();
+
+        expect(result, isA<DownloadResultFailure>());
+      });
+
+      test('handles path provider exceptions in multiple methods', () async {
+        when(
+          () => mockPathProvider.getApplicationDocumentsPath(),
+        ).thenThrow(Exception('Path provider error'));
+
+        expect(await downloader.getParamsPath(), isNull);
+        expect(await downloader.areParamsAvailable(), isFalse);
+        expect(await downloader.validateParams(), isFalse);
+        expect(await downloader.clearParams(), isFalse);
+
+        final downloadResult = await downloader.downloadParams();
+        expect(downloadResult, isA<DownloadResultFailure>());
+      });
+    });
+  });
+}
diff --git a/packages/komodo_defi_sdk/test/zcash_params/platform_implementations/web_zcash_params_downloader_test.dart b/packages/komodo_defi_sdk/test/zcash_params/platform_implementations/web_zcash_params_downloader_test.dart
new file mode 100644
index 000000000..7883e968b
--- /dev/null
+++ b/packages/komodo_defi_sdk/test/zcash_params/platform_implementations/web_zcash_params_downloader_test.dart
@@ -0,0 +1,323 @@
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_progress.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_result.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/platforms/web_zcash_params_downloader.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('WebZcashParamsDownloader', () {
+    late WebZcashParamsDownloader downloader;
+
+    setUp(() {
+      downloader = WebZcashParamsDownloader();
+    });
+
+    tearDown(() {
+      downloader.dispose();
+    });
+
+    group('downloadParams', () {
+      test('returns immediate success', () async {
+        final result = await downloader.downloadParams();
+
+        expect(result, isA<DownloadResultSuccess>());
+        result.when(
+          success: (paramsPath) {
+            expect(paramsPath, isNotNull);
+          },
+          failure: (error) {
+            fail('Expected success but got failure: $error');
+          },
+        );
+      });
+
+      test('returns consistent results on multiple calls', () async {
+        final result1 = await downloader.downloadParams();
+        final result2 = await downloader.downloadParams();
+
+        expect(result1.runtimeType, equals(result2.runtimeType));
+
+        // Both should be success results
+        expect(result1, isA<DownloadResultSuccess>());
+        expect(result2, isA<DownloadResultSuccess>());
+      });
+    });
+
+    group('getParamsPath', () {
+      test('returns null', () async {
+        final path = await downloader.getParamsPath();
+        expect(path, isNull);
+      });
+
+      test('returns consistent null on multiple calls', () async {
+        final path1 = await downloader.getParamsPath();
+        final path2 = await downloader.getParamsPath();
+
+        expect(path1, isNull);
+        expect(path2, isNull);
+        expect(path1, equals(path2));
+      });
+    });
+
+    group('areParamsAvailable', () {
+      test('returns true', () async {
+        final available = await downloader.areParamsAvailable();
+        expect(available, isTrue);
+      });
+
+      test('returns consistent true on multiple calls', () async {
+        final available1 = await downloader.areParamsAvailable();
+        final available2 = await downloader.areParamsAvailable();
+
+        expect(available1, isTrue);
+        expect(available2, isTrue);
+        expect(available1, equals(available2));
+      });
+    });
+
+    group('downloadProgress', () {
+      test('stream is empty', () async {
+        final events = <DownloadProgress>[];
+        final subscription = downloader.downloadProgress.listen(events.add);
+
+        // Wait a short time to ensure no events are emitted
+        await Future<void>.delayed(const Duration(milliseconds: 100));
+        await subscription.cancel();
+
+        expect(events, isEmpty);
+      });
+
+      test('stream can be listened to multiple times', () async {
+        final events1 = <DownloadProgress>[];
+        final events2 = <DownloadProgress>[];
+
+        final sub1 = downloader.downloadProgress.listen(events1.add);
+        final sub2 = downloader.downloadProgress.listen(events2.add);
+
+        await Future<void>.delayed(const Duration(milliseconds: 100));
+
+        await sub1.cancel();
+        await sub2.cancel();
+
+        expect(events1, isEmpty);
+        expect(events2, isEmpty);
+      });
+
+      test('stream is broadcast', () {
+        final stream = downloader.downloadProgress;
+
+        // Should be able to listen multiple times (broadcast stream)
+        expect(() => stream.listen((_) {}), returnsNormally);
+        expect(() => stream.listen((_) {}), returnsNormally);
+      });
+    });
+
+    group('cancelDownload', () {
+      test('returns false', () async {
+        final cancelled = await downloader.cancelDownload();
+        expect(cancelled, isFalse);
+      });
+
+      test('returns consistent false on multiple calls', () async {
+        final cancelled1 = await downloader.cancelDownload();
+        final cancelled2 = await downloader.cancelDownload();
+
+        expect(cancelled1, isFalse);
+        expect(cancelled2, isFalse);
+        expect(cancelled1, equals(cancelled2));
+      });
+
+      test('can be called after downloadParams', () async {
+        await downloader.downloadParams();
+        final cancelled = await downloader.cancelDownload();
+        expect(cancelled, isFalse);
+      });
+    });
+
+    group('validateParams', () {
+      test('returns true', () async {
+        final valid = await downloader.validateParams();
+        expect(valid, isTrue);
+      });
+
+      test('returns consistent true on multiple calls', () async {
+        final valid1 = await downloader.validateParams();
+        final valid2 = await downloader.validateParams();
+
+        expect(valid1, isTrue);
+        expect(valid2, isTrue);
+        expect(valid1, equals(valid2));
+      });
+
+      test('can be called before downloadParams', () async {
+        final valid = await downloader.validateParams();
+        expect(valid, isTrue);
+      });
+
+      test('can be called after downloadParams', () async {
+        await downloader.downloadParams();
+        final valid = await downloader.validateParams();
+        expect(valid, isTrue);
+      });
+    });
+
+    group('clearParams', () {
+      test('returns true', () async {
+        final cleared = await downloader.clearParams();
+        expect(cleared, isTrue);
+      });
+
+      test('returns consistent true on multiple calls', () async {
+        final cleared1 = await downloader.clearParams();
+        final cleared2 = await downloader.clearParams();
+
+        expect(cleared1, isTrue);
+        expect(cleared2, isTrue);
+        expect(cleared1, equals(cleared2));
+      });
+
+      test('can be called before downloadParams', () async {
+        final cleared = await downloader.clearParams();
+        expect(cleared, isTrue);
+      });
+
+      test('can be called after downloadParams', () async {
+        await downloader.downloadParams();
+        final cleared = await downloader.clearParams();
+        expect(cleared, isTrue);
+      });
+    });
+
+    group('dispose', () {
+      test('can be called safely', () {
+        expect(() => downloader.dispose(), returnsNormally);
+      });
+
+      test('can be called multiple times', () {
+        downloader.dispose();
+        expect(() => downloader.dispose(), returnsNormally);
+      });
+
+      test('closes progress stream', () async {
+        final stream = downloader.downloadProgress;
+        downloader.dispose();
+
+        // Stream should be closed after dispose
+        expect(stream, emitsDone);
+      });
+    });
+
+    group('integration scenarios', () {
+      test('complete workflow behaves correctly', () async {
+        // Check availability first
+        final available = await downloader.areParamsAvailable();
+        expect(available, isTrue);
+
+        // Get params path
+        final path = await downloader.getParamsPath();
+        expect(path, isNull);
+
+        // Download params
+        final result = await downloader.downloadParams();
+        expect(result, isA<DownloadResultSuccess>());
+        result.when(
+          success: (paramsPath) {
+            expect(paramsPath, isNotNull);
+          },
+          failure: (error) {
+            fail('Expected success but got failure: $error');
+          },
+        );
+
+        // Validate params
+        final valid = await downloader.validateParams();
+        expect(valid, isTrue);
+
+        // Clear params
+        final cleared = await downloader.clearParams();
+        expect(cleared, isTrue);
+      });
+
+      test('can handle rapid sequential calls', () async {
+        final futures = <Future<dynamic>>[];
+
+        // Make multiple rapid calls to all methods
+        for (int i = 0; i < 10; i++) {
+          futures
+            ..add(downloader.downloadParams())
+            ..add(downloader.getParamsPath())
+            ..add(downloader.areParamsAvailable())
+            ..add(downloader.cancelDownload())
+            ..add(downloader.validateParams())
+            ..add(downloader.clearParams());
+        }
+
+        // All should complete successfully
+        await Future.wait(futures);
+      });
+
+      test('maintains state consistency across operations', () async {
+        // Perform operations in different orders
+        await downloader.clearParams();
+        await downloader.validateParams();
+        await downloader.downloadParams();
+
+        final available = await downloader.areParamsAvailable();
+        final path = await downloader.getParamsPath();
+
+        expect(available, isTrue);
+        expect(path, isNull);
+      });
+    });
+
+    group('error conditions', () {
+      test('handles dispose during operation gracefully', () async {
+        final downloadFuture = downloader.downloadParams();
+        downloader.dispose();
+
+        // Download should still complete successfully
+        final result = await downloadFuture;
+        expect(result, isA<DownloadResultSuccess>());
+      });
+
+      test('all methods work after dispose', () async {
+        downloader.dispose();
+
+        // All methods should still work (they're no-ops anyway)
+        final result = await downloader.downloadParams();
+        expect(result, isA<DownloadResult>());
+        expect(result, isA<DownloadResultSuccess>());
+        expect(await downloader.getParamsPath(), isNull);
+        expect(await downloader.areParamsAvailable(), isTrue);
+        expect(await downloader.cancelDownload(), isFalse);
+        expect(await downloader.validateParams(), isTrue);
+        expect(await downloader.clearParams(), isTrue);
+      });
+    });
+
+    group('resource management', () {
+      test('multiple instances can coexist', () {
+        final downloader2 = WebZcashParamsDownloader();
+        final downloader3 = WebZcashParamsDownloader();
+
+        expect(downloader, isNot(same(downloader2)));
+        expect(downloader2, isNot(same(downloader3)));
+
+        downloader2.dispose();
+        downloader3.dispose();
+      });
+
+      test('instances are independent', () async {
+        final downloader2 = WebZcashParamsDownloader();
+
+        final result1 = await downloader.downloadParams();
+        final result2 = await downloader2.downloadParams();
+
+        expect(result1.runtimeType, equals(result2.runtimeType));
+        expect(result1, isA<DownloadResultSuccess>());
+        expect(result2, isA<DownloadResultSuccess>());
+
+        downloader2.dispose();
+      });
+    });
+  });
+}
diff --git a/packages/komodo_defi_sdk/test/zcash_params/platform_implementations/windows_zcash_params_downloader_test.dart b/packages/komodo_defi_sdk/test/zcash_params/platform_implementations/windows_zcash_params_downloader_test.dart
new file mode 100644
index 000000000..6bed3f711
--- /dev/null
+++ b/packages/komodo_defi_sdk/test/zcash_params/platform_implementations/windows_zcash_params_downloader_test.dart
@@ -0,0 +1,355 @@
+import 'dart:io';
+
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_progress.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_result.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/platforms/windows_zcash_params_downloader.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/services/zcash_params_download_service.dart';
+import 'package:mocktail/mocktail.dart';
+import 'package:test/test.dart';
+
+import '../test_helpers/mock_classes.dart';
+
+void main() {
+  group('WindowsZcashParamsDownloader', () {
+    late WindowsZcashParamsDownloader downloader;
+    late MockHttpClient mockHttpClient;
+    late MockDirectory mockDirectory;
+    late MockFile mockFile;
+
+    Directory mockDirectoryFactory(String path) => mockDirectory;
+    File mockFileFactory(String path) => mockFile;
+
+    setUpAll(() {
+      // Register fallback values for mocktail
+      registerFallbackValue(Uri.parse('https://example.com'));
+      registerFallbackValue(MockHttpRequest());
+    });
+
+    setUp(() {
+      mockHttpClient = MockHttpClient();
+      mockDirectory = MockDirectory();
+      mockFile = MockFile();
+
+      downloader = WindowsZcashParamsDownloader(
+        downloadService: DefaultZcashParamsDownloadService(
+          httpClient: mockHttpClient,
+        ),
+        directoryFactory: mockDirectoryFactory,
+        fileFactory: mockFileFactory,
+      );
+    });
+
+    tearDown(() {
+      downloader.dispose();
+    });
+
+    group('getParamsPath', () {
+      test('returns null when APPDATA environment variable missing', () async {
+        // On non-Windows platforms, APPDATA won't exist
+        final path = await downloader.getParamsPath();
+        expect(path, isNull);
+      });
+
+      test('returns normally but fails due to missing APPDATA', () {
+        // This test would need to mock Platform.environment in a real scenario
+        // For now, we just verify the method doesn't throw
+        expect(downloader.getParamsPath(), completes);
+      });
+    });
+
+    group('areParamsAvailable', () {
+      test('returns false due to missing APPDATA environment', () async {
+        when(() => mockFile.exists()).thenAnswer((_) async => true);
+
+        final available = await downloader.areParamsAvailable();
+        expect(available, isFalse);
+      });
+
+      test('returns false when any param file missing', () async {
+        when(() => mockFile.exists()).thenAnswer((_) async => false);
+
+        final available = await downloader.areParamsAvailable();
+        expect(available, isFalse);
+      });
+
+      test('returns false when getParamsPath throws', () async {
+        // Will throw StateError due to missing APPDATA
+        final available = await downloader.areParamsAvailable();
+        expect(available, isFalse);
+      });
+    });
+
+    group('downloadParams', () {
+      test('returns failure when already downloading', () async {
+        // Start first download (will fail due to missing APPDATA but sets downloading flag)
+        final future1 = downloader.downloadParams();
+        final future2 = downloader.downloadParams();
+
+        final result1 = await future1;
+        final result2 = await future2;
+
+        expect(result2, isA<DownloadResultFailure>());
+        result2.when(
+          success: (paramsPath) {
+            fail('Expected failure but got success');
+          },
+          failure: (error) {
+            expect(error, contains('already in progress'));
+          },
+        );
+      });
+
+      test('returns failure when unable to determine params path', () async {
+        final result = await downloader.downloadParams();
+
+        expect(result, isA<DownloadResultFailure>());
+        result.when(
+          success: (paramsPath) {
+            fail('Expected failure but got success');
+          },
+          failure: (error) {
+            expect(error, contains('Unable to determine parameters path'));
+          },
+        );
+      });
+
+      test('attempts download but fails due to missing APPDATA', () async {
+        when(() => mockDirectory.exists()).thenAnswer((_) async => false);
+        when(
+          () => mockDirectory.create(recursive: any(named: 'recursive')),
+        ).thenAnswer((_) async => mockDirectory);
+
+        final result = await downloader.downloadParams();
+
+        expect(result, isA<DownloadResultFailure>());
+        // Directory creation is not called because path determination fails first
+        verifyNever(
+          () => mockDirectory.create(recursive: any(named: 'recursive')),
+        );
+      });
+
+      test('fails even when all files exist due to path issue', () async {
+        when(() => mockFile.exists()).thenAnswer((_) async => true);
+
+        final result = await downloader.downloadParams();
+
+        expect(
+          result,
+          isA<DownloadResultFailure>(),
+        ); // Will still fail due to path issue
+      });
+
+      test('fails to download due to missing APPDATA', () async {
+        // Setup successful HTTP response
+        final testData = TestData.sampleParamData;
+        final mockResponse = TestHttpResponse.streamedSuccess(testData);
+        when(
+          () => mockHttpClient.send(any()),
+        ).thenAnswer((_) async => mockResponse);
+
+        final result = await downloader.downloadParams();
+
+        expect(result, isA<DownloadResultFailure>());
+        // HTTP requests are not made because path determination fails first
+        verifyNever(() => mockHttpClient.send(any()));
+      });
+
+      test('fails due to path issue before HTTP attempt', () async {
+        final mockResponse = TestHttpResponse.streamedFailure(404);
+        when(
+          () => mockHttpClient.send(any()),
+        ).thenAnswer((_) async => mockResponse);
+
+        final result = await downloader.downloadParams();
+
+        expect(result, isA<DownloadResultFailure>());
+        // HTTP is not attempted due to earlier path failure
+        verifyNever(() => mockHttpClient.send(any()));
+      });
+
+      test('fails before attempting backup URLs', () async {
+        final result = await downloader.downloadParams();
+
+        expect(result, isA<DownloadResultFailure>());
+        // No HTTP calls made due to path failure
+        verifyNever(() => mockHttpClient.send(any()));
+      });
+
+      test('no progress events due to early failure', () async {
+        final progressEvents = <DownloadProgress>[];
+        final subscription = downloader.downloadProgress.listen(
+          progressEvents.add,
+        );
+
+        final testData = TestData.sampleParamData;
+        final mockResponse = TestHttpResponse.streamedSuccess(testData);
+        when(
+          () => mockHttpClient.send(any()),
+        ).thenAnswer((_) async => mockResponse);
+
+        await downloader.downloadParams();
+        await subscription.cancel();
+
+        // No progress events because download never starts due to path failure
+        expect(progressEvents, isEmpty);
+      });
+
+      test('fails before download starts, cancellation not relevant', () async {
+        final downloadFuture = downloader.downloadParams();
+        final cancelled = await downloader.cancelDownload();
+
+        final result = await downloadFuture;
+        expect(result, isA<DownloadResultFailure>());
+        expect(
+          cancelled,
+          isTrue,
+        ); // Returns true even though no actual download to cancel
+      });
+    });
+
+    group('cancelDownload', () {
+      test('returns false when no download in progress', () async {
+        final cancelled = await downloader.cancelDownload();
+        expect(cancelled, isFalse);
+      });
+
+      test('returns true when download is in progress', () async {
+        // Start a download (will set downloading flag)
+        final downloadFuture = downloader.downloadParams();
+        final cancelled = await downloader.cancelDownload();
+
+        expect(cancelled, isTrue);
+        await downloadFuture; // Wait for download to complete
+      });
+    });
+
+    group('validateParams', () {
+      test('returns false due to path issue', () async {
+        when(() => mockFile.exists()).thenAnswer((_) async => true);
+
+        final mockStat = MockFileStat();
+        when(() => mockStat.size).thenReturn(2 * 1024 * 1024); // 2MB
+        when(() => mockFile.stat()).thenAnswer((_) async => mockStat);
+
+        final valid = await downloader.validateParams();
+        expect(valid, isFalse); // Fails due to missing APPDATA
+      });
+
+      test('returns false when files do not exist', () async {
+        when(() => mockFile.exists()).thenAnswer((_) async => false);
+
+        final valid = await downloader.validateParams();
+        expect(valid, isFalse);
+      });
+
+      test('returns false when files are too small', () async {
+        when(() => mockFile.exists()).thenAnswer((_) async => true);
+
+        final mockStat = MockFileStat();
+        when(() => mockStat.size).thenReturn(1024); // 1KB (too small)
+        when(() => mockFile.stat()).thenAnswer((_) async => mockStat);
+
+        final valid = await downloader.validateParams();
+        expect(valid, isFalse);
+      });
+    });
+
+    group('clearParams', () {
+      test('deletes params directory successfully', () async {
+        when(() => mockDirectory.exists()).thenAnswer((_) async => true);
+        when(
+          () => mockDirectory.delete(recursive: true),
+        ).thenAnswer((_) async => mockDirectory);
+
+        final cleared = await downloader.clearParams();
+        expect(cleared, isFalse); // Fails due to missing APPDATA
+      });
+
+      test('handles missing directory gracefully', () async {
+        when(() => mockDirectory.exists()).thenAnswer((_) async => false);
+
+        final cleared = await downloader.clearParams();
+        expect(cleared, isFalse); // Fails due to missing APPDATA
+      });
+
+      test('handles deletion errors gracefully', () async {
+        when(() => mockDirectory.exists()).thenAnswer((_) async => true);
+        when(
+          () => mockDirectory.delete(recursive: true),
+        ).thenThrow(FileSystemException('Cannot delete'));
+
+        final cleared = await downloader.clearParams();
+        expect(cleared, isFalse);
+      });
+    });
+
+    group('downloadProgress stream', () {
+      test('is broadcast stream', () {
+        final stream = downloader.downloadProgress;
+        expect(() => stream.listen((_) {}), returnsNormally);
+        expect(() => stream.listen((_) {}), returnsNormally);
+      });
+
+      test('emits no progress due to early failure', () async {
+        final progressEvents = <DownloadProgress>[];
+        final subscription = downloader.downloadProgress.listen(
+          progressEvents.add,
+        );
+
+        await downloader.downloadParams();
+        await subscription.cancel();
+
+        expect(progressEvents, isEmpty);
+      });
+    });
+
+    group('error handling', () {
+      test('handles path determination failure', () async {
+        final result = await downloader.downloadParams();
+        expect(result, isA<DownloadResultFailure>());
+        result.when(
+          success: (paramsPath) {
+            fail('Expected failure but got success');
+          },
+          failure: (error) {
+            expect(error, contains('Unable to determine parameters path'));
+          },
+        );
+      });
+    });
+
+    group('resource management', () {
+      test('disposes successfully', () {
+        expect(() => downloader.dispose(), returnsNormally);
+        // HTTP client is closed in the service, not directly accessible to verify
+      });
+
+      test('closes progress stream on dispose', () async {
+        final stream = downloader.downloadProgress;
+        downloader.dispose();
+
+        expect(stream, emitsDone);
+      });
+
+      test('can be disposed multiple times safely', () {
+        downloader.dispose();
+        expect(() => downloader.dispose(), returnsNormally);
+      });
+    });
+
+    group('edge cases', () {
+      test('all operations fail due to missing APPDATA', () async {
+        // Test that all operations consistently fail due to path issues
+        final downloadResult = await downloader.downloadParams();
+        final validateResult = await downloader.validateParams();
+        final clearResult = await downloader.clearParams();
+        final availableResult = await downloader.areParamsAvailable();
+
+        expect(downloadResult, isA<DownloadResultFailure>());
+        expect(validateResult, isFalse);
+        expect(clearResult, isFalse);
+        expect(availableResult, isFalse);
+      });
+    });
+  });
+}
diff --git a/packages/komodo_defi_sdk/test/zcash_params/platforms/unix_zcash_params_downloader_test.dart b/packages/komodo_defi_sdk/test/zcash_params/platforms/unix_zcash_params_downloader_test.dart
new file mode 100644
index 000000000..50bcc24d7
--- /dev/null
+++ b/packages/komodo_defi_sdk/test/zcash_params/platforms/unix_zcash_params_downloader_test.dart
@@ -0,0 +1,205 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_progress.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_result.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/models/zcash_params_config.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/platforms/unix_zcash_params_downloader.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/services/zcash_params_download_service.dart';
+import 'package:mocktail/mocktail.dart';
+import 'package:test/test.dart';
+
+// Helper function to run tests with a custom HOME environment variable
+Future<T> withEnvironmentVariable<T>(
+  String key,
+  String? value,
+  Future<T> Function() testFunction,
+) async {
+  final originalValue = Platform.environment[key];
+  if (value == null) {
+    Platform.environment.remove(key);
+  } else {
+    // Note: In test environment, we can't actually modify Platform.environment
+    // So we'll create a custom downloader with the override instead
+  }
+
+  try {
+    return await testFunction();
+  } finally {
+    // Restore original value (though this won't work in test environment either)
+    if (originalValue != null) {
+      // We can't restore in test environment, so this is a no-op
+    }
+  }
+}
+
+class MockZcashParamsDownloadService extends Mock
+    implements ZcashParamsDownloadService {}
+
+class MockDirectory extends Mock implements Directory {}
+
+class MockFile extends Mock implements File {}
+
+void main() {
+  late MockZcashParamsDownloadService mockDownloadService;
+  late MockDirectory mockDirectory;
+  late MockFile mockFile;
+
+  setUpAll(() {
+    // Register fallback values for mocktail
+    registerFallbackValue(
+      const ZcashParamsConfig(
+        paramFiles: [
+          ZcashParamFile(fileName: 'dummy-file', sha256Hash: 'dummy-hash'),
+        ],
+      ),
+    );
+    registerFallbackValue(StreamController<DownloadProgress>.broadcast());
+  });
+
+  setUp(() {
+    mockDownloadService = MockZcashParamsDownloadService();
+    mockDirectory = MockDirectory();
+    mockFile = MockFile();
+  });
+
+  group('UnixZcashParamsDownloader', () {
+    group('getParamsPath', () {
+      test('uses HOME environment variable when available', () async {
+        // Mock the environment variable by using the override parameter
+        const testHome = '/home/testuser';
+        final downloader = UnixZcashParamsDownloader(
+          homeDirectoryOverride: testHome,
+        );
+
+        final path = await downloader.getParamsPath();
+
+        // Since we're running on macOS, the path will be treated as macOS
+        // even though it starts with /home/ - the logic checks Platform.isMacOS first
+        expect(
+          path,
+          equals('/home/testuser/Library/Application Support/ZcashParams'),
+        );
+      });
+
+      test('uses custom homeDirectoryOverride when provided', () async {
+        const customHome = '/custom/home/path';
+        final downloader = UnixZcashParamsDownloader(
+          homeDirectoryOverride: customHome,
+        );
+
+        final path = await downloader.getParamsPath();
+
+        // Should use the custom home directory (macOS path since we're on macOS)
+        expect(
+          path,
+          equals('/custom/home/path/Library/Application Support/ZcashParams'),
+        );
+      });
+
+      test(
+        'falls back to application documents directory when HOME is not available',
+        () async {
+          // Test with no HOME override (should use fallback)
+          final downloader = UnixZcashParamsDownloader();
+
+          final path = await downloader.getParamsPath();
+
+          // Should return a path (either from fallback or null if path_provider fails)
+          // We can't easily mock path_provider in this test, so we'll just verify
+          // it doesn't throw an exception
+          expect(path, anyOf(isA<String>(), isNull));
+        },
+      );
+
+      test('handles path_provider errors gracefully', () async {
+        // This test would require more complex mocking of path_provider
+        // For now, we test that the method doesn't throw when HOME is missing
+        final downloader = UnixZcashParamsDownloader();
+
+        // Should not throw an exception
+        final path = await downloader.getParamsPath();
+
+        // Path might be null if path_provider fails, but no exception should be thrown
+        expect(path, anyOf(isA<String>(), isNull));
+      });
+
+      test('uses macOS-specific path when on macOS', () async {
+        const testHome = '/Users/testuser';
+        final downloader = UnixZcashParamsDownloader(
+          homeDirectoryOverride: testHome,
+        );
+
+        final path = await downloader.getParamsPath();
+
+        // Should use macOS-specific path (since we're running on macOS and the path starts with /Users/)
+        expect(
+          path,
+          equals('/Users/testuser/Library/Application Support/ZcashParams'),
+        );
+      });
+    });
+
+    group('downloadParams', () {
+      test('handles null params path gracefully', () async {
+        final downloader = UnixZcashParamsDownloader(
+          downloadService: mockDownloadService,
+          directoryFactory: (path) => mockDirectory,
+          fileFactory: (path) => mockFile,
+        );
+
+        // Mock the download service methods
+        when(
+          () => mockDownloadService.ensureDirectoryExists(any(), any()),
+        ).thenAnswer((_) async {});
+        when(
+          () => mockDownloadService.getMissingFiles(any(), any(), any()),
+        ).thenAnswer(
+          (_) async => ['test-file'],
+        ); // Return non-empty list to trigger download
+        when(
+          () => mockDownloadService.downloadMissingFiles(
+            any(),
+            any(),
+            any(),
+            any(),
+            any(),
+          ),
+        ).thenAnswer(
+          (_) async => false,
+        ); // Return false to simulate download failure
+
+        // Should return failure result when path is null
+        final result = await downloader.downloadParams();
+
+        expect(result, isA<DownloadResultFailure>());
+        expect(
+          (result as DownloadResultFailure).error,
+          equals('Failed to download one or more parameter files'),
+        );
+      });
+    });
+
+    group('areParamsAvailable', () {
+      test('handles null params path gracefully', () async {
+        final downloader = UnixZcashParamsDownloader(
+          downloadService: mockDownloadService,
+          directoryFactory: (path) => mockDirectory,
+          fileFactory: (path) => mockFile,
+        );
+
+        // Mock the download service
+        when(
+          () => mockDownloadService.getMissingFiles(any(), any(), any()),
+        ).thenAnswer(
+          (_) async => ['missing-file'],
+        ); // Return non-empty list to indicate files are missing
+
+        // Should return false when path is null
+        final available = await downloader.areParamsAvailable();
+
+        expect(available, isFalse);
+      });
+    });
+  });
+}
diff --git a/packages/komodo_defi_sdk/test/zcash_params/services/zcash_params_download_service_test.dart b/packages/komodo_defi_sdk/test/zcash_params/services/zcash_params_download_service_test.dart
new file mode 100644
index 000000000..c7945c613
--- /dev/null
+++ b/packages/komodo_defi_sdk/test/zcash_params/services/zcash_params_download_service_test.dart
@@ -0,0 +1,724 @@
+import 'dart:async';
+import 'dart:io';
+import 'dart:typed_data';
+
+import 'package:crypto/crypto.dart';
+import 'package:http/http.dart' as http;
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_progress.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/models/zcash_params_config.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/services/zcash_params_download_service.dart';
+import 'package:mocktail/mocktail.dart';
+import 'package:test/test.dart';
+
+import '../test_helpers/mock_classes.dart';
+
+void main() {
+  group('DefaultZcashParamsDownloadService', () {
+    late DefaultZcashParamsDownloadService service;
+    late MockHttpClient mockHttpClient;
+    late ZcashParamsConfig testConfig;
+
+    // Test data
+    final testData = Uint8List.fromList(List.generate(1024, (i) => i % 256));
+    final testHash = sha256.convert(testData).toString().toLowerCase();
+
+    setUp(() {
+      mockHttpClient = MockHttpClient();
+      service = DefaultZcashParamsDownloadService(httpClient: mockHttpClient);
+
+      testConfig = const ZcashParamsConfig(
+        paramFiles: [
+          ZcashParamFile(
+            fileName: 'test-spend.params',
+            sha256Hash: 'testhash1',
+            expectedSize: 1024,
+          ),
+          ZcashParamFile(
+            fileName: 'test-output.params',
+            sha256Hash: 'testhash2',
+            expectedSize: 2048,
+          ),
+        ],
+        primaryUrl: 'https://test.example.com/downloads/',
+        backupUrl: 'https://backup.example.com/downloads/',
+        downloadTimeoutSeconds: 30,
+      );
+
+      // Register fallback values for mocktail
+      registerFallbackValue(Uri.parse('https://example.com'));
+      registerFallbackValue(
+        http.Request('GET', Uri.parse('https://example.com')),
+      );
+    });
+
+    tearDown(() {
+      service.dispose();
+    });
+
+    group('getMissingFiles', () {
+      test('returns empty list when all files exist and are valid', () async {
+        File fileFactory(String path) {
+          final file = MockFile();
+          when(() => file.existsSync()).thenReturn(true);
+          when(() => file.path).thenReturn(path);
+          when(
+            () => file.openRead(),
+          ).thenAnswer((_) => Stream.fromIterable([testData]));
+          return file;
+        }
+
+        final missingFiles = await service.getMissingFiles(
+          '/test/dir',
+          fileFactory,
+          testConfig.copyWith(
+            paramFiles: [
+              ZcashParamFile(
+                fileName: 'test-spend.params',
+                sha256Hash: testHash,
+                expectedSize: 1024,
+              ),
+            ],
+          ),
+        );
+
+        expect(missingFiles, isEmpty);
+      });
+
+      test('returns files that do not exist', () async {
+        File fileFactory(String path) {
+          final file = MockFile();
+          when(() => file.exists()).thenAnswer((_) async => false);
+          when(() => file.path).thenReturn(path);
+          return file;
+        }
+
+        final missingFiles = await service.getMissingFiles(
+          '/test/dir',
+          fileFactory,
+          testConfig,
+        );
+
+        expect(
+          missingFiles,
+          equals(['test-spend.params', 'test-output.params']),
+        );
+      });
+
+      test('returns files with invalid hashes', () async {
+        File fileFactory(String path) {
+          final file = MockFile();
+          when(() => file.exists()).thenAnswer((_) async => true);
+          when(() => file.path).thenReturn(path);
+          when(
+            () => file.openRead(),
+          ).thenAnswer((_) => Stream.fromIterable([testData]));
+          return file;
+        }
+
+        final missingFiles = await service.getMissingFiles(
+          '/test/dir',
+          fileFactory,
+          testConfig,
+        );
+
+        expect(
+          missingFiles,
+          equals(['test-spend.params', 'test-output.params']),
+        );
+      });
+
+      test('handles file read errors gracefully', () async {
+        File fileFactory(String path) {
+          final file = MockFile();
+          when(() => file.exists()).thenAnswer((_) async => true);
+          when(() => file.path).thenReturn(path);
+          when(
+            () => file.openRead(),
+          ).thenThrow(FileSystemException('Read error'));
+          return file;
+        }
+
+        final missingFiles = await service.getMissingFiles(
+          '/test/dir',
+          fileFactory,
+          testConfig,
+        );
+
+        expect(
+          missingFiles,
+          equals(['test-spend.params', 'test-output.params']),
+        );
+      });
+    });
+
+    group('ensureDirectoryExists', () {
+      test('creates directory when it does not exist', () async {
+        final mockDirectory = MockDirectory();
+        when(() => mockDirectory.existsSync()).thenReturn(false);
+        when(
+          () => mockDirectory.create(recursive: true),
+        ).thenAnswer((_) async => mockDirectory);
+
+        Directory directoryFactory(String path) => mockDirectory;
+
+        await service.ensureDirectoryExists('/test/dir', directoryFactory);
+
+        verify(() => mockDirectory.create(recursive: true)).called(1);
+      });
+
+      test('does nothing when directory already exists', () async {
+        final mockDirectory = MockDirectory();
+        when(() => mockDirectory.existsSync()).thenReturn(true);
+
+        Directory directoryFactory(String path) => mockDirectory;
+
+        await service.ensureDirectoryExists('/test/dir', directoryFactory);
+
+        verifyNever(
+          () => mockDirectory.create(recursive: any(named: 'recursive')),
+        );
+      });
+
+      test('handles directory creation errors', () async {
+        final mockDirectory = MockDirectory();
+        when(() => mockDirectory.existsSync()).thenReturn(false);
+        when(
+          () => mockDirectory.create(recursive: true),
+        ).thenThrow(FileSystemException('Permission denied'));
+
+        Directory directoryFactory(String path) => mockDirectory;
+
+        expect(
+          () => service.ensureDirectoryExists('/test/dir', directoryFactory),
+          throwsA(isA<FileSystemException>()),
+        );
+      });
+    });
+
+    group('validateFiles', () {
+      test('returns true when all files exist and have valid hashes', () async {
+        File fileFactory(String path) {
+          final file = MockFile();
+          when(() => file.exists()).thenAnswer((_) async => true);
+          when(() => file.existsSync()).thenReturn(true);
+          when(() => file.path).thenReturn(path);
+          when(
+            () => file.openRead(),
+          ).thenAnswer((_) => Stream.fromIterable([testData]));
+          return file;
+        }
+
+        final isValid = await service.validateFiles(
+          '/test/dir',
+          fileFactory,
+          testConfig.copyWith(
+            paramFiles: [
+              ZcashParamFile(
+                fileName: 'test-spend.params',
+                sha256Hash: testHash,
+                expectedSize: 1024,
+              ),
+            ],
+          ),
+        );
+
+        expect(isValid, isTrue);
+      });
+
+      test('returns false when any file does not exist', () async {
+        File fileFactory(String path) {
+          final file = MockFile();
+          when(() => file.exists()).thenAnswer((_) async => false);
+          when(() => file.path).thenReturn(path);
+          return file;
+        }
+
+        final isValid = await service.validateFiles(
+          '/test/dir',
+          fileFactory,
+          testConfig,
+        );
+
+        expect(isValid, isFalse);
+      });
+
+      test('returns false when any file has invalid hash', () async {
+        File fileFactory(String path) {
+          final file = MockFile();
+          when(() => file.exists()).thenAnswer((_) async => true);
+          when(() => file.path).thenReturn(path);
+          when(
+            () => file.openRead(),
+          ).thenAnswer((_) => Stream.fromIterable([testData]));
+          return file;
+        }
+
+        final isValid = await service.validateFiles(
+          '/test/dir',
+          fileFactory,
+          testConfig, // Uses different hash than testData
+        );
+
+        expect(isValid, isFalse);
+      });
+
+      test('returns false on exceptions', () async {
+        File fileFactory(String path) {
+          final file = MockFile();
+          when(
+            () => file.exists(),
+          ).thenThrow(FileSystemException('Access denied'));
+          when(() => file.path).thenReturn(path);
+          return file;
+        }
+
+        final isValid = await service.validateFiles(
+          '/test/dir',
+          fileFactory,
+          testConfig,
+        );
+
+        expect(isValid, isFalse);
+      });
+    });
+
+    group('validateFileHash', () {
+      test('returns true for valid hash', () async {
+        File fileFactory(String path) {
+          final file = MockFile();
+          when(() => file.existsSync()).thenReturn(true);
+          when(() => file.path).thenReturn(path);
+          when(
+            () => file.openRead(),
+          ).thenAnswer((_) => Stream.fromIterable([testData]));
+          return file;
+        }
+
+        final isValid = await service.validateFileHash(
+          '/test/file.params',
+          testHash,
+          fileFactory,
+        );
+
+        expect(isValid, isTrue);
+      });
+
+      test('returns false for invalid hash', () async {
+        File fileFactory(String path) {
+          final file = MockFile();
+          when(() => file.exists()).thenAnswer((_) async => true);
+          when(() => file.path).thenReturn(path);
+          when(
+            () => file.openRead(),
+          ).thenAnswer((_) => Stream.fromIterable([testData]));
+          return file;
+        }
+
+        final isValid = await service.validateFileHash(
+          '/test/file.params',
+          'invalidhash',
+          fileFactory,
+        );
+
+        expect(isValid, isFalse);
+      });
+
+      test('is case insensitive', () async {
+        File fileFactory(String path) {
+          final file = MockFile();
+          when(() => file.existsSync()).thenReturn(true);
+          when(() => file.path).thenReturn(path);
+          when(
+            () => file.openRead(),
+          ).thenAnswer((_) => Stream.fromIterable([testData]));
+          return file;
+        }
+
+        final isValid = await service.validateFileHash(
+          '/test/file.params',
+          testHash.toUpperCase(),
+          fileFactory,
+        );
+
+        expect(isValid, isTrue);
+      });
+
+      test('returns false when file does not exist', () async {
+        File fileFactory(String path) {
+          final file = MockFile();
+          when(() => file.exists()).thenAnswer((_) async => false);
+          when(() => file.path).thenReturn(path);
+          return file;
+        }
+
+        final isValid = await service.validateFileHash(
+          '/test/file.params',
+          testHash,
+          fileFactory,
+        );
+
+        expect(isValid, isFalse);
+      });
+
+      test('handles read errors gracefully', () async {
+        File fileFactory(String path) {
+          final file = MockFile();
+          when(() => file.exists()).thenAnswer((_) async => true);
+          when(() => file.path).thenReturn(path);
+          when(
+            () => file.openRead(),
+          ).thenThrow(FileSystemException('Read error'));
+          return file;
+        }
+
+        final isValid = await service.validateFileHash(
+          '/test/file.params',
+          testHash,
+          fileFactory,
+        );
+
+        expect(isValid, isFalse);
+      });
+    });
+
+    group('getFileHash', () {
+      test('returns correct hash for existing file', () async {
+        File fileFactory(String path) {
+          final file = MockFile();
+          when(() => file.existsSync()).thenReturn(true);
+          when(() => file.path).thenReturn(path);
+          when(
+            () => file.openRead(),
+          ).thenAnswer((_) => Stream.fromIterable([testData]));
+          return file;
+        }
+
+        final hash = await service.getFileHash(
+          '/test/file.params',
+          fileFactory,
+        );
+
+        expect(hash, equals(testHash));
+      });
+
+      test('returns null when file does not exist', () async {
+        File fileFactory(String path) {
+          final file = MockFile();
+          when(() => file.existsSync()).thenReturn(false);
+          when(() => file.path).thenReturn(path);
+          return file;
+        }
+
+        final hash = await service.getFileHash(
+          '/test/file.params',
+          fileFactory,
+        );
+
+        expect(hash, isNull);
+      });
+
+      test('returns null on read errors', () async {
+        File fileFactory(String path) {
+          final file = MockFile();
+          when(() => file.exists()).thenAnswer((_) async => true);
+          when(() => file.existsSync()).thenReturn(true);
+          when(() => file.path).thenReturn(path);
+          when(
+            () => file.openRead(),
+          ).thenThrow(FileSystemException('Read error'));
+          return file;
+        }
+
+        final hash = await service.getFileHash(
+          '/test/file.params',
+          fileFactory,
+        );
+
+        expect(hash, isNull);
+      });
+    });
+
+    group('getRemoteFileSize', () {
+      test('returns content length from successful HEAD request', () async {
+        final mockResponse = MockHttpResponse();
+        when(() => mockResponse.statusCode).thenReturn(200);
+        when(() => mockResponse.headers).thenReturn({'content-length': '1024'});
+        when(
+          () => mockHttpClient.head(any()),
+        ).thenAnswer((_) async => mockResponse);
+
+        final size = await service.getRemoteFileSize(
+          'https://example.com/file.params',
+        );
+
+        expect(size, equals(1024));
+      });
+
+      test('returns null when HEAD request fails', () async {
+        final mockResponse = MockHttpResponse();
+        when(() => mockResponse.statusCode).thenReturn(404);
+        when(
+          () => mockHttpClient.head(any()),
+        ).thenAnswer((_) async => mockResponse);
+
+        final size = await service.getRemoteFileSize(
+          'https://example.com/file.params',
+        );
+
+        expect(size, isNull);
+      });
+
+      test('returns null when content-length header is missing', () async {
+        final mockResponse = MockHttpResponse();
+        when(() => mockResponse.statusCode).thenReturn(200);
+        when(() => mockResponse.headers).thenReturn(<String, String>{});
+        when(
+          () => mockHttpClient.head(any()),
+        ).thenAnswer((_) async => mockResponse);
+
+        final size = await service.getRemoteFileSize(
+          'https://example.com/file.params',
+        );
+
+        expect(size, isNull);
+      });
+
+      test('returns null when content-length is not a valid number', () async {
+        final mockResponse = MockHttpResponse();
+        when(() => mockResponse.statusCode).thenReturn(200);
+        when(
+          () => mockResponse.headers,
+        ).thenReturn({'content-length': 'invalid'});
+        when(
+          () => mockHttpClient.head(any()),
+        ).thenAnswer((_) async => mockResponse);
+
+        final size = await service.getRemoteFileSize(
+          'https://example.com/file.params',
+        );
+
+        expect(size, isNull);
+      });
+
+      test('returns null on network errors', () async {
+        when(
+          () => mockHttpClient.head(any()),
+        ).thenThrow(SocketException('Network error'));
+
+        final size = await service.getRemoteFileSize(
+          'https://example.com/file.params',
+        );
+
+        expect(size, isNull);
+      });
+    });
+
+    group('clearFiles', () {
+      test('successfully deletes existing directory', () async {
+        final mockDirectory = MockDirectory();
+        when(() => mockDirectory.existsSync()).thenReturn(true);
+        when(
+          () => mockDirectory.delete(recursive: true),
+        ).thenAnswer((_) async => mockDirectory);
+
+        Directory directoryFactory(String path) => mockDirectory;
+
+        final result = await service.clearFiles('/test/dir', directoryFactory);
+
+        expect(result, isTrue);
+        verify(() => mockDirectory.delete(recursive: true)).called(1);
+      });
+
+      test('returns true when directory does not exist', () async {
+        final mockDirectory = MockDirectory();
+        when(() => mockDirectory.existsSync()).thenReturn(false);
+
+        Directory directoryFactory(String path) => mockDirectory;
+
+        final result = await service.clearFiles('/test/dir', directoryFactory);
+
+        expect(result, isTrue);
+        verifyNever(
+          () => mockDirectory.delete(recursive: any(named: 'recursive')),
+        );
+      });
+
+      test('returns false on deletion errors', () async {
+        final mockDirectory = MockDirectory();
+        when(() => mockDirectory.existsSync()).thenReturn(true);
+        when(
+          () => mockDirectory.delete(recursive: true),
+        ).thenThrow(FileSystemException('Permission denied'));
+
+        Directory directoryFactory(String path) => mockDirectory;
+
+        final result = await service.clearFiles('/test/dir', directoryFactory);
+
+        expect(result, isFalse);
+      });
+    });
+
+    group('downloadMissingFiles', () {
+      test('returns true for empty missing files list', () async {
+        final progressController = StreamController<DownloadProgress>();
+        bool isCancelled() => false;
+
+        final result = await service.downloadMissingFiles(
+          '/test/dir',
+          [], // Empty list
+          progressController,
+          isCancelled,
+          testConfig,
+        );
+
+        expect(result, isTrue);
+        progressController.close();
+      });
+
+      test('returns false when download is cancelled immediately', () async {
+        final progressController = StreamController<DownloadProgress>();
+        bool isCancelled() => true; // Always cancelled
+
+        final result = await service.downloadMissingFiles(
+          '/test/dir',
+          ['test-spend.params'],
+          progressController,
+          isCancelled,
+          testConfig,
+        );
+
+        expect(result, isFalse);
+        progressController.close();
+      });
+
+      test('handles timeout errors gracefully', () async {
+        when(
+          () => mockHttpClient.send(any()),
+        ).thenAnswer((_) async => throw TimeoutException('Request timeout'));
+
+        final progressController = StreamController<DownloadProgress>();
+        bool isCancelled() => false;
+
+        final result = await service.downloadMissingFiles(
+          '/test/dir',
+          ['test-spend.params'],
+          progressController,
+          isCancelled,
+          testConfig,
+        );
+
+        expect(result, isFalse);
+        progressController.close();
+      });
+
+      test('handles HTTP client exceptions gracefully', () async {
+        when(
+          () => mockHttpClient.send(any()),
+        ).thenAnswer((_) async => throw HttpException('Connection failed'));
+
+        final progressController = StreamController<DownloadProgress>();
+        bool isCancelled() => false;
+
+        final result = await service.downloadMissingFiles(
+          '/test/dir',
+          ['test-spend.params'],
+          progressController,
+          isCancelled,
+          testConfig,
+        );
+
+        expect(result, isFalse);
+        progressController.close();
+      });
+    });
+
+    group('dispose', () {
+      test('closes HTTP client', () {
+        service.dispose();
+
+        verify(() => mockHttpClient.close()).called(1);
+      });
+
+      test('can be called multiple times safely', () {
+        service.dispose();
+        service.dispose();
+
+        verify(() => mockHttpClient.close()).called(2);
+      });
+    });
+
+    group('interface methods', () {
+      test('implements all required ZcashParamsDownloadService methods', () {
+        expect(service, isA<ZcashParamsDownloadService>());
+
+        // Verify that all interface methods are implemented
+        expect(service.downloadMissingFiles, isA<Function>());
+        expect(service.getMissingFiles, isA<Function>());
+        expect(service.ensureDirectoryExists, isA<Function>());
+        expect(service.validateFiles, isA<Function>());
+        expect(service.validateFileHash, isA<Function>());
+        expect(service.getFileHash, isA<Function>());
+        expect(service.getRemoteFileSize, isA<Function>());
+        expect(service.clearFiles, isA<Function>());
+        expect(service.dispose, isA<Function>());
+      });
+    });
+
+    group('constructor', () {
+      test('creates instance with default HTTP client when none provided', () {
+        final serviceWithDefaults = DefaultZcashParamsDownloadService();
+        expect(serviceWithDefaults, isA<DefaultZcashParamsDownloadService>());
+        serviceWithDefaults.dispose();
+      });
+
+      test('creates instance with provided HTTP client', () {
+        final customClient = MockHttpClient();
+        final serviceWithCustomClient = DefaultZcashParamsDownloadService(
+          httpClient: customClient,
+        );
+
+        expect(
+          serviceWithCustomClient,
+          isA<DefaultZcashParamsDownloadService>(),
+        );
+
+        serviceWithCustomClient.dispose();
+        verify(() => customClient.close()).called(1);
+      });
+    });
+
+    group('edge cases and error handling', () {
+      test('handles null or malformed URLs gracefully', () async {
+        await expectLater(service.getRemoteFileSize(''), completes);
+      });
+
+      test('handles config with no param files', () async {
+        final emptyConfig = testConfig.copyWith(paramFiles: []);
+
+        File fileFactory(String path) => MockFile();
+
+        final missingFiles = await service.getMissingFiles(
+          '/test/dir',
+          fileFactory,
+          emptyConfig,
+        );
+
+        expect(missingFiles, isEmpty);
+      });
+
+      test('handles very long file paths', () async {
+        final longPath = 'a' * 1000; // Very long path
+
+        File fileFactory(String path) {
+          final file = MockFile();
+          when(() => file.exists()).thenAnswer((_) async => false);
+          when(() => file.path).thenReturn(path);
+          return file;
+        }
+
+        final hash = await service.getFileHash(longPath, fileFactory);
+        expect(hash, isNull);
+      });
+    });
+  });
+}
diff --git a/packages/komodo_defi_sdk/test/zcash_params/test_helpers/mock_classes.dart b/packages/komodo_defi_sdk/test/zcash_params/test_helpers/mock_classes.dart
new file mode 100644
index 000000000..5ea2377a5
--- /dev/null
+++ b/packages/komodo_defi_sdk/test/zcash_params/test_helpers/mock_classes.dart
@@ -0,0 +1,371 @@
+import 'dart:async';
+import 'dart:io';
+import 'dart:typed_data';
+
+import 'package:http/http.dart' as http;
+import 'package:http/src/byte_stream.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/services/zcash_params_download_service.dart';
+import 'package:mocktail/mocktail.dart';
+
+/// Mock HTTP client for testing download functionality
+class MockHttpClient extends Mock implements http.Client {}
+
+/// Mock HTTP request for testing
+class MockHttpRequest extends Mock implements http.BaseRequest {}
+
+/// Mock HTTP response for testing
+class MockHttpResponse extends Mock implements http.Response {}
+
+/// Mock HTTP streamed response for testing download streams
+class MockStreamedResponse extends Mock implements http.StreamedResponse {}
+
+/// Mock directory for testing file system operations
+class MockDirectory extends Mock implements Directory {}
+
+/// Mock file for testing file operations
+class MockFile extends Mock implements File {}
+
+/// Mock file stat for testing file properties
+class MockFileStat extends Mock implements FileStat {}
+
+/// Mock IOSink for testing file writing
+class MockIOSink extends Mock implements IOSink {}
+
+/// Mock ZCash parameters download service for testing
+class MockZcashParamsDownloadService extends Mock
+    implements ZcashParamsDownloadService {}
+
+/// Helper class to create test HTTP responses
+class TestHttpResponse {
+  /// Creates a successful HTTP response with given data
+  static http.Response success(List<int> bodyBytes, {int statusCode = 200}) {
+    final response = MockHttpResponse();
+    when(() => response.statusCode).thenReturn(statusCode);
+    when(() => response.bodyBytes).thenReturn(Uint8List.fromList(bodyBytes));
+    when(() => response.body).thenReturn(String.fromCharCodes(bodyBytes));
+    return response;
+  }
+
+  /// Creates a failed HTTP response with given status code
+  static http.Response failure(int statusCode, [String? body]) {
+    final response = MockHttpResponse();
+    when(() => response.statusCode).thenReturn(statusCode);
+    when(() => response.bodyBytes).thenReturn(Uint8List.fromList([]));
+    when(() => response.body).thenReturn(body ?? '');
+    return response;
+  }
+
+  /// Creates a streamed response for testing streaming downloads
+  static http.StreamedResponse streamedSuccess(
+    List<int> data, {
+    int statusCode = 200,
+    int? contentLength,
+  }) {
+    final response = MockStreamedResponse();
+    when(() => response.statusCode).thenReturn(statusCode);
+    when(() => response.contentLength).thenReturn(contentLength ?? data.length);
+
+    // Create a stream that emits the data in chunks
+    final controller = StreamController<List<int>>();
+    const chunkSize = 1024;
+
+    // Emit data in chunks to simulate real download
+    Future.delayed(Duration.zero, () {
+      for (int i = 0; i < data.length; i += chunkSize) {
+        final end = (i + chunkSize < data.length) ? i + chunkSize : data.length;
+        controller.add(data.sublist(i, end));
+      }
+      controller.close();
+    });
+
+    when(
+      () => response.stream,
+    ).thenAnswer((_) => ByteStream(controller.stream));
+    return response;
+  }
+
+  /// Creates a streamed response that fails during download
+  static http.StreamedResponse streamedFailure(int statusCode) {
+    final response = MockStreamedResponse();
+    when(() => response.statusCode).thenReturn(statusCode);
+    when(() => response.contentLength).thenReturn(null);
+    when(() => response.stream).thenAnswer(
+      (_) => ByteStream(
+        Stream.error(HttpException('Download failed with status $statusCode')),
+      ),
+    );
+    return response;
+  }
+}
+
+/// Helper class to set up mock file system operations
+class TestFileSystem {
+  /// Sets up a mock directory that exists and can be created
+  static void setupMockDirectory(
+    MockDirectory directory, {
+    bool exists = true,
+    bool canCreate = true,
+  }) {
+    when(() => directory.exists()).thenAnswer((_) async => exists);
+
+    if (canCreate) {
+      when(
+        () => directory.create(recursive: any(named: 'recursive')),
+      ).thenAnswer((_) async => directory);
+    } else {
+      when(
+        () => directory.create(recursive: any(named: 'recursive')),
+      ).thenThrow(FileSystemException('Cannot create directory'));
+    }
+
+    when(
+      () => directory.delete(recursive: any(named: 'recursive')),
+    ).thenAnswer((_) async => directory);
+  }
+
+  /// Sets up a mock file with specified properties
+  static void setupMockFile(
+    MockFile file, {
+    bool exists = false,
+    int size = 0,
+    bool canWrite = true,
+    bool canDelete = true,
+  }) {
+    when(() => file.exists()).thenAnswer((_) async => exists);
+
+    final stat = MockFileStat();
+    when(() => stat.size).thenReturn(size);
+    when(() => file.stat()).thenAnswer((_) async => stat);
+
+    if (canWrite) {
+      final sink = MockIOSink();
+      when(() => sink.add(any())).thenReturn(null);
+      when(() => sink.close()).thenAnswer((_) async {});
+      when(() => file.openWrite()).thenReturn(sink);
+      when(() => file.writeAsBytes(any())).thenAnswer((_) async => file);
+    } else {
+      when(
+        () => file.openWrite(),
+      ).thenThrow(FileSystemException('Cannot write to file'));
+      when(
+        () => file.writeAsBytes(any()),
+      ).thenThrow(FileSystemException('Cannot write to file'));
+    }
+
+    if (canDelete) {
+      when(() => file.delete()).thenAnswer((_) async => file);
+    } else {
+      when(
+        () => file.delete(),
+      ).thenThrow(FileSystemException('Cannot delete file'));
+    }
+  }
+
+  /// Sets up mock environment variables for testing
+  static void setupMockEnvironment(Map<String, String> environment) {
+    // Note: In real tests, you would use a package like `platform`
+    // that allows mocking Platform.environment
+    // For now, this is a placeholder for the pattern
+  }
+}
+
+/// Helper class for creating test data
+class TestData {
+  /// Sample ZCash parameter file data (small for testing)
+  static List<int> get sampleParamData => List.generate(1024, (i) => i % 256);
+
+  /// Large sample data for testing progress reporting
+  static List<int> get largeSampleData => List.generate(
+    10 * 1024 * 1024, // 10 MB
+    (i) => i % 256,
+  );
+
+  /// Creates test data of specified size
+  static List<int> createTestData(int sizeInBytes) {
+    return List.generate(sizeInBytes, (i) => i % 256);
+  }
+
+  /// Sample file names for testing
+  static const List<String> sampleFileNames = [
+    'test-spend.params',
+    'test-output.params',
+    'test-groth16.params',
+  ];
+
+  /// Sample URLs for testing
+  static const List<String> sampleUrls = [
+    'https://test.example.com/downloads/',
+    'https://backup.example.com/downloads/',
+  ];
+
+  /// Sample Windows APPDATA path
+  static const String sampleWindowsAppData =
+      r'C:\Users\TestUser\AppData\Roaming';
+
+  /// Sample Unix HOME path
+  static const String sampleUnixHome = '/home/testuser';
+
+  /// Sample macOS HOME path
+  static const String sampleMacOSHome = '/Users/testuser';
+}
+
+/// Helper class for testing download progress
+class ProgressCapture {
+  final List<double> _percentages = [];
+  final List<String> _fileNames = [];
+  final List<int> _downloadedBytes = [];
+  final List<int> _totalBytes = [];
+
+  /// Captures progress from a download progress stream
+  StreamSubscription<T> captureProgress<T>(
+    Stream<T> stream,
+    void Function(T) captureFunction,
+  ) {
+    return stream.listen(captureFunction);
+  }
+
+  /// Records a progress event
+  void recordProgress(String fileName, int downloaded, int total) {
+    _fileNames.add(fileName);
+    _downloadedBytes.add(downloaded);
+    _totalBytes.add(total);
+    _percentages.add(total > 0 ? (downloaded / total) * 100 : 0);
+  }
+
+  /// Gets all recorded percentages
+  List<double> get percentages => List.unmodifiable(_percentages);
+
+  /// Gets all recorded file names
+  List<String> get fileNames => List.unmodifiable(_fileNames);
+
+  /// Gets all recorded downloaded byte counts
+  List<int> get downloadedBytes => List.unmodifiable(_downloadedBytes);
+
+  /// Gets all recorded total byte counts
+  List<int> get totalBytes => List.unmodifiable(_totalBytes);
+
+  /// Clears all recorded data
+  void clear() {
+    _percentages.clear();
+    _fileNames.clear();
+    _downloadedBytes.clear();
+    _totalBytes.clear();
+  }
+
+  /// Gets the last recorded percentage
+  double? get lastPercentage =>
+      _percentages.isNotEmpty ? _percentages.last : null;
+
+  /// Checks if progress was reported for a specific file
+  bool hasProgressFor(String fileName) => _fileNames.contains(fileName);
+
+  /// Gets progress count for a specific file
+  int getProgressCount(String fileName) {
+    return _fileNames.where((name) => name == fileName).length;
+  }
+}
+
+/// Helper for testing error scenarios
+class ErrorScenarios {
+  /// Creates an HTTP exception
+  static HttpException httpException(String message) {
+    return HttpException(message);
+  }
+
+  /// Creates a file system exception
+  static FileSystemException fileSystemException(String message) {
+    return FileSystemException(message);
+  }
+
+  /// Creates a timeout exception
+  static TimeoutException timeoutException(String message) {
+    return TimeoutException(message);
+  }
+
+  /// Creates a socket exception
+  static SocketException socketException(String message) {
+    return SocketException(message);
+  }
+}
+
+/// Test utilities for common operations
+class TestUtils {
+  /// Waits for a stream to emit a specific number of events
+  static Future<List<T>> collectStreamEvents<T>(
+    Stream<T> stream,
+    int expectedCount, {
+    Duration timeout = const Duration(seconds: 5),
+  }) async {
+    final events = <T>[];
+    final completer = Completer<List<T>>();
+    late StreamSubscription<T> subscription;
+
+    subscription = stream.listen(
+      (event) {
+        events.add(event);
+        if (events.length >= expectedCount) {
+          subscription.cancel();
+          completer.complete(events);
+        }
+      },
+      onError: (Object error) {
+        subscription.cancel();
+        completer.completeError(error);
+      },
+      onDone: () {
+        subscription.cancel();
+        completer.complete(events);
+      },
+    );
+
+    return completer.future.timeout(timeout);
+  }
+
+  /// Creates a temporary directory for testing
+  static Future<Directory> createTempDirectory() async {
+    final tempDir = await Directory.systemTemp.createTemp('zcash_params_test');
+    return tempDir;
+  }
+
+  /// Cleans up a temporary directory
+  static Future<void> cleanupTempDirectory(Directory dir) async {
+    if (await dir.exists()) {
+      await dir.delete(recursive: true);
+    }
+  }
+
+  /// Creates a temporary file with specified content
+  static Future<File> createTempFile(
+    Directory parent,
+    String name,
+    List<int> content,
+  ) async {
+    final file = File('${parent.path}/$name');
+    await file.writeAsBytes(content);
+    return file;
+  }
+
+  /// Verifies that a future completes within a specified time
+  static Future<T> expectTimely<T>(
+    Future<T> future, {
+    Duration timeout = const Duration(seconds: 5),
+  }) {
+    return future.timeout(timeout);
+  }
+
+  /// Verifies that a future throws a specific exception type
+  static Future<void> expectThrows<T extends Exception>(
+    Future<void> future,
+  ) async {
+    try {
+      await future;
+      throw AssertionError('Expected exception of type $T but none was thrown');
+    } catch (e) {
+      if (e is! T) {
+        throw AssertionError(
+          'Expected exception of type $T but got ${e.runtimeType}',
+        );
+      }
+    }
+  }
+}
diff --git a/packages/komodo_defi_sdk/test/zcash_params/zcash_params_downloader_factory_test.dart b/packages/komodo_defi_sdk/test/zcash_params/zcash_params_downloader_factory_test.dart
new file mode 100644
index 000000000..12d687b72
--- /dev/null
+++ b/packages/komodo_defi_sdk/test/zcash_params/zcash_params_downloader_factory_test.dart
@@ -0,0 +1,264 @@
+import 'package:test/test.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/zcash_params_downloader_factory.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/models/download_result.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/platforms/web_zcash_params_downloader.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/platforms/windows_zcash_params_downloader.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/platforms/unix_zcash_params_downloader.dart';
+import 'package:komodo_defi_sdk/src/zcash_params/platforms/mobile_zcash_params_downloader.dart';
+
+void main() {
+  group('ZcashParamsDownloaderFactory', () {
+    group('create', () {
+      test('creates WebZcashParamsDownloader on web platform', () {
+        // This test will only run on web platform in actual testing
+        // For unit testing, we test the factory logic through createForPlatform
+        final downloader = ZcashParamsDownloaderFactory.createForPlatform(
+          ZcashParamsPlatform.web,
+        );
+
+        expect(downloader, isA<WebZcashParamsDownloader>());
+      });
+
+      test('creates WindowsZcashParamsDownloader for Windows platform', () {
+        final downloader = ZcashParamsDownloaderFactory.createForPlatform(
+          ZcashParamsPlatform.windows,
+        );
+
+        expect(downloader, isA<WindowsZcashParamsDownloader>());
+      });
+
+      test('creates UnixZcashParamsDownloader for Unix platform', () {
+        final downloader = ZcashParamsDownloaderFactory.createForPlatform(
+          ZcashParamsPlatform.unix,
+        );
+
+        expect(downloader, isA<UnixZcashParamsDownloader>());
+      });
+
+      test('creates MobileZcashParamsDownloader for Mobile platform', () {
+        final downloader = ZcashParamsDownloaderFactory.createForPlatform(
+          ZcashParamsPlatform.mobile,
+        );
+
+        expect(downloader, isA<MobileZcashParamsDownloader>());
+      });
+    });
+
+    group('createForPlatform', () {
+      test('creates correct downloader for each platform type', () {
+        for (final platform in ZcashParamsPlatform.values) {
+          final downloader = ZcashParamsDownloaderFactory.createForPlatform(
+            platform,
+          );
+
+          switch (platform) {
+            case ZcashParamsPlatform.web:
+              expect(downloader, isA<WebZcashParamsDownloader>());
+              break;
+            case ZcashParamsPlatform.windows:
+              expect(downloader, isA<WindowsZcashParamsDownloader>());
+              break;
+            case ZcashParamsPlatform.mobile:
+              expect(downloader, isA<MobileZcashParamsDownloader>());
+              break;
+            case ZcashParamsPlatform.unix:
+              expect(downloader, isA<UnixZcashParamsDownloader>());
+              break;
+          }
+        }
+      });
+
+      test('creates different instances for multiple calls', () {
+        final downloader1 = ZcashParamsDownloaderFactory.createForPlatform(
+          ZcashParamsPlatform.web,
+        );
+        final downloader2 = ZcashParamsDownloaderFactory.createForPlatform(
+          ZcashParamsPlatform.web,
+        );
+
+        expect(downloader1, isNot(same(downloader2)));
+        expect(downloader1.runtimeType, equals(downloader2.runtimeType));
+      });
+    });
+
+    group('detectPlatform', () {
+      test('returns web for web platform when kIsWeb is true', () {
+        // Note: This test will behave differently based on the actual platform
+        // In a real test environment, you would mock kIsWeb
+        final detected = ZcashParamsDownloaderFactory.detectPlatform();
+
+        // Verify it returns a valid platform
+        expect(ZcashParamsPlatform.values.contains(detected), isTrue);
+      });
+
+      test('detection is consistent', () {
+        final platform1 = ZcashParamsDownloaderFactory.detectPlatform();
+        final platform2 = ZcashParamsDownloaderFactory.detectPlatform();
+
+        expect(platform1, equals(platform2));
+      });
+    });
+
+    // (Redundant test removed; platform-specific assertions exist below.)
+
+    group('getDefaultParamsPath', () {
+      test('returns path for platforms that support it', () async {
+        // Test with Unix platform (should return a path)
+        final downloader = ZcashParamsDownloaderFactory.createForPlatform(
+          ZcashParamsPlatform.unix,
+        );
+
+        expect(downloader, isA<UnixZcashParamsDownloader>());
+
+        // Note: In a real test, environment variables would be mocked.
+        final path = await downloader.getParamsPath();
+        expect(path, anyOf(isA<String>(), isNull));
+      });
+
+      test('returns null for web platform', () async {
+        final downloader = ZcashParamsDownloaderFactory.createForPlatform(
+          ZcashParamsPlatform.web,
+        );
+
+        final path = await downloader.getParamsPath();
+        expect(path, isNull);
+      });
+    });
+  });
+
+  group('ZcashParamsPlatform', () {
+    group('displayName', () {
+      test('returns correct display names', () {
+        expect(ZcashParamsPlatform.web.displayName, equals('Web'));
+        expect(ZcashParamsPlatform.windows.displayName, equals('Windows'));
+        expect(ZcashParamsPlatform.mobile.displayName, equals('Mobile'));
+        expect(ZcashParamsPlatform.unix.displayName, equals('Unix/Linux'));
+      });
+    });
+
+    group('requiresDownload', () {
+      test('returns correct download requirements', () {
+        expect(ZcashParamsPlatform.web.requiresDownload, isFalse);
+        expect(ZcashParamsPlatform.windows.requiresDownload, isTrue);
+        expect(ZcashParamsPlatform.mobile.requiresDownload, isTrue);
+        expect(ZcashParamsPlatform.unix.requiresDownload, isTrue);
+      });
+    });
+
+    group('defaultDirectoryName', () {
+      test('returns correct directory names', () {
+        expect(ZcashParamsPlatform.web.defaultDirectoryName, isNull);
+        expect(
+          ZcashParamsPlatform.windows.defaultDirectoryName,
+          equals('ZcashParams'),
+        );
+        expect(
+          ZcashParamsPlatform.mobile.defaultDirectoryName,
+          equals('ZcashParams'),
+        );
+        expect(ZcashParamsPlatform.unix.defaultDirectoryName, isNull);
+      });
+    });
+  });
+
+  group('edge cases', () {
+    test('factory methods handle multiple rapid calls', () {
+      final downloaders = <Object>[];
+
+      // Create multiple downloaders rapidly
+      for (int i = 0; i < 10; i++) {
+        final downloader = ZcashParamsDownloaderFactory.createForPlatform(
+          ZcashParamsPlatform.web,
+        );
+        downloaders.add(downloader);
+      }
+
+      // All should be of the same type but different instances
+      expect(downloaders.length, equals(10));
+      for (final downloader in downloaders) {
+        expect(downloader, isA<WebZcashParamsDownloader>());
+      }
+    });
+
+    test('platform detection is deterministic', () {
+      final detections = <ZcashParamsPlatform>[];
+
+      // Detect platform multiple times
+      for (int i = 0; i < 5; i++) {
+        detections.add(ZcashParamsDownloaderFactory.detectPlatform());
+      }
+
+      // All detections should be the same
+      final firstDetection = detections.first;
+      for (final detection in detections) {
+        expect(detection, equals(firstDetection));
+      }
+    });
+
+    test('enum values are complete', () {
+      // Ensure all enum values are handled in the factory
+      expect(ZcashParamsPlatform.values.length, equals(4));
+      expect(ZcashParamsPlatform.values, contains(ZcashParamsPlatform.web));
+      expect(ZcashParamsPlatform.values, contains(ZcashParamsPlatform.windows));
+      expect(ZcashParamsPlatform.values, contains(ZcashParamsPlatform.mobile));
+      expect(ZcashParamsPlatform.values, contains(ZcashParamsPlatform.unix));
+    });
+  });
+
+  group('integration tests', () {
+    test('created downloaders have expected interfaces', () async {
+      for (final platform in ZcashParamsPlatform.values) {
+        final downloader = ZcashParamsDownloaderFactory.createForPlatform(
+          platform,
+        );
+
+        // Verify all downloaders implement the expected interface
+        expect(downloader.downloadParams, isA<Function>());
+        expect(downloader.getParamsPath, isA<Function>());
+        expect(downloader.areParamsAvailable, isA<Function>());
+        expect(downloader.downloadProgress, isA<Stream>());
+        expect(downloader.cancelDownload, isA<Function>());
+        expect(downloader.validateParams, isA<Function>());
+        expect(downloader.clearParams, isA<Function>());
+      }
+    });
+
+    test('web downloader behaves as expected', () async {
+      final downloader =
+          ZcashParamsDownloaderFactory.createForPlatform(
+                ZcashParamsPlatform.web,
+              )
+              as WebZcashParamsDownloader;
+
+      // Web downloader should immediately return success; no local path is available (getParamsPath returns null)
+      final result = await downloader.downloadParams();
+      expect(result, isA<DownloadResultSuccess>());
+      result.when(
+        success: (paramsPath) {
+          expect(paramsPath, isNotNull);
+        },
+        failure: (error) {
+          fail('Expected success but got failure: $error');
+        },
+      );
+
+      final path = await downloader.getParamsPath();
+      expect(path, isNull);
+
+      final available = await downloader.areParamsAvailable();
+      expect(available, isTrue);
+
+      final cancelled = await downloader.cancelDownload();
+      expect(cancelled, isFalse);
+
+      final validated = await downloader.validateParams();
+      expect(validated, isTrue);
+
+      final cleared = await downloader.clearParams();
+      expect(cleared, isTrue);
+
+      // Clean up
+      downloader.dispose();
+    });
+  });
+}
diff --git a/packages/komodo_defi_types/lib/src/activation/activation_progress.dart b/packages/komodo_defi_types/lib/src/activation/activation_progress.dart
index d027b7ecd..2234967bd 100644
--- a/packages/komodo_defi_types/lib/src/activation/activation_progress.dart
+++ b/packages/komodo_defi_types/lib/src/activation/activation_progress.dart
@@ -3,6 +3,66 @@ import 'package:komodo_defi_types/komodo_defi_type_utils.dart';
 import 'package:komodo_defi_types/komodo_defi_types.dart';
 import 'package:meta/meta.dart';
 
+/// Canonical activation steps used across strategies
+enum ActivationStep {
+  planning,
+  strategySelection,
+  initialization,
+  validation,
+  platformSetup,
+  platformActivation,
+  tokenActivation,
+  activation,
+  verification,
+  database,
+  connection,
+  electrumConnection,
+  blockchainSync,
+  txScan,
+  contracts,
+  scanning,
+  processing,
+  error,
+  complete,
+  init,
+  groupStart,
+  unknown,
+}
+
+extension ActivationStepSerialization on ActivationStep {
+  String get serializedName {
+    switch (this) {
+      case ActivationStep.platformSetup:
+        return 'platform_setup';
+      case ActivationStep.platformActivation:
+        return 'platform_activation';
+      case ActivationStep.tokenActivation:
+        return 'token_activation';
+      case ActivationStep.electrumConnection:
+        return 'electrum_connection';
+      case ActivationStep.blockchainSync:
+        return 'blockchain_sync';
+      case ActivationStep.txScan:
+        return 'tx_scan';
+      case ActivationStep.strategySelection:
+        return 'strategy_selection';
+      case ActivationStep.groupStart:
+        return 'group_start';
+      default:
+        // For other enums, the enum name matches the desired string
+        return name;
+    }
+  }
+}
+
+/// Typed UI/control signals that may be emitted alongside progress for
+/// semantic intent (avoid using additionalInfo for control flow).
+enum ActivationUiSignal { awaitingUserInput }
+
+extension ActivationUiSignalSerialization on ActivationUiSignal {
+  String get serializedName => name;
+}
+
 /// Represents the current state and progress of an activation operation
 @immutable
 class ActivationProgress extends Equatable {
@@ -21,7 +81,7 @@ class ActivationProgress extends Equatable {
       progressPercentage: 100,
       isComplete: true,
       progressDetails: details?.copyWith(
-        currentStep: 'complete',
+        currentStep: ActivationStep.complete,
         completedAt: DateTime.now(),
       ),
     );
@@ -36,7 +96,7 @@ class ActivationProgress extends Equatable {
       progressPercentage: 100,
       isComplete: true,
       progressDetails: ActivationProgressDetails(
-        currentStep: 'complete',
+        currentStep: ActivationStep.complete,
         stepCount: 1,
         additionalInfo: {
           'primaryAsset': assetName,
@@ -60,7 +120,7 @@ class ActivationProgress extends Equatable {
       errorMessage: message,
       isComplete: true,
       progressDetails: ActivationProgressDetails(
-        currentStep: 'error',
+        currentStep: ActivationStep.error,
         stepCount: 1,
         errorCode: errorCode,
         errorDetails: details,
@@ -108,21 +168,20 @@ class ActivationProgress extends Equatable {
 
   @override
   List<Object?> get props => [
-        status,
-        progressPercentage,
-        isComplete,
-        errorMessage,
-        progressDetails,
-      ];
+    status,
+    progressPercentage,
+    isComplete,
+    errorMessage,
+    progressDetails,
+  ];
 
   JsonMap toJson() => {
-        'status': status,
-        if (progressPercentage != null)
-          'progressPercentage': progressPercentage,
-        'isComplete': isComplete,
-        if (errorMessage != null) 'errorMessage': errorMessage,
-        if (progressDetails != null) 'details': progressDetails!.toJson(),
-      };
+    'status': status,
+    if (progressPercentage != null) 'progressPercentage': progressPercentage,
+    'isComplete': isComplete,
+    if (errorMessage != null) 'errorMessage': errorMessage,
+    if (progressDetails != null) 'details': progressDetails!.toJson(),
+  };
 }
 
 /// Detailed information about the activation progress
@@ -132,6 +191,8 @@ class ActivationProgressDetails extends Equatable {
     required this.currentStep,
     required this.stepCount,
     this.additionalInfo = const {},
+    this.uiSignal,
+    this.deadlineAt,
     this.errorCode,
     this.errorDetails,
     this.stackTrace,
@@ -139,9 +200,11 @@ class ActivationProgressDetails extends Equatable {
     this.completedAt,
   });
 
-  final String currentStep;
+  final ActivationStep currentStep;
   final int stepCount;
   final JsonMap additionalInfo;
+  final ActivationUiSignal? uiSignal;
+  final DateTime? deadlineAt;
   final String? errorCode;
   final String? errorDetails;
   final String? stackTrace;
@@ -154,9 +217,11 @@ class ActivationProgressDetails extends Equatable {
   }
 
   ActivationProgressDetails copyWith({
-    String? currentStep,
+    ActivationStep? currentStep,
     int? stepCount,
     JsonMap? additionalInfo,
+    ActivationUiSignal? uiSignal,
+    DateTime? deadlineAt,
     String? errorCode,
     String? errorDetails,
     String? stackTrace,
@@ -167,6 +232,8 @@ class ActivationProgressDetails extends Equatable {
       currentStep: currentStep ?? this.currentStep,
       stepCount: stepCount ?? this.stepCount,
       additionalInfo: additionalInfo ?? this.additionalInfo,
+      uiSignal: uiSignal ?? this.uiSignal,
+      deadlineAt: deadlineAt ?? this.deadlineAt,
       errorCode: errorCode ?? this.errorCode,
       errorDetails: errorDetails ?? this.errorDetails,
       stackTrace: stackTrace ?? this.stackTrace,
@@ -177,27 +244,31 @@ class ActivationProgressDetails extends Equatable {
 
   @override
   List<Object?> get props => [
-        currentStep,
-        stepCount,
-        additionalInfo,
-        errorCode,
-        errorDetails,
-        stackTrace,
-        startedAt,
-        completedAt,
-      ];
+    currentStep,
+    stepCount,
+    additionalInfo,
+    uiSignal,
+    deadlineAt,
+    errorCode,
+    errorDetails,
+    stackTrace,
+    startedAt,
+    completedAt,
+  ];
 
   JsonMap toJson() => {
-        'currentStep': currentStep,
-        'stepCount': stepCount,
-        'additionalInfo': additionalInfo,
-        if (errorCode != null) 'errorCode': errorCode,
-        if (errorDetails != null) 'errorDetails': errorDetails,
-        if (stackTrace != null) 'stackTrace': stackTrace,
-        if (startedAt != null) 'startedAt': startedAt!.toIso8601String(),
-        if (completedAt != null) 'completedAt': completedAt!.toIso8601String(),
-        if (duration != null) 'duration': duration!.inMilliseconds,
-      };
+    'currentStep': currentStep.serializedName,
+    'stepCount': stepCount,
+    'additionalInfo': additionalInfo,
+    'uiSignal': ?uiSignal?.serializedName,
+    'deadlineAt': ?deadlineAt?.toIso8601String(),
+    'errorCode': ?errorCode,
+    'errorDetails': ?errorDetails,
+    'stackTrace': ?stackTrace,
+    'startedAt': ?startedAt?.toIso8601String(),
+    'completedAt': ?completedAt?.toIso8601String(),
+    if (duration != null) 'duration': duration!.inMilliseconds,
+  };
 }
 
 /// Helper for tracking multi-asset activation progress
@@ -213,25 +284,23 @@ class BatchActivationProgress {
       _startTimes[asset.id] = DateTime.now();
     }
 
-    final details = progress.progressDetails?.copyWith(
-          startedAt: _startTimes[asset.id],
-        ) ??
+    final details =
+        progress.progressDetails?.copyWith(startedAt: _startTimes[asset.id]) ??
         ActivationProgressDetails(
-          currentStep: 'unknown',
+          currentStep: ActivationStep.unknown,
           stepCount: 1,
           startedAt: _startTimes[asset.id],
         );
 
-    _progress[asset.id] = progress.copyWith(
-      progressDetails: details,
-    );
+    _progress[asset.id] = progress.copyWith(progressDetails: details);
   }
 
   double get overallProgress {
     if (_progress.isEmpty) return 0;
 
-    final progressValues =
-        _progress.values.map((p) => p.progressPercentage ?? 0).toList();
+    final progressValues = _progress.values
+        .map((p) => p.progressPercentage ?? 0)
+        .toList();
 
     return progressValues.reduce((a, b) => a + b) / assets.length;
   }
@@ -253,12 +322,12 @@ class BatchActivationProgress {
       .toList();
 
   JsonMap toJson() => {
-        'overallProgress': overallProgress,
-        'isComplete': isComplete,
-        'pendingAssets': pendingAssets,
-        'failedAssets': failedAssets,
-        'details': _progress.map(
-          (id, progress) => MapEntry(id.toString(), progress.toJson()),
-        ),
-      };
+    'overallProgress': overallProgress,
+    'isComplete': isComplete,
+    'pendingAssets': pendingAssets,
+    'failedAssets': failedAssets,
+    'details': _progress.map(
+      (id, progress) => MapEntry(id.toString(), progress.toJson()),
+    ),
+  };
 }
diff --git a/packages/komodo_defi_types/lib/src/protocols/zhtlc/zhtlc_protocol.dart b/packages/komodo_defi_types/lib/src/protocols/zhtlc/zhtlc_protocol.dart
index 099640071..65ceac9f7 100644
--- a/packages/komodo_defi_types/lib/src/protocols/zhtlc/zhtlc_protocol.dart
+++ b/packages/komodo_defi_types/lib/src/protocols/zhtlc/zhtlc_protocol.dart
@@ -2,10 +2,7 @@ import 'package:komodo_defi_types/komodo_defi_type_utils.dart';
 import 'package:komodo_defi_types/komodo_defi_types.dart';
 
 class ZhtlcProtocol extends ProtocolClass {
-  ZhtlcProtocol._({
-    required super.subClass,
-    required super.config,
-  });
+  ZhtlcProtocol._({required super.subClass, required super.config});
 
   factory ZhtlcProtocol.fromJson(JsonMap json) {
     _validateZhtlcConfig(json);
@@ -25,23 +22,21 @@ class ZhtlcProtocol extends ProtocolClass {
   bool get isMemoSupported => true;
 
   static void _validateZhtlcConfig(JsonMap json) {
-    final requiredFields = {
-      // 'zcash_params_path': 'Zcash parameters path',
-      'electrum': 'Electrum servers',
-    };
-
-    for (final field in requiredFields.entries) {
-      if (!json.containsKey(field.key)) {
-        throw MissingProtocolFieldException(
-          field.value,
-          field.key,
-        );
-      }
+    // ZHTLC can operate in Light mode using lightwalletd and optionally electrum servers.
+    // We require at least one of electrum servers or light wallet d servers to be present.
+
+    // Backward compatibility: some configs provided 'electrum' under config used by Electrum mode
+    final hasElectrum = json.containsKey('electrum') || json.containsKey('electrum_servers');
+    final hasLightWalletD = json.containsKey('light_wallet_d_servers');
+
+    if (!hasElectrum && !hasLightWalletD) {
+      throw MissingProtocolFieldException(
+        'Electrum or LightwalletD servers',
+        'electrum | light_wallet_d_servers',
+      );
     }
   }
 
   String get zcashParamsPath =>
-
-      //TODO! config.value<String>('zcash_params_path');
-      'PLACEHOLDER_STRING_FOR_ZCASH_PARAMS_PATH';
+      config.valueOrNull<String>('zcash_params_path') ?? '';
 }
diff --git a/packages/komodo_defi_types/lib/src/transactions/transaction_history_strategy.dart b/packages/komodo_defi_types/lib/src/transactions/transaction_history_strategy.dart
index 9bdd8d083..86744414e 100644
--- a/packages/komodo_defi_types/lib/src/transactions/transaction_history_strategy.dart
+++ b/packages/komodo_defi_types/lib/src/transactions/transaction_history_strategy.dart
@@ -34,22 +34,4 @@ abstract class TransactionHistoryStrategy {
       );
     }
   }
-
-  /// Helper method to convert legacy pagination parameters to TransactionPagination
-  TransactionPagination _getLegacyPagination({
-    String? fromId,
-    int? pageNumber,
-    int limit = 10,
-  }) {
-    if (fromId != null) {
-      return TransactionBasedPagination(
-        fromId: fromId,
-        itemCount: limit,
-      );
-    }
-    return PagePagination(
-      pageNumber: pageNumber ?? 1,
-      itemsPerPage: limit,
-    );
-  }
 }
diff --git a/packages/komodo_defi_types/lib/src/utils/json_type_utils.dart b/packages/komodo_defi_types/lib/src/utils/json_type_utils.dart
index ee957e746..a19875c15 100644
--- a/packages/komodo_defi_types/lib/src/utils/json_type_utils.dart
+++ b/packages/komodo_defi_types/lib/src/utils/json_type_utils.dart
@@ -126,6 +126,13 @@ T? _traverseJson<T>(
         if (parsed != null) return parsed as T;
       }
 
+      // Rounding precision loss is not a concern when converting int to String
+      // This is safe because int to String conversion is always exact.
+      // “For any int i, it is guaranteed that i == int.parse(i.toString()).”
+      if (T == String && value is int) {
+        return value.toString() as T;
+      }
+
       // Handle lossy casts if allowed
       if (lossyCast && T == String && value is num) {
         return value.toString() as T;
diff --git a/packages/komodo_ui/lib/src/core/inputs/address_select_input.dart b/packages/komodo_ui/lib/src/core/inputs/address_select_input.dart
index f07b8af33..539153484 100644
--- a/packages/komodo_ui/lib/src/core/inputs/address_select_input.dart
+++ b/packages/komodo_ui/lib/src/core/inputs/address_select_input.dart
@@ -66,43 +66,43 @@ class AddressSelectInput extends StatelessWidget {
               ),
               const SizedBox(width: 12),
               Expanded(
-                child:
-                    selectedAddress != null
-                        ? Row(
-                          children: [
-                            Text(
-                              selectedAddress!.formatted,
-                              style: theme.textTheme.bodyMedium?.copyWith(
-                                fontWeight: FontWeight.w500,
-                                letterSpacing: 0.5,
-                              ),
+                child: selectedAddress != null
+                    ? Row(
+                        children: [
+                          Text(
+                            selectedAddress!.formatted,
+                            style: theme.textTheme.bodyMedium?.copyWith(
+                              fontWeight: FontWeight.w500,
+                              letterSpacing: 0.5,
                             ),
-                            const SizedBox(width: 4),
-                            if (verified?.call(selectedAddress!) ?? false) ...[
-                              Icon(
-                                Icons.verified,
-                                size: 16,
-                                color: theme.colorScheme.primary,
-                              ),
-                              const SizedBox(width: 8),
-                            ],
-                            Text(
-                              '(${selectedAddress!.balance.spendable} $assetName)',
-                              style: theme.textTheme.bodySmall?.copyWith(
-                                color: theme.colorScheme.onSurface.withOpacity(
-                                  0.7,
-                                ),
-                              ),
+                          ),
+                          const SizedBox(width: 4),
+                          if (verified?.call(selectedAddress!) ?? false) ...[
+                            Icon(
+                              Icons.verified,
+                              size: 16,
+                              color: theme.colorScheme.primary,
                             ),
                             const SizedBox(width: 8),
                           ],
-                        )
-                        : Text(
-                          hint,
-                          style: theme.textTheme.bodyMedium?.copyWith(
-                            color: theme.colorScheme.onSurface.withOpacity(0.5),
+                          Text(
+                            '(${selectedAddress!.balance.spendable} $assetName)',
+                            style: theme.textTheme.bodySmall?.copyWith(
+                              color: theme.textTheme.bodySmall?.color
+                                  ?.withValues(alpha: 0.7),
+                            ),
+                          ),
+                          const SizedBox(width: 8),
+                        ],
+                      )
+                    : Text(
+                        hint,
+                        style: theme.textTheme.bodyMedium?.copyWith(
+                          color: theme.textTheme.bodyMedium?.color?.withValues(
+                            alpha: 0.5,
                           ),
                         ),
+                      ),
               ),
               const Icon(
                 Icons.arrow_drop_down,
diff --git a/packages/komodo_ui/lib/src/defi/withdraw/source_address_field.dart b/packages/komodo_ui/lib/src/defi/withdraw/source_address_field.dart
index bf25432ae..50d405ebd 100644
--- a/packages/komodo_ui/lib/src/defi/withdraw/source_address_field.dart
+++ b/packages/komodo_ui/lib/src/defi/withdraw/source_address_field.dart
@@ -167,7 +167,7 @@ class _LoadingState extends StatelessWidget {
             Text(
               'Fetching your ${asset.id.name} addresses',
               style: theme.textTheme.bodyMedium?.copyWith(
-                color: theme.colorScheme.onSurface.withValues(alpha: 0.7),
+                color: theme.textTheme.bodyMedium?.color?.withValues(alpha: 0.7),
               ),
             ),
           ],
diff --git a/playground/.firebaserc b/playground/.firebaserc
new file mode 100644
index 000000000..5dd4f6f1a
--- /dev/null
+++ b/playground/.firebaserc
@@ -0,0 +1,5 @@
+{
+  "projects": {
+    "default": "komodo-playground"
+  }
+}
diff --git a/playground/firebase.json b/playground/firebase.json
new file mode 100644
index 000000000..b4706416e
--- /dev/null
+++ b/playground/firebase.json
@@ -0,0 +1,16 @@
+{
+    "hosting": {
+        "public": "build/web",
+        "ignore": [
+            "firebase.json",
+            "**/.*",
+            "**/node_modules/**"
+        ],
+        "rewrites": [
+            {
+                "source": "**",
+                "destination": "/index.html"
+            }
+        ]
+    }
+}
\ No newline at end of file
diff --git a/playground/lib/kdf_operations/kdf_operations_server_native.dart b/playground/lib/kdf_operations/kdf_operations_server_native.dart
index e8ba0bc45..295db53b3 100644
--- a/playground/lib/kdf_operations/kdf_operations_server_native.dart
+++ b/playground/lib/kdf_operations/kdf_operations_server_native.dart
@@ -48,4 +48,7 @@ class KdfHttpServerOperations implements IKdfOperations {
   Future<bool> isAvailable(IKdfHostConfig hostConfig) async {
     throw UnsupportedError('Unknown platforms are not supported');
   }
+  
+  @override
+  void dispose() { }
 }
diff --git a/playground/lib/kdf_operations/kdf_operations_server_stub.dart b/playground/lib/kdf_operations/kdf_operations_server_stub.dart
index e8ba0bc45..295db53b3 100644
--- a/playground/lib/kdf_operations/kdf_operations_server_stub.dart
+++ b/playground/lib/kdf_operations/kdf_operations_server_stub.dart
@@ -48,4 +48,7 @@ class KdfHttpServerOperations implements IKdfOperations {
   Future<bool> isAvailable(IKdfHostConfig hostConfig) async {
     throw UnsupportedError('Unknown platforms are not supported');
   }
+  
+  @override
+  void dispose() { }
 }