@l.x/hashcash-native 1.0.2 → 1.0.3

package/NitroHashcashNative.podspec

@@ -0,0 +1,56 @@
+require "json"
+
+# Dynamically resolve the nitro_pod_utils path from the workspace root
+# (static require_relative doesn't work for workspace packages due to symlinks)
+# Pod::Config.instance.installation_root is the ios folder, so we go up to find workspace root
+workspace_root = File.expand_path("../../..", Pod::Config.instance.installation_root.to_s)
+nitro_utils_path = File.join(workspace_root, "node_modules", "react-native-nitro-modules", "nitro_pod_utils")
+require nitro_utils_path
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NitroHashcashNative"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported, :visionos => 1.0 }
+  s.source       = { :git => "https://github.com/Uniswap/universe.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    # Implementation (Swift)
+    "ios/**/*.{swift}",
+    # Autolinking/Registration (Objective-C++)
+    "ios/**/*.{m,mm}",
+    # Implementation (C++ objects)
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  load 'nitrogen/generated/ios/NitroHashcashNative+autolinking.rb'
+  add_nitrogen_files(s)
+
+  xcconfig = {
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
+    "DEFINES_MODULE" => "YES",
+  }
+
+  if has_react_native()
+    react_native_version = get_react_native_version()
+    if (react_native_version < 80)
+      current_header_search_paths = Array(xcconfig["HEADER_SEARCH_PATHS"])
+      xcconfig["HEADER_SEARCH_PATHS"] = current_header_search_paths + ["${PODS_ROOT}/RCT-Folly"]
+      xcconfig["GCC_PREPROCESSOR_DEFINITIONS"] = "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES"
+      xcconfig["OTHER_CPLUSPLUSFLAGS"] = "$(inherited) -DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1"
+    end
+  end
+
+  s.pod_target_xcconfig = xcconfig
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  install_modules_dependencies(s)
+end

package/README.md

@@ -0,0 +1,24 @@
+# hashcash-native
+
+A React Native Nitro Module providing native hashcash proof-of-work solving for iOS and Android.
+
+## Overview
+
+This package provides native implementations for computing hashcash proofs, which are used for proof-of-work challenges. Native implementations offer significantly better performance than JavaScript-based solutions.
+
+## Structure
+
+- `android/` - Android JNI/Kotlin implementation
+- `ios/` - iOS Swift implementation
+- `cpp/` - Cross-platform C++ implementation (to be added)
+- `src/` - TypeScript interface definitions
+- `nitrogen/` - Generated Nitro bindings
+
+## Development
+
+This package uses [Nitro Modules](https://nitro.margelo.com/) for native bindings.
+
+```bash
+# Generate Nitro bindings
+bun run specs
+```

package/android/CMakeLists.txt

@@ -0,0 +1,29 @@
+project(NitroHashcashNative)
+cmake_minimum_required(VERSION 3.9.0)
+
+set (PACKAGE_NAME NitroHashcashNative)
+set (CMAKE_VERBOSE_MAKEFILE ON)
+set (CMAKE_CXX_STANDARD 20)
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED
+        src/main/cpp/cpp-adapter.cpp
+)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroHashcashNative+autolinking.cmake)
+
+# Set up local includes
+include_directories(
+        "src/main/cpp"
+        "../cpp"
+)
+
+find_library(LOG_LIB log)
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android                                   # <-- Android core
+)

package/android/build.gradle

@@ -0,0 +1,141 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.13.1"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: 'org.jetbrains.kotlin.android'
+apply from: '../nitrogen/generated/android/NitroHashcashNative+autolinking.gradle'
+apply from: "./fix-prefab.gradle"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["NitroHashcashNative_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["NitroHashcashNative_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.hashcashnative"
+
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += [
+          // React Codegen files
+          "${project.buildDir}/generated/source/codegen/java"
+        ]
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+
+  // Add a dependency on NitroModules
+  implementation project(":react-native-nitro-modules")
+}
+

