@l.x/hashcash-native 1.0.2 → 1.0.4

package/LICENSE

@@ -0,0 +1,122 @@
+Lux Ecosystem License
+Version 1.2, December 2025
+
+Copyright (c) 2020-2025 Lux Industries Inc.
+All rights reserved.
+
+TECHNOLOGY PORTFOLIO - PATENT APPLICATIONS PLANNED
+Contact: licensing@lux.network
+
+================================================================================
+                          TERMS AND CONDITIONS
+================================================================================
+
+1. DEFINITIONS
+
+   "Lux Primary Network" means the official Lux blockchain with Network ID=1
+   and EVM Chain ID=96369.
+   
+   "Authorized Network" means the Lux Primary Network, official testnets/devnets,
+   and any L1/L2/L3 chain descending from the Lux Primary Network.
+   
+   "Descending Chain" means an L1/L2/L3 chain built on, anchored to, or deriving
+   security from the Lux Primary Network or its authorized testnets.
+   
+   "Research Use" means non-commercial academic research, education, personal
+   study, or evaluation purposes.
+   
+   "Commercial Use" means any use in connection with a product or service
+   offered for sale or fee, internal use by a for-profit entity, or any use
+   to generate revenue.
+
+2. GRANT OF LICENSE
+
+   Subject to these terms, Lux Industries Inc grants you a non-exclusive,
+   royalty-free license to:
+   
+   (a) Use for Research Use without restriction;
+   
+   (b) Operate on the Lux Primary Network (Network ID=1, EVM Chain ID=96369);
+   
+   (c) Operate on official Lux testnets and devnets;
+   
+   (d) Operate L1/L2/L3 chains descending from the Lux Primary Network;
+   
+   (e) Build applications within the Lux ecosystem;
+   
+   (f) Contribute improvements back to the original repositories.
+
+3. RESTRICTIONS
+
+   Without a commercial license from Lux Industries Inc, you may NOT:
+   
+   (a) Fork the Lux Network or any Lux software;
+   
+   (b) Create competing networks not descending from Lux Primary Network;
+   
+   (c) Use for Commercial Use outside the Lux ecosystem;
+   
+   (d) Sublicense or transfer rights outside the Lux ecosystem;
+   
+   (e) Use to create competing blockchain networks, exchanges, custody
+       services, or cryptographic systems outside the Lux ecosystem.
+
+4. NO FORKS POLICY
+
+   Lux Industries Inc maintains ZERO TOLERANCE for unauthorized forks.
+   Any fork or deployment on an unauthorized network constitutes:
+   
+   (a) Breach of this license;
+   (b) Grounds for immediate legal action.
+
+5. RIGHTS RESERVATION
+
+   All rights not explicitly granted are reserved by Lux Industries Inc.
+   
+   We plan to apply for patent protection for the technology in this
+   repository. Any implementation outside the Lux ecosystem may require
+   a separate commercial license.
+
+6. DISCLAIMER OF WARRANTY
+
+   THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+
+7. LIMITATION OF LIABILITY
+
+   IN NO EVENT SHALL LUX INDUSTRIES INC BE LIABLE FOR ANY CLAIM, DAMAGES
+   OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE.
+
+8. TERMINATION
+
+   This license terminates immediately upon any breach, including but not
+   limited to deployment on unauthorized networks or creation of forks.
+
+9. GOVERNING LAW
+
+   This License shall be governed by the laws of the State of Delaware.
+
+10. COMMERCIAL LICENSING
+
+    For commercial use outside the Lux ecosystem:
+    
+    Lux Industries Inc.
+    Email: licensing@lux.network
+    Subject: Commercial License Request
+
+================================================================================
+                              TL;DR
+================================================================================
+
+- Research/academic use = OK
+- Lux Primary Network (Network ID=1, Chain ID=96369) = OK
+- L1/L2/L3 chains descending from Lux Primary Network = OK
+- Commercial products outside Lux ecosystem = Contact licensing@lux.network
+- Forks = Absolutely not
+
+================================================================================
+
+See LP-0012 for full licensing documentation:
+https://github.com/luxfi/lps/blob/main/LPs/lp-0012-ecosystem-licensing.md

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