UltrafastSecp256k1 is an ultra high-performance library designed for secp256k1 elliptic curve cryptography, optimized for various hardware platforms. This library provides extensive support for both CPU and GPU architectures, leveraging advanced optimizations to deliver exceptional performance in cryptographic operations.

Key Features

• Multi-Platform Support:

  • Optimized for CPU architectures, specifically x86-64 (BMI2/ADX) and RISC-V (RV64GC).
  • Utilizes CUDA for GPU acceleration, allowing for batch operations and future plans for OpenCL support.

• Performance Improvements:

  • Achieves a 3-5× speedup on x86-64 systems via sophisticated assembly optimizations.
  • Delivers 2-3× speedup on RISC-V systems with native assembly efficiencies.
  • Supports batch processing of thousands of operations in parallel using CUDA, and includes memory-mapped database support for large-scale lookups.

• Comprehensive Cryptographic Features:

  • Supports complete secp256k1 field and scalar arithmetic, including point addition, doubling, and scalar multiplication.
  • Implements GLV endomorphism optimization for efficient computation.
  • Offers robust signature verification and public key derivation functionalities.

Use Cases

• Cryptocurrency Applications:

  • Generate Bitcoin and Ethereum addresses, sign transactions, and integrate hardware wallets.
  • Validate a large number of addresses in bulk.

• Cryptographic Research:

  • Ideal for testing ECC algorithms, conducting performance benchmarks, and implementing custom curves.

• General Purpose Applications:

  • Serve any application that requires secp256k1 operations, providing high-throughput cryptographic services and support for embedded systems, notably with RISC-V compatibility.

Quick Start Examples

Here’s a brief illustration of basic CPU usage:

#include <secp256k1/field.hpp>
#include <secp256k1/point.hpp>
#include <secp256k1/scalar.hpp>
#include <iostream>

using namespace secp256k1::fast;

int main() {
    // Sample field arithmetic calculations
    auto a = FieldElement::from_hex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141");
    auto b = FieldElement::from_hex("1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF");
    auto sum = a + b;
    auto product = a * b;
    auto inverse = a.inverse();

    std::cout << "Sum: " << sum.to_hex() << "\n";
    std::cout << "Product: " << product.to_hex() << "\n";
}

Compilation Command:

g++ -std=c++20 example.cpp -lsecp256k1-fast-cpu -o example
./example

Performance Highlights

The library demonstrates impressive benchmark results across various architectures:

• x86_64:

  • Field multiplication in 32 ns, Point addition in 644 ns.

• RISC-V:

  • Field multiplication in 197 ns, Point scalar multiplication in 672 μs.

• CUDA Performance:

  • Achieves throughput of approximately 4.1 Gops/s for field multiplications.

For detailed performance insights and tuning options, refer to the provided documentation.

Documentation and Support

Extensive documentation is available covering API references, build guides, performance tuning tips, and contributing guidelines.

• Documentation
• Build Instructions
• Performance Tuning
• Contributions are welcome; please check the CONTRIBUTING.md for guidelines.

UltrafastSecp256k1 stands out as a vital resource for developers and researchers seeking to implement high-speed elliptic curve cryptography effectively.