package/android/fix-prefab.gradle

@@ -0,0 +1,51 @@
+tasks.configureEach { task ->
+  // Make sure that we generate our prefab publication file only after having built the native library
+  // so that not a header publication file, but a full configuration publication will be generated, which
+  // will include the .so file
+
+  def prefabConfigurePattern = ~/^prefab(.+)ConfigurePackage$/
+  def matcher = task.name =~ prefabConfigurePattern
+  if (matcher.matches()) {
+    def variantName = matcher[0][1]
+    task.outputs.upToDateWhen { false }
+    task.dependsOn("externalNativeBuild${variantName}")
+  }
+}
+
+afterEvaluate {
+  def abis = reactNativeArchitectures()
+  rootProject.allprojects.each { proj ->
+    if (proj === rootProject) return
+
+    def dependsOnThisLib = proj.configurations.findAll { it.canBeResolved }.any { config ->
+      config.dependencies.any { dep ->
+        dep.group == project.group && dep.name == project.name
+      }
+    }
+    if (!dependsOnThisLib && proj != project) return
+
+    if (!proj.plugins.hasPlugin('com.android.application') && !proj.plugins.hasPlugin('com.android.library')) {
+      return
+    }
+
+    def variants = proj.android.hasProperty('applicationVariants') ? proj.android.applicationVariants : proj.android.libraryVariants
+    // Touch the prefab_config.json files to ensure that in ExternalNativeJsonGenerator.kt we will re-trigger the prefab CLI to
+    // generate a libnameConfig.cmake file that will contain our native library (.so).
+    // See this condition: https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:build-system/gradle-core/src/main/java/com/android/build/gradle/tasks/ExternalNativeJsonGenerator.kt;l=207-219?q=createPrefabBuildSystemGlue
+    variants.all { variant ->
+      def variantName = variant.name
+      abis.each { abi ->
+        def searchDir = new File(proj.projectDir, ".cxx/${variantName}")
+        if (!searchDir.exists()) return
+        def matches = []
+        searchDir.eachDir { randomDir ->
+          def prefabFile = new File(randomDir, "${abi}/prefab_config.json")
+          if (prefabFile.exists()) matches << prefabFile
+        }
+        matches.each { prefabConfig ->
+          prefabConfig.setLastModified(System.currentTimeMillis())
+        }
+      }
+    }
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+NitroHashcashNative_kotlinVersion=2.0.21
+NitroHashcashNative_minSdkVersion=23
+NitroHashcashNative_targetSdkVersion=35
+NitroHashcashNative_compileSdkVersion=35
+NitroHashcashNative_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,6 @@
+#include <jni.h>
+#include "NitroHashcashNativeOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::hashcashnative::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/hashcashnative/HybridHashcash.kt

@@ -0,0 +1,113 @@
+package com.margelo.nitro.hashcashnative
+
+import com.margelo.nitro.core.Promise
+import java.security.MessageDigest
+import java.util.Base64
+import java.util.concurrent.atomic.AtomicBoolean
+
+/**
+ * Native hashcash proof-of-work solver for Android.
+ *
+ * Uses java.security.MessageDigest for SHA256 hashing. The computation
+ * runs on a background thread via Nitro's Promise.async to avoid blocking
+ * the main/JS thread.
+ *
+ * Performance notes:
+ * - Cancellation is checked every 1000 iterations to balance responsiveness
+ *   with cancellation check overhead
+ * - AtomicBoolean provides thread-safe access to the cancellation flag
+ * - Native MessageDigest is significantly faster than JS crypto
+ */
+class HybridHashcash : HybridHashcashSpec() {
+    /**
+     * Thread-safe cancellation flag using AtomicBoolean.
+     * Checked every 1000 iterations to allow responsive cancellation
+     * without excessive overhead.
+     */
+    private val cancelled = AtomicBoolean(false)
+
+    /**
+     * Find a proof-of-work solution for the given challenge.
+     *
+     * Iterates through counter values computing SHA256 hashes until
+     * one is found with the required number of leading zero bytes.
+     */
+    override fun findProof(params: FindProofParams): Promise<HashcashProofResult?> {
+        return Promise.async {
+            cancelled.set(false)
+
+            val challenge = params.challenge
+            val rangeStart = params.rangeStart?.toInt() ?: 0
+            val rangeSize = params.rangeSize?.toInt() ?: challenge.maxProofLength.toInt()
+            val rangeEnd = rangeStart + rangeSize
+
+            val startTime = System.currentTimeMillis()
+            val digest = MessageDigest.getInstance("SHA-256")
+
+            for (counter in rangeStart until rangeEnd) {
+                // Check cancellation every 1000 iterations
+                if (counter % 1000 == 0 && cancelled.get()) {
+                    return@async null
+                }
+
+                // Compute hash for this counter
+                val hash = computeHash(digest, challenge.subject, challenge.nonce, counter)
+
+                // Check if hash meets difficulty requirement
+                if (checkDifficulty(hash, challenge.difficulty.toInt())) {
+                    val timeMs = (System.currentTimeMillis() - startTime).toDouble()
+
+                    return@async HashcashProofResult(
+                        counter = counter.toString(),
+                        hashBase64 = Base64.getEncoder().encodeToString(hash),
+                        attempts = (counter - rangeStart + 1).toDouble(),
+                        timeMs = timeMs
+                    )
+                }
+            }
+
+            null
+        }
+    }
+
+    /**
+     * Cancel any in-progress proof search.
+     */
+    override fun cancel() {
+        cancelled.set(true)
+    }
+
+    // MARK: - Private Helpers
+
+    /**
+     * Compute SHA256 hash of "{subject}:{nonce}:{counter}"
+     */
+    private fun computeHash(
+        digest: MessageDigest,
+        subject: String,
+        nonce: String,
+        counter: Int
+    ): ByteArray {
+        val solutionString = "$subject:$nonce:$counter"
+        digest.reset()
+        return digest.digest(solutionString.toByteArray(Charsets.UTF_8))
+    }
+
+    /**
+     * Check if hash has required number of leading zero bytes.
+     *
+     * difficulty=1 means first byte must be 0x00
+     * difficulty=2 means first two bytes must be 0x00, etc.
+     */
+    private fun checkDifficulty(hash: ByteArray, difficulty: Int): Boolean {
+        if (hash.size < difficulty) return false
+
+        for (i in 0 until difficulty) {
+            if (hash[i] != 0.toByte()) {
+                return false
+            }
+        }
+
+        return true
+    }
+}

package/android/src/main/java/com/margelo/nitro/hashcashnative/NitroHashcashNativePackage.kt

@@ -0,0 +1,18 @@
+package com.margelo.nitro.hashcashnative
+
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.BaseReactPackage
+
+class NitroHashcashNativePackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider { HashMap() }
+
+    companion object {
+        init {
+            NitroHashcashNativeOnLoad.initializeNative()
+        }
+    }
+}

package/ios/Bridge.h

@@ -0,0 +1,8 @@
+//
+//  Bridge.h
+//  NitroHashcashNative
+//
+//  Created by Uniswap Labs
+//
+
+#pragma once

package/ios/HybridHashcash.swift

@@ -0,0 +1,133 @@
+import Foundation
+import CommonCrypto
+import NitroModules
+
+/**
+ * Native hashcash proof-of-work solver for iOS.
+ *
+ * Uses CommonCrypto for SHA256 hashing. The computation runs on a
+ * background thread via Nitro's Promise.async to avoid blocking
+ * the main/JS thread.
+ *
+ * Performance notes:
+ * - Cancellation is checked every 1000 iterations to balance responsiveness
+ *   with cancellation check overhead
+ * - NSLock provides thread-safe access to the cancellation flag
+ *   (Swift's standard pattern for thread-safe booleans, equivalent to
+ *   Java's AtomicBoolean pattern)
+ * - Native CommonCrypto is significantly faster than JS crypto
+ */
+class HybridHashcash: HybridHashcashSpec {
+    /// Thread-safe cancellation flag. Checked every 1000 iterations
+    /// to allow responsive cancellation without excessive overhead.
+    private var cancelled = false
+
+    /// NSLock for thread-safe cancellation flag access.
+    /// Swift's standard pattern for synchronizing access to shared state.
+    private let lock = NSLock()
+
+    private var isCancelled: Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        return cancelled
+    }
+
+    private func setCancelled(_ value: Bool) {
+        lock.lock()
+        defer { lock.unlock() }
+        cancelled = value
+    }
+
+    /**
+     * Find a proof-of-work solution for the given challenge.
+     *
+     * Iterates through counter values computing SHA256 hashes until
+     * one is found with the required number of leading zero bytes.
+     */
+    func findProof(params: FindProofParams) throws -> Promise<HashcashProofResult?> {
+        return Promise.async { [weak self] in
+            guard let self = self else { return nil }
+
+            self.setCancelled(false)
+
+            let challenge = params.challenge
+            let rangeStart = Int(params.rangeStart ?? 0)
+            let rangeSize = Int(params.rangeSize ?? challenge.maxProofLength)
+            let rangeEnd = rangeStart + rangeSize
+
+            let startTime = CFAbsoluteTimeGetCurrent()
+
+            for counter in rangeStart..<rangeEnd {
+                // Check cancellation every 1000 iterations
+                if counter % 1000 == 0 && self.isCancelled {
+                    return nil
+                }
+
+                // Compute hash for this counter
+                let hash = self.computeHash(
+                    subject: challenge.subject,
+                    nonce: challenge.nonce,
+                    counter: counter
+                )
+
+                // Check if hash meets difficulty requirement
+                if self.checkDifficulty(hash: hash, difficulty: Int(challenge.difficulty)) {
+                    let timeMs = (CFAbsoluteTimeGetCurrent() - startTime) * 1000
+
+                    return HashcashProofResult(
+                        counter: String(counter),
+                        hashBase64: hash.base64EncodedString(),
+                        attempts: Double(counter - rangeStart + 1),
+                        timeMs: timeMs
+                    )
+                }
+            }
+
+            return nil
+        }
+    }
+
+    /**
+     * Cancel any in-progress proof search.
+     */
+    func cancel() throws {
+        setCancelled(true)
+    }
+
+    // MARK: - Private Helpers
+
+    /**
+     * Compute SHA256 hash of "{subject}:{nonce}:{counter}"
+     */
+    private func computeHash(subject: String, nonce: String, counter: Int) -> Data {
+        let solutionString = "\(subject):\(nonce):\(counter)"
+        guard let data = solutionString.data(using: .utf8) else {
+            return Data()
+        }
+
+        var hash = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
+        data.withUnsafeBytes { bytes in
+            _ = CC_SHA256(bytes.baseAddress, CC_LONG(data.count), &hash)
+        }
+
+        return Data(hash)
+    }
+
+    /**
+     * Check if hash has required number of leading zero bytes.
+     *
+     * difficulty=1 means first byte must be 0x00
+     * difficulty=2 means first two bytes must be 0x00, etc.
+     */
+    private func checkDifficulty(hash: Data, difficulty: Int) -> Bool {
+        guard hash.count >= difficulty else { return false }
+
+        for i in 0..<difficulty {
+            if hash[i] != 0 {
+                return false
+            }
+        }
+
+        return true
+    }
+}

package/lib/benchmark.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Hashcash Benchmark Utility
+ *
+ * Compares native vs JS hashcash implementation performance.
+ * Run this in your app to measure the speedup from native code.
+ */
+/** biome-ignore-all lint/suspicious/noConsole: dev only file */
+interface BenchmarkResult {
+    implementation: 'native' | 'js';
+    difficulty: number;
+    counter: string | null;
+    attempts: number;
+    timeMs: number;
+}
+interface BenchmarkSummary {
+    native: BenchmarkResult;
+    js: BenchmarkResult;
+    speedup: number;
+}
+/**
+ * Run a single benchmark with the native implementation
+ */
+export declare function benchmarkNative(difficulty: number): Promise<BenchmarkResult>;
+/**
+ * Run a single benchmark with the JS implementation
+ * Requires passing in the findProof function from @l.x/sessions
+ */
+export declare function benchmarkJS(difficulty: number, findProof: (params: {
+    challenge: {
+        difficulty: number;
+        subject: string;
+        algorithm: 'sha256';
+        nonce: string;
+        max_proof_length: number;
+    };
+}) => {
+    counter: string;
+    attempts: number;
+    timeMs: number;
+} | null): Promise<BenchmarkResult>;
+/**
+ * Run a comparison benchmark between native and JS implementations
+ */
+export declare function runBenchmark(difficulty: number, jsFindProof: (params: {
+    challenge: {
+        difficulty: number;
+        subject: string;
+        algorithm: 'sha256';
+        nonce: string;
+        max_proof_length: number;
+    };
+}) => {
+    counter: string;
+    attempts: number;
+    timeMs: number;
+} | null): Promise<BenchmarkSummary>;
+/**
+ * Run benchmarks at multiple difficulty levels
+ */
+export declare function runFullBenchmark(jsFindProof: (params: {
+    challenge: {
+        difficulty: number;
+        subject: string;
+        algorithm: 'sha256';
+        nonce: string;
+        max_proof_length: number;
+    };
+}) => {
+    counter: string;
+    attempts: number;
+    timeMs: number;
+} | null): Promise<void>;
+export {};
+//# sourceMappingURL=benchmark.d.ts.map

package/lib/benchmark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark.d.ts","sourceRoot":"","sources":["../src/benchmark.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,gEAAgE;AAIhE,UAAU,eAAe;IACvB,cAAc,EAAE,QAAQ,GAAG,IAAI,CAAA;IAC/B,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;CACf;AAED,UAAU,gBAAgB;IACxB,MAAM,EAAE,eAAe,CAAA;IACvB,EAAE,EAAE,eAAe,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAmBlF;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAC/B,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,CAAC,MAAM,EAAE;IAClB,SAAS,EAAE;QACT,UAAU,EAAE,MAAM,CAAA;QAClB,OAAO,EAAE,MAAM,CAAA;QACf,SAAS,EAAE,QAAQ,CAAA;QACnB,KAAK,EAAE,MAAM,CAAA;QACb,gBAAgB,EAAE,MAAM,CAAA;KACzB,CAAA;CACF,KAAK;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GACjE,OAAO,CAAC,eAAe,CAAC,CAkB1B;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,CAAC,MAAM,EAAE;IACpB,SAAS,EAAE;QACT,UAAU,EAAE,MAAM,CAAA;QAClB,OAAO,EAAE,MAAM,CAAA;QACf,SAAS,EAAE,QAAQ,CAAA;QACnB,KAAK,EAAE,MAAM,CAAA;QACb,gBAAgB,EAAE,MAAM,CAAA;KACzB,CAAA;CACF,KAAK;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GACjE,OAAO,CAAC,gBAAgB,CAAC,CAyB3B;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,CAAC,MAAM,EAAE;IACpB,SAAS,EAAE;QACT,UAAU,EAAE,MAAM,CAAA;QAClB,OAAO,EAAE,MAAM,CAAA;QACf,SAAS,EAAE,QAAQ,CAAA;QACnB,KAAK,EAAE,MAAM,CAAA;QACb,gBAAgB,EAAE,MAAM,CAAA;KACzB,CAAA;CACF,KAAK;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GACjE,OAAO,CAAC,IAAI,CAAC,CAcf"}