[ { "path": ".codecov.yml", "content": "comment:\n layout: \"diff, files\"\n behavior: default\n\ncoverage:\n range: 50..100\n round: down\n precision: 2\n\n status:\n project:\n default:\n target: '70'\n patch:\n default:\n target: '70'\n" }, { "path": ".conda/environment-dev.yml", "content": "name: coincurve-with-conda-dev\nchannels:\n - conda-forge\n - defaults\ndependencies:\n - cffi >=1.3.0\n - cmake\n - libsecp256k1\n - pkg-config\n - pytest\n - pytest-benchmark\n - python =3.12\n - tox-conda\n" }, { "path": ".conda/environment.yml", "content": "name: coincurve-with-conda\nchannels:\n - conda-forge\n - defaults\ndependencies:\n - libsecp256k1\n - cffi >=1.3.0\n - asn1crypto\n\n" }, { "path": ".gemini/config.yaml", "content": "# https://developers.google.com/gemini-code-assist/docs/customize-gemini-behavior-github\nhave_fun: false\ncode_review:\n pull_request_opened:\n summary: false\n code_review: false\n" }, { "path": ".gitattributes", "content": "# Auto detect text files and perform LF normalization\n* text=auto\n\n# Custom for Visual Studio\n*.cs diff=csharp\n\n# Standard to msysgit\n*.doc\t diff=astextplain\n*.DOC\t diff=astextplain\n*.docx diff=astextplain\n*.DOCX diff=astextplain\n*.dot diff=astextplain\n*.DOT diff=astextplain\n*.pdf diff=astextplain\n*.PDF\t diff=astextplain\n*.rtf\t diff=astextplain\n*.RTF\t diff=astextplain\n" }, { "path": ".github/FUNDING.yml", "content": "github:\n- ofek\ncustom:\n- https://ofek.dev/donate/\n- https://paypal.me/ofeklev\n" }, { "path": ".github/dependabot.yml", "content": "version: 2\nupdates:\n- package-ecosystem: \"github-actions\"\n directory: \"/\"\n schedule:\n interval: \"monthly\"\n" }, { "path": ".github/scripts/install-macos-build-deps.sh", "content": "#!/bin/bash\nset -ex\n\n# update brew\nbrew update\n\n# Update openssl if necessary\nbrew outdated openssl || brew upgrade openssl\n\n# Install packages needed to build lib-secp256k1\nfor pkg in pkg-config; do\n brew list $pkg > /dev/null || brew install $pkg\n brew outdated --quiet $pkg || brew upgrade $pkg\ndone\n" }, { "path": ".github/workflows/build.yml", "content": "name: build\n\non:\n push:\n tags:\n - v*\n branches:\n - master\n pull_request:\n branches:\n - master\n\nconcurrency:\n group: build-${{ github.head_ref }}\n cancel-in-progress: true\n\nenv:\n PYTHON_VERSION: '3.13'\n COINCURVE_IGNORE_SYSTEM_LIB: 'ON'\n COINCURVE_SECP256K1_STATIC: 'ON'\n COINCURVE_CROSS_HOST: ''\n CIBW_ENVIRONMENT_PASS_LINUX: >\n COINCURVE_IGNORE_SYSTEM_LIB\n COINCURVE_SECP256K1_STATIC\n COINCURVE_CROSS_HOST\n CIBW_BEFORE_ALL_MACOS: ./.github/scripts/install-macos-build-deps.sh\n CIBW_TEST_REQUIRES: pytest\n CIBW_TEST_COMMAND: >\n python -c\n \"from coincurve import PrivateKey;\n a=PrivateKey();\n b=PrivateKey();\n assert a.ecdh(b.public_key.format())==b.ecdh(a.public_key.format())\n \" &&\n python -m pytest {project}\n CIBW_SKIP: >\n pp*\n\njobs:\n test:\n name: Test Python ${{ matrix.python-version }} on ${{ startsWith(matrix.os, 'macos-') && 'macOS' || startsWith(matrix.os, 'windows-') && 'Windows' || 'Linux' }}\n runs-on: ${{ matrix.os }}\n strategy:\n fail-fast: false\n matrix:\n os: [ubuntu-latest, windows-latest, macos-latest]\n python-version: [\"3.9\", \"3.10\", \"3.11\", \"3.12\", \"3.13\", \"3.14\"]\n\n steps:\n - name: Checkout code\n uses: actions/checkout@v5\n\n - name: Set up Python ${{ matrix.python-version }}\n uses: actions/setup-python@v6\n with:\n python-version: ${{ matrix.python-version }}\n\n - name: Install system dependencies\n if: runner.os == 'macOS'\n run: ./.github/scripts/install-macos-build-deps.sh\n\n - name: Install Hatch\n uses: pypa/hatch@install\n\n - name: Run static analysis\n run: hatch fmt --check\n\n - name: Check types\n run: hatch run types:check\n\n - name: Run tests\n run: hatch test --python ${{ matrix.python-version }} --cover-quiet --randomize\n\n - name: Create coverage report\n run: hatch run hatch-test.py${{ matrix.python-version }}:coverage xml\n\n - name: Upload coverage data\n uses: actions/upload-artifact@v4\n with:\n name: coverage-${{ matrix.os }}-${{ matrix.python-version }}\n path: coverage.xml\n\n - name: Install uv\n uses: astral-sh/setup-uv@v5\n\n - name: Benchmark\n run: uv run --python-preference system scripts/bench.py\n\n coverage:\n name: Upload coverage\n needs:\n - test\n runs-on: ubuntu-latest\n\n permissions:\n contents: read\n id-token: write\n\n steps:\n - name: Download coverage data\n uses: actions/download-artifact@v5\n with:\n pattern: coverage-*\n path: coverage_data\n\n - name: Upload coverage to Codecov\n uses: codecov/codecov-action@v5\n with:\n directory: coverage_data\n use_oidc: true\n\n linux-wheels-x86_64:\n name: Build Linux wheels for x86-64\n needs:\n - test\n runs-on: ubuntu-latest\n\n steps:\n - uses: actions/checkout@v5\n\n - name: Build wheels\n uses: pypa/cibuildwheel@v2.23\n\n - uses: actions/upload-artifact@v4\n with:\n name: artifact-linux-wheels-x86_64\n path: wheelhouse/*.whl\n if-no-files-found: error\n\n macos-wheels-x86_64:\n name: Build macOS wheels for x86-64\n needs:\n - test\n runs-on: macos-15-intel\n\n steps:\n - uses: actions/checkout@v5\n\n - name: Build wheels\n uses: pypa/cibuildwheel@v3.2.0\n env:\n CIBW_ARCHS_MACOS: x86_64\n CIBW_SKIP: \"cp314t-*\"\n MACOSX_DEPLOYMENT_TARGET: 10.13\n\n - uses: actions/upload-artifact@v4\n with:\n name: artifact-macos-wheels-x86_64\n path: wheelhouse/*.whl\n if-no-files-found: error\n\n macos-wheels-arm64:\n name: Build macOS wheels for ARM64\n needs:\n - test\n runs-on: macos-latest\n\n steps:\n - uses: actions/checkout@v5\n\n - name: Build wheels\n uses: pypa/cibuildwheel@v2.23\n\n - uses: actions/upload-artifact@v4\n with:\n name: artifact-macos-wheels-arm64\n path: wheelhouse/*.whl\n if-no-files-found: error\n\n windows-wheels-x86_64:\n name: Build Windows wheels for x86-64\n needs:\n - test\n runs-on: windows-latest\n\n steps:\n - uses: actions/checkout@v5\n\n - uses: actions/setup-python@v6\n with:\n python-version: ${{ env.PYTHON_VERSION }}\n\n - name: Build wheels\n uses: pypa/cibuildwheel@v2.23\n env:\n CIBW_ARCHS_WINDOWS: 'AMD64'\n CIBW_BEFORE_ALL: choco install -y --no-progress --no-color cmake>=3.28\n\n - uses: actions/upload-artifact@v4\n with:\n name: artifact-windows-wheels-x86_64\n path: wheelhouse/*.whl\n if-no-files-found: error\n\n windows-wheels-arm64:\n name: Build Windows wheels for ARM64\n needs:\n - test\n runs-on: windows-latest\n\n steps:\n - uses: actions/checkout@v5\n\n - name: Build wheels\n uses: pypa/cibuildwheel@v2.23\n env:\n COINCURVE_CROSS_HOST: 'arm64'\n CIBW_ARCHS_WINDOWS: 'ARM64'\n CIBW_BEFORE_ALL: choco install -y --no-progress --no-color cmake>=3.28\n\n - uses: actions/upload-artifact@v4\n with:\n name: artifact-windows-wheels-arm64\n path: wheelhouse/*.whl\n if-no-files-found: error\n\n sdist:\n name: Build source distribution\n needs:\n - test\n runs-on: ubuntu-latest\n\n steps:\n - uses: actions/checkout@v5\n\n - name: Install build dependencies\n run: python -m pip install build\n\n - name: Build source distribution\n run: python -m build --sdist\n\n - uses: actions/upload-artifact@v4\n with:\n name: artifact-sdist\n path: dist/*\n if-no-files-found: error\n\n linux-wheels-arm64:\n name: Build Linux wheels for ARM64\n needs:\n - test\n runs-on: ubuntu-latest\n if: github.event_name == 'push' && (github.ref == 'refs/heads/master' || startsWith(github.event.ref, 'refs/tags'))\n\n steps:\n - uses: actions/checkout@v5\n\n - name: Set up QEMU\n uses: docker/setup-qemu-action@v3\n with:\n platforms: arm64\n\n - name: Build wheels\n uses: pypa/cibuildwheel@v2.23\n env:\n CIBW_ARCHS_LINUX: aarch64\n\n - uses: actions/upload-artifact@v4\n with:\n name: artifact-linux-wheels-arm64\n path: wheelhouse/*.whl\n if-no-files-found: error\n\n publish:\n name: Publish release\n needs:\n - linux-wheels-x86_64\n - macos-wheels-x86_64\n - macos-wheels-arm64\n - windows-wheels-x86_64\n - windows-wheels-arm64\n - sdist\n - linux-wheels-arm64\n runs-on: ubuntu-latest\n if: github.event_name == 'push' && startsWith(github.event.ref, 'refs/tags')\n\n permissions:\n id-token: write\n\n steps:\n - uses: actions/download-artifact@v5\n with:\n pattern: artifact-*\n merge-multiple: true\n path: dist\n - run: ls -l dist\n\n - name: Push build artifacts to PyPI\n uses: pypa/gh-action-pypi-publish@v1.13.0\n with:\n skip-existing: true\n" }, { "path": ".github/workflows/docs.yml", "content": "name: docs\n\non:\n push:\n branches:\n - master\n pull_request:\n branches:\n - master\n\njobs:\n build:\n runs-on: ubuntu-latest\n\n steps:\n - uses: actions/checkout@v5\n with:\n # Fetch all history for applying timestamps to every page\n fetch-depth: 0\n\n - name: Set up Python\n uses: actions/setup-python@v6\n with:\n python-version: '3.12'\n\n - name: Install Hatch\n uses: pypa/hatch@install\n\n - name: Check documentation\n run: hatch run docs:build-check\n\n - name: Build documentation\n run: hatch run docs:build\n\n - uses: actions/upload-artifact@v4\n with:\n name: documentation\n path: site\n\n publish:\n runs-on: ubuntu-latest\n\n if: github.event_name == 'push' && github.ref == 'refs/heads/master'\n needs:\n - build\n\n steps:\n - uses: actions/download-artifact@v5\n with:\n name: documentation\n path: site\n\n - uses: peaceiris/actions-gh-pages@v4\n with:\n github_token: ${{ secrets.GITHUB_TOKEN }}\n publish_dir: ./site\n commit_message: ${{ github.event.head_commit.message }}\n # Write .nojekyll at the root, see:\n # https://help.github.com/en/github/working-with-github-pages/about-github-pages#static-site-generators\n enable_jekyll: false\n # Only deploy if there were changes\n allow_empty_commit: false\n" }, { "path": ".github/workflows/verify_conda_build.yml", "content": "name: conda_build\n\non:\n push:\n tags:\n - v*\n branches:\n - master\n pull_request:\n branches:\n - master\n\nconcurrency:\n group: build_conda-${{ github.head_ref }}\n cancel-in-progress: true\n\nenv:\n PYTHON_VERSION: '3.12'\n COINCURVE_UPSTREAM_REF: __no_upstream__\n COINCURVE_IGNORE_SYSTEM_LIB: 'OFF'\n COINCURVE_SECP256K1_STATIC: 'OFF'\n COINCURVE_CROSS_HOST: ''\n CIBW_ENVIRONMENT_PASS_LINUX: >\n COINCURVE_UPSTREAM_REF\n COINCURVE_IGNORE_SYSTEM_LIB\n COINCURVE_SECP256K1_STATIC\n COINCURVE_CROSS_HOST\n CIBW_BEFORE_ALL_MACOS: ./.github/scripts/install-macos-build-deps.sh\n CIBW_TEST_REQUIRES: pytest\n CIBW_TEST_COMMAND: >\n python -c\n \"from coincurve import PrivateKey;\n a=PrivateKey();\n b=PrivateKey();\n assert a.ecdh(b.public_key.format())==b.ecdh(a.public_key.format())\n \" &&\n python -m pytest {project}\n CIBW_SKIP: >\n pp*\n\njobs:\n test:\n name: Test with Conda libsecp256k1\n runs-on: ubuntu-latest\n defaults:\n run:\n shell: bash -el {0}\n\n steps:\n - uses: actions/checkout@v5\n\n - name: Install Miniconda\n uses: conda-incubator/setup-miniconda@v3\n with:\n environment-file: ./.conda/environment-dev.yml\n activate-environment: coincurve-with-conda\n python-version: ${{ env.PYTHON_VERSION }}\n auto-activate-base: false\n\n - name: Install Hatch\n uses: pypa/hatch@install\n\n - name: Run static analysis\n run: hatch fmt --check\n\n - name: Check types\n run: hatch run types:check\n\n - name: Run tests\n run: LD_LIBRARY_PATH=$CONDA_PREFIX/lib hatch test\n\n - name: Install uv\n uses: astral-sh/setup-uv@v5\n\n - name: Benchmark\n run: LD_LIBRARY_PATH=$CONDA_PREFIX/lib uv run --python-preference system scripts/bench.py\n\n linux-wheels-x86_64:\n name: Build Linux wheels\n needs:\n - test\n runs-on: ubuntu-latest\n defaults:\n run:\n shell: bash -el {0}\n\n steps:\n - uses: actions/checkout@v5\n\n - name: Install Miniconda\n uses: conda-incubator/setup-miniconda@v3\n with:\n environment-file: ./.conda/environment-dev.yml\n activate-environment: coincurve-with-conda\n python-version: ${{ env.PYTHON_VERSION }}\n auto-activate-base: false\n\n - name: Build sdist & wheel\n run: |\n conda install python-build\n python -m build --outdir conda_dist\n\n - name: Test wheel in a clean environment\n run: |\n conda install pip\n pip install conda_dist/*.whl\n python -m pytest tests\n" }, { "path": ".github/workflows/verify_shared_build.yml", "content": "name: shared_build\n\non:\n push:\n tags:\n - v*\n branches:\n - master\n pull_request:\n branches:\n - master\n\nconcurrency:\n group: build_shared-${{ github.head_ref }}\n cancel-in-progress: true\n\nenv:\n PYTHON_VERSION: '3.12'\n COINCURVE_IGNORE_SYSTEM_LIB: '1'\n # Only 'SHARED' is recognized, any other string means 'not SHARED'\n COINCURVE_SECP256K1_BUILD: 'SHARED'\n CIBW_ENVIRONMENT_PASS_LINUX: >\n COINCURVE_IGNORE_SYSTEM_LIB\n COINCURVE_SECP256K1_BUILD\n CIBW_BEFORE_ALL_MACOS: ./.github/scripts/install-macos-build-deps.sh\n CIBW_TEST_REQUIRES: pytest\n CIBW_TEST_COMMAND: >\n python -c\n \"from coincurve import PrivateKey;\n a=PrivateKey();\n b=PrivateKey();\n assert a.ecdh(b.public_key.format())==b.ecdh(a.public_key.format())\n \" &&\n python -m pytest {project}\n CIBW_TEST_SKIP: \"*-macosx_arm64\"\n CIBW_SKIP: >\n pp*\n\njobs:\n test:\n name: Test latest Python\n runs-on: ubuntu-latest\n\n steps:\n - uses: actions/checkout@v5\n\n - name: Set up Python ${{ env.PYTHON_VERSION }}\n uses: actions/setup-python@v6\n with:\n python-version: ${{ env.PYTHON_VERSION }}\n\n - name: Install system dependencies\n if: runner.os == 'macOS'\n run: ./.github/scripts/install-macos-build-deps.sh\n\n - name: Install Hatch\n uses: pypa/hatch@install\n\n - name: Run static analysis\n run: hatch fmt --check\n\n - name: Check types\n run: hatch run types:check\n\n - name: Run tests\n run: hatch test\n\n - name: Install uv\n uses: astral-sh/setup-uv@v5\n\n - name: Benchmark\n run: uv run --python-preference system scripts/bench.py\n\n linux-wheels-x86_64:\n name: Build Linux wheels for x86-64\n needs:\n - test\n runs-on: ubuntu-latest\n\n steps:\n - uses: actions/checkout@v5\n\n - name: Build wheels\n uses: pypa/cibuildwheel@v2.23\n\n macos-wheels-x86_64:\n name: Build macOS wheels for x86-64\n needs:\n - test\n runs-on: macos-15-intel\n\n steps:\n - uses: actions/checkout@v5\n\n - name: Build wheels\n uses: pypa/cibuildwheel@v3.2.0\n env:\n CIBW_ARCHS_MACOS: x86_64\n CIBW_SKIP: \"cp314t-*\"\n MACOSX_DEPLOYMENT_TARGET: 10.13\n\n macos-wheels-arm64:\n name: Build macOS wheels for ARM64\n needs:\n - test\n runs-on: macos-latest\n\n steps:\n - uses: actions/checkout@v5\n\n - name: Build wheels\n uses: pypa/cibuildwheel@v2.23\n\n windows-wheels-x86_64:\n name: Build Windows wheels for x86-64\n needs:\n - test\n runs-on: windows-latest\n\n steps:\n - uses: actions/checkout@v5\n\n - uses: actions/setup-python@v6\n with:\n python-version: ${{ env.PYTHON_VERSION }}\n\n - name: Build wheels\n uses: pypa/cibuildwheel@v2.23\n env:\n CIBW_ARCHS_WINDOWS: 'AMD64'\n CIBW_BEFORE_ALL: choco install -y --no-progress --no-color cmake>=3.28\n\n windows-wheels-arm64:\n name: Build Windows wheels for ARM64\n needs:\n - test\n runs-on: windows-latest\n\n steps:\n - uses: actions/checkout@v5\n\n - name: Build wheels\n uses: pypa/cibuildwheel@v2.23\n env:\n COINCURVE_CROSS_HOST: 'arm64'\n CIBW_ARCHS_WINDOWS: 'ARM64'\n CIBW_BEFORE_ALL: choco install -y --no-progress --no-color cmake>=3.28\n" }, { "path": ".gitignore", "content": "*.log\n*.pyc\n/.cache\n/.coverage\n/.eggs\n/.idea\n/.mypy_cache\n/.tox\n/coincurve.egg-info\n/build\n/dist\n/site\n" }, { "path": ".linkcheckerrc", "content": "[AnchorCheck]\n" }, { "path": "CMakeLists.txt", "content": "cmake_minimum_required(VERSION 3.26)\n\nproject(${SKBUILD_PROJECT_NAME}\n VERSION ${SKBUILD_PROJECT_VERSION}\n LANGUAGES C\n)\n\n# Path to custom CMake functions\nset(CMAKE_MODULE_PATH \"${PROJECT_SOURCE_DIR}/cmake\" ${CMAKE_MODULE_PATH})\n\n# Name of the vendored library CMake target\ninclude(SetDefaultVendoredLibrary)\nSetDefaultVendoredLibrary()\n\nset(CFFI_INPUT_LIBRARY ${VENDORED_LIBRARY_CMAKE_TARGET})\n\n# Set the output directories for the generated C code and headers\nset(CFFI_C_CODE_DIR ${PROJECT_BINARY_DIR}/_gen_c_file)\nset(CFFI_C_CODE \"${CFFI_INPUT_LIBRARY}_cffi_bindings.c\")\nset(CFFI_HEADERS_DIR ${PROJECT_BINARY_DIR}/_gen_cffi_headers)\n\n# Shared object that wraps the CFFI binding of the vendored library\nset(CFFI_OUTPUT_LIBRARY \"_${VENDORED_LIBRARY_PKG_CONFIG}\")\n\n# Setting python for the host system (before change in CMAKE_SYSTEM_PROCESSOR)\nfind_package(Python 3 REQUIRED COMPONENTS Interpreter Development.Module Development.SABIModule)\n\ninclude(SetCrossCompilerGithubActions)\nSetCrossCompilerGithubActions()\n\n# Add the subdirectories. Append CONDA to the PKG_CONFIG_PATH\nif (CMAKE_SYSTEM_NAME STREQUAL \"Windows\")\n set(PKG_CONFIG_ARGN \"--dont-define-prefix\")\nendif()\nfind_package(PkgConfig REQUIRED)\n\n# Set VENDORED_AS_SYSTEM_LIB to true if the vendored library is installed as a system library\ninclude(SetSystemLibIfExists)\nSetSystemLibIfExists()\n\nadd_subdirectory(cm_vendored_library)\nadd_subdirectory(cm_library_cffi_headers)\nadd_subdirectory(cm_library_c_binding)\nadd_subdirectory(cm_python_module)\n\n# Configure installation of the shared library ${CFFI_OUTPUT_LIBRARY} in the package\ninstall(TARGETS ${CFFI_OUTPUT_LIBRARY} LIBRARY DESTINATION ${SKBUILD_PLATLIB_DIR}/${SKBUILD_PROJECT_NAME})\n" }, { "path": "LICENSE-APACHE", "content": "Copyright 2017 Ofek Lev\n\n Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\nTERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\nEND OF TERMS AND CONDITIONS\n" }, { "path": "LICENSE-MIT", "content": "MIT License\n\nCopyright (c) 2017 Ofek Lev\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n" }, { "path": "NOTICE", "content": "This package is dual-licensed under MIT or Apache-2.0.\n\nThe final distribution includes the following compiled artifacts:\n\n* `_cffi_backend` shared library from the CFFI project (https://github.com/python-cffi/cffi) which is licensed under the MIT license. See `coincurve-X.Y.Z.dist-info/licenses/LICENSE-cffi` for the license text.\n* Code from the libsecp256k1 project (https://github.com/bitcoin-core/secp256k1) which is licensed under the MIT license.\n" }, { "path": "README.md", "content": "# coincurve\n\n| | |\n| --- | --- |\n| CI/CD | [![CI - Test](https://github.com/ofek/coincurve/actions/workflows/build.yml/badge.svg)](https://github.com/ofek/coincurve/actions/workflows/build.yml) [![CI - Coverage](https://img.shields.io/codecov/c/github/ofek/coincurve/master.svg?logo=codecov&logoColor=red)](https://codecov.io/github/ofek/coincurve) |\n| Docs | [![CI - Docs](https://github.com/ofek/coincurve/actions/workflows/docs.yml/badge.svg)](https://github.com/ofek/coincurve/actions/workflows/docs.yml) |\n| Package | [![PyPI - Version](https://img.shields.io/pypi/v/coincurve.svg?logo=pypi&label=PyPI&logoColor=gold)](https://pypi.org/project/coincurve/) [![PyPI - Downloads](https://img.shields.io/pypi/dm/coincurve.svg?color=blue&label=Downloads&logo=pypi&logoColor=gold)](https://pypi.org/project/coincurve/) [![Required Python Version](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Fofek%2Fcoincurve%2FHEAD%2Fpyproject.toml)](https://pypi.org/project/coincurve/) |\n| Meta | [![Hatch project](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/ofek/dep-sync) [![linting - Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff) [![types - Mypy](https://img.shields.io/badge/types-Mypy-blue.svg)](https://github.com/python/mypy) [![License - MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-9400d3.svg)](https://spdx.org/licenses/) [![GitHub Sponsors](https://img.shields.io/github/sponsors/ofek?logo=GitHub%20Sponsors&style=social)](https://github.com/sponsors/ofek) |\n\n-----\n\nThis library provides well-tested Python bindings for [libsecp256k1](https://github.com/bitcoin-core/secp256k1), the heavily optimized C library\nused by [Bitcoin Core](https://github.com/bitcoin/bitcoin) for operations on the elliptic curve [secp256k1](https://en.bitcoin.it/wiki/Secp256k1).\n\nFeel free to read the [documentation](https://ofek.dev/coincurve/)!\n\n## Users\n\n- [Ethereum](https://ethereum.org)\n- [LBRY](https://lbry.com)\n- [libp2p](https://libp2p.io)\n\nand [many more](https://ofek.dev/coincurve/users/)!\n\n## License\n\n`coincurve` is distributed under the terms of any of the following licenses:\n\n- [MIT](https://spdx.org/licenses/MIT.html)\n- [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html)\n" }, { "path": "cm_library_c_binding/CMakeLists.txt", "content": "# create folder for _gen code\nfile(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/_gen_c_file)\n\nif (NOT CFFI_C_CODE)\n set(CFFI_C_CODE _cffi_c_code.c)\nendif() \n\nif (NOT CFFI_C_CODE_DIR)\n set(CFFI_C_CODE_DIR \"${PROJECT_BINARY_DIR}/_gen_c_file\")\nendif()\n\n# Copy the build.py file to the build directory\nfile(COPY ${CMAKE_CURRENT_LIST_DIR}/build.py DESTINATION ${CFFI_C_CODE_DIR})\n\ninclude(VerifyPythonModule)\nVerifyPythonModule(cffi ${Python_EXECUTABLE})\n\nif (VENDORED_HEADERS_DIR)\n set(_static_build 'ON')\nelse()\n message(STATUS \"CFFI C-file is built for a SHARED system library\")\n set(_static_build 'OFF')\nendif()\n\n# Generate the CFFI source file\nadd_custom_command(\n OUTPUT ${CFFI_C_CODE_DIR}/${CFFI_C_CODE}\n COMMAND ${Python_EXECUTABLE} ${CFFI_C_CODE_DIR}/build.py\n ${CFFI_HEADERS_DIR}\n ${CFFI_C_CODE_DIR}/${CFFI_C_CODE} ${_static_build}\n MAIN_DEPENDENCY ${CMAKE_CURRENT_LIST_DIR}/build.py\n DEPENDS headers-for-cffi\n WORKING_DIRECTORY ${CFFI_C_CODE_DIR}\n COMMENT \"Generating CFFI source file\"\n)\n\nadd_custom_target(cffi-c-binding ALL DEPENDS ${CFFI_C_CODE_DIR}/${CFFI_C_CODE})\nadd_dependencies(cffi-c-binding headers-for-cffi)\n" }, { "path": "cm_library_c_binding/build.py", "content": "from __future__ import annotations\n\nimport argparse\nimport logging\nimport os\nfrom typing import NamedTuple\n\nfrom cffi import FFI\n\nlogging.basicConfig(level=logging.INFO)\n\nhere = os.path.dirname(os.path.abspath(__file__))\n\n\nclass Source(NamedTuple):\n h: str\n include: str\n\n\ndef gather_sources_from_directory(directory: str) -> list[Source]:\n \"\"\"\n Gather source files from a given directory.\n\n :param directory: The directory where source files are located.\n :return: A list of Source namedtuples.\n \"\"\"\n sources = []\n for filename in os.listdir(directory):\n if filename.endswith(\".h\"):\n include_line = f\"#include <{filename}>\"\n sources.append(Source(filename, include_line))\n return sorted(sources)\n\n\ndefine_static_lib = \"\"\"\n#if defined(_WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)\n# define SECP256K1_STATIC 1\n#endif\n\"\"\"\n\n\ndef mk_ffi(\n directory: str,\n sources: list[Source],\n static_lib: bool = False, # noqa: FBT001, FBT002\n name: str = \"_libsecp256k1\",\n) -> FFI:\n \"\"\"\n Create an FFI object.\n\n :param sources: A list of Source namedtuples.\n :param static_lib: Whether to generate a static lib in Windows.\n :param name: The name of the FFI object.\n :return: An FFI object.\n \"\"\"\n _ffi = FFI()\n code = [define_static_lib] if static_lib else []\n\n logging.info(\" Static %s...\", static_lib)\n for source in sources:\n with open(os.path.join(directory, source.h), encoding=\"utf-8\") as h:\n logging.info(\" Including %s...\", source.h)\n c_header = h.read()\n _ffi.cdef(c_header)\n\n code.append(source.include)\n\n code.append(\"#define PY_USE_BUNDLED\")\n _ffi.set_source(name, \"\\n\".join(code))\n\n return _ffi\n\n\nif __name__ == \"__main__\":\n logging.info(\"Starting CFFI build process...\")\n parser = argparse.ArgumentParser(description=\"Generate C code using CFFI.\")\n parser.add_argument(\"headers_dir\", help=\"Path to the header files.\", type=str)\n parser.add_argument(\"c_file\", help=\"Generated C code filename.\", type=str)\n parser.add_argument(\"static_lib\", help=\"Generate static lib in Windows.\", default=\"0N\", type=str)\n args = parser.parse_args()\n\n modules = gather_sources_from_directory(args.headers_dir)\n ffi = mk_ffi(args.headers_dir, modules, args.static_lib == \"ON\")\n ffi.emit_c_code(args.c_file)\n\n vendor_cffi = os.environ.get(\"COINCURVE_VENDOR_CFFI\", \"1\") == \"1\"\n if vendor_cffi:\n with open(args.c_file, encoding=\"utf-8\") as f:\n source = f.read()\n\n expected_text = 'PyImport_ImportModule(\"_cffi_backend\")'\n if expected_text not in source:\n msg = f\"{expected_text} not found in {args.c_file}\"\n raise ValueError(msg)\n\n new_source = source.replace(expected_text, 'PyImport_ImportModule(\"coincurve._cffi_backend\")')\n with open(args.c_file, \"w\", encoding=\"utf-8\") as f:\n f.write(new_source)\n\n logging.info(\" Generated C code: %s\", args.c_file)\n" }, { "path": "cm_library_cffi_headers/CMakeLists.txt", "content": "# create folder for _gen code\nfile(MAKE_DIRECTORY ${CFFI_HEADERS_DIR})\n\nmacro(generate_cffi_header src_header cffi_header cffi_dir)\n add_custom_command(\n OUTPUT ${cffi_dir}/${cffi_header}\n COMMAND ${Python_EXECUTABLE} ${CMAKE_CURRENT_LIST_DIR}/compose_cffi_headers.py\n ${src_header} ${cffi_header} ${cffi_dir}\n MAIN_DEPENDENCY ${CMAKE_CURRENT_LIST_DIR}/compose_cffi_headers.py\n DEPENDS ${src_header}\n WORKING_DIRECTORY ${cffi_dir}\n )\n add_custom_target(${cffi_header} ALL DEPENDS ${cffi_dir}/${cffi_header})\nendmacro()\n\n# Extract files from full path of src_headers\nif(VENDORED_HEADERS_DIR)\n file(GLOB src_headers ${VENDORED_HEADERS_DIR}/*.h)\nelseif(VENDORED_AS_SYSTEM_LIB_FOUND)\n message(WARNING \"Using system library ${VENDORED_LIBRARY_CMAKE_TARGET}. The list of headers is set to:\"\n \" /*${VENDORED_LIBRARY_CMAKE_TARGET}/*.h\")\n file(GLOB src_headers ${VENDORED_AS_SYSTEM_LIB_INCLUDE_DIRS}/*${VENDORED_LIBRARY_CMAKE_TARGET}*.h)\n message(STATUS \" Generating CFFI header for ${src_headers}\")\nelse()\n message(FATAL_ERROR \"Headers for CFFI cannot be found. Exiting\")\nendif()\n\nadd_custom_target(headers-for-cffi)\n\nforeach(src_header ${src_headers})\n get_filename_component(cffi_header ${src_header} NAME)\n get_filename_component(src_header_dir ${src_header} DIRECTORY)\n generate_cffi_header(${src_header_dir} ${cffi_header} ${CFFI_HEADERS_DIR})\n add_dependencies(headers-for-cffi ${cffi_header})\nendforeach()\n" }, { "path": "cm_library_cffi_headers/compose_cffi_headers.py", "content": "import argparse\nimport logging\nimport os\nimport re\nimport sys\n\nlogging.basicConfig(level=logging.ERROR)\n\n\ndef remove_c_comments_emptylines(text):\n text = re.sub(r\"/\\*.*?\\*/\", \"\", text, flags=re.DOTALL) # Remove multi-line comments\n text = re.sub(r\"//.*\", \"\", text) # Remove single-line comments\n return re.sub(r\"\\n\\s*\\n+\", \"\\n\", text) # Remove empty lines\n\n\ndef remove_c_includes(lines):\n return [line for line in lines if not re.match(r\"^\\s*#include\\s\", line)]\n\n\ndef remove_special_defines(lines, defines):\n return [line for line in lines if not any(f\"#define {define}\" in line for define in defines)]\n\n\ndef apply_cffi_defines_syntax(lines):\n return [re.sub(r\"#\\s*define\\s+(\\w+).*\", r\"#define \\1 ...\", line) for line in lines]\n\n\ndef remove_c_ifdef(lines):\n processed_lines = []\n\n # The first #if is the multi-inclusion guard\n ifdef_count = -1\n\n for line in lines:\n stripped_line = line.rstrip()\n\n if re.match(r\"^#\\s*(if|el|endif)\", stripped_line):\n stripped_line = stripped_line.replace(\" \", \"\")\n ifdef_count += stripped_line.count(\"#if\") - stripped_line.count(\"#endif\")\n continue\n\n if ifdef_count == 0:\n processed_lines.append(stripped_line)\n elif ifdef_count < 0 and line != lines[-1]:\n msg = \"Unbalanced #if/#endif preprocessor directives.\"\n raise ValueError(msg)\n\n return processed_lines\n\n\ndef concatenate_c_defines(lines):\n buffer = []\n processed_lines = []\n in_define = False\n\n for line in lines:\n stripped_line = line.rstrip()\n\n if (re.match(r\"#\\s*define\", stripped_line) or in_define) and stripped_line.endswith(\"\\\\\"):\n in_define = True\n buffer.append(\n re.sub(r\"#\\s*define\", \"#define\", stripped_line).rstrip(\"\\\\\").strip()\n ) # Normalize #define and remove trailing backslash\n continue # Skip the rest of the loop to avoid resetting the buffer\n\n if in_define:\n buffer.append(stripped_line)\n processed_lines.append(\" \".join(buffer))\n buffer = [] # Reset the buffer for the next definition\n in_define = False\n continue # Skip the rest of the loop to avoid adding the line again\n\n processed_lines.append(stripped_line)\n\n return processed_lines\n\n\ndef remove_deprecated_functions(lines, deprecation):\n buffer = []\n processed_lines = []\n in_struct = False\n in_define = False\n brace_count = 0\n\n for line in lines:\n stripped_line = line.rstrip()\n\n if re.match(r\"#\\s*define\", stripped_line) or in_define:\n in_define = bool(stripped_line.endswith(\"\\\\\"))\n processed_lines.append(stripped_line)\n continue\n\n if stripped_line.startswith(\"struct\") or re.match(r\"typedef\\s+struct\", stripped_line) or in_struct:\n in_struct = True\n processed_lines.append(stripped_line)\n brace_count += stripped_line.count(\"{\") - stripped_line.count(\"}\")\n if brace_count == 0: # End of struct block\n in_struct = False\n continue\n\n buffer.append(stripped_line)\n\n # Check for the end of a function declaration\n if stripped_line.endswith(\";\") and not in_struct:\n # Extend if not DEPRECATED\n if not any(d in \" \".join(buffer) for d in deprecation):\n processed_lines.extend(buffer)\n buffer = [] # Reset the buffer for the next definition\n\n return processed_lines\n\n\ndef remove_function_attributes(lines, attributes):\n processed_lines = []\n\n for line in lines:\n stripped_line = line.rstrip()\n\n for attribute, replacement in attributes.items():\n # Attributes can be functions with (...), so using regular expression\n # Remove the definition\n if re.search(rf\"#\\s*define\\s+{attribute}(\\(.*\\))?\\b\", stripped_line):\n stripped_line = None\n break\n\n if re.search(rf\"\\b{attribute}(\\(.*\\))?\\b\", stripped_line):\n stripped_line = re.sub(rf\"\\b{attribute}(\\(.*\\))?\", f\"{replacement}\", stripped_line)\n stripped_line = stripped_line.replace(\" ;\", \";\")\n stripped_line = stripped_line.replace(\" \", \" \")\n\n if stripped_line:\n processed_lines.append(stripped_line)\n\n return processed_lines\n\n\ndef remove_header_guard(lines, keywords):\n processed_lines = []\n\n for line in lines:\n stripped_line = line.rstrip()\n\n for keyword in keywords:\n if re.search(rf\"#\\s*define\\s+{keyword}.*_H\\b\", stripped_line):\n continue\n processed_lines.append(stripped_line)\n\n return processed_lines\n\n\ndef concatenate_c_struct(lines):\n buffer = []\n processed_lines = []\n in_struct = False\n brace_count = 0\n\n for line in lines:\n stripped_line = line.strip()\n\n if stripped_line.startswith(\"struct\") or re.match(r\"typedef\\s+struct\", stripped_line) or in_struct:\n in_struct = True\n brace_count += stripped_line.count(\"{\") - stripped_line.count(\"}\")\n buffer.append(stripped_line)\n if brace_count == 0: # End of struct block\n processed_lines.append(\" \".join(buffer).strip())\n buffer = [] # Reset the buffer for the next definition\n in_struct = False\n continue # Skip the rest of the loop to avoid adding the line again\n\n processed_lines.append(stripped_line)\n\n return processed_lines\n\n\ndef make_header_cffi_compliant(src_header_dir, src_header, cffi_dir):\n with open(os.path.join(src_header_dir, src_header), encoding=\"utf-8\") as f:\n text = remove_c_comments_emptylines(f.read())\n lines = text.split(\"\\n\")\n\n lines = remove_c_includes(lines)\n lines = remove_c_ifdef(lines)\n lines = concatenate_c_defines(lines)\n lines = remove_deprecated_functions(lines, [\"DEPRECATED\"])\n lines = remove_header_guard(lines, [\"SECP256K1\"])\n lines = remove_function_attributes(\n lines,\n {\n \"SECP256K1_API\": \"extern\",\n \"SECP256K1_WARN_UNUSED_RESULT\": \"\",\n \"SECP256K1_DEPRECATED\": \"\",\n \"SECP256K1_ARG_NONNULL\": \"\",\n },\n )\n lines = remove_special_defines(\n lines,\n [\n # Deprecated flags\n \"SECP256K1_CONTEXT_VERIFY\",\n \"SECP256K1_CONTEXT_SIGN\",\n \"SECP256K1_FLAGS_BIT_CONTEXT_VERIFY\",\n \"SECP256K1_FLAGS_BIT_CONTEXT_SIGN\",\n # Testing flags\n \"SECP256K1_CONTEXT_DECLASSIFY\",\n \"SECP256K1_FLAGS_BIT_CONTEXT_DECLASSIFY\",\n # Not for direct use - That may not mean to remove them!\n # 'SECP256K1_FLAGS_TYPE_MASK',\n # 'SECP256K1_FLAGS_TYPE_CONTEXT',\n # 'SECP256K1_FLAGS_TYPE_COMPRESSION',\n # 'SECP256K1_FLAGS_BIT_COMPRESSION',\n # Not supported\n \"SECP256K1_SCHNORRSIG_EXTRAPARAMS_MAGIC\",\n \"SECP256K1_SCHNORRSIG_EXTRAPARAMS\",\n ],\n )\n lines = apply_cffi_defines_syntax(lines)\n\n logging.info(\" Writing: %s in %s\", src_header, cffi_dir)\n output_filename = os.path.join(cffi_dir, src_header)\n with open(output_filename, \"w\", encoding=\"utf-8\") as f_out:\n f_out.write(\"\\n\".join(lines))\n\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser(description=\"Process a header file.\")\n parser.add_argument(\"src_header_dir\", type=str, help=\"The path to the header file to be processed.\")\n parser.add_argument(\"cffi_header\", type=str, help=\"The path where the compliant header will be written.\")\n parser.add_argument(\"cffi_dir\", type=str, help=\"The path where the compliant header will be written.\", default=\".\")\n\n args = parser.parse_args()\n\n # Verify args are valid\n if not os.path.isdir(args.src_header_dir):\n logging.error(\"Error: Directory: %s not found.\", args.src_header_dir)\n sys.exit(1)\n\n if not os.path.isdir(args.cffi_dir):\n logging.error(\"Error: Directory: %s not found.\", args.cffi_dir)\n sys.exit(1)\n\n if not os.path.isfile(os.path.join(args.src_header_dir, args.cffi_header)):\n logging.error(\"Error: %s not found in %s.\", args.cffi_header, args.src_header_dir)\n sys.exit(1)\n\n make_header_cffi_compliant(args.src_header_dir, args.cffi_header, args.cffi_dir)\n" }, { "path": "cm_python_module/CMakeLists.txt", "content": "# Create the shared library from the CFFI binding and the static library from ${CFFI_INPUT_LIBRARY}\nif (CMAKE_SYSTEM_NAME STREQUAL \"Windows\")\n Python_add_library(${CFFI_OUTPUT_LIBRARY} MODULE USE_SABI 3.8 \"${CFFI_C_CODE_DIR}/${CFFI_C_CODE}\")\nelse()\n set(Python_SOABI ${SKBUILD_SOABI})\n Python_add_library(${CFFI_OUTPUT_LIBRARY} MODULE WITH_SOABI \"${CFFI_C_CODE_DIR}/${CFFI_C_CODE}\")\n target_compile_definitions(${CFFI_OUTPUT_LIBRARY} PRIVATE Py_LIMITED_API)\nendif()\n\nset_source_files_properties(\"${CFFI_C_CODE_DIR}/${CFFI_C_CODE}\" PROPERTIES GENERATED 1)\n\n# Detect whether the vendored library is a system library or not\nif (PROJECT_IGNORE_SYSTEM_LIB OR NOT VENDORED_AS_SYSTEM_LIB_FOUND)\n # The build-type seems to be defined as 'MODULE', which creates issues with missing variables\n # for CMake: (This only happens on Windows though ...)\n set(CMAKE_MODULE_LINKER_FLAGS_COVERAGE \"\")\n\n add_dependencies(${CFFI_OUTPUT_LIBRARY} ${CFFI_INPUT_LIBRARY})\n add_dependencies(${CFFI_OUTPUT_LIBRARY} cffi-c-binding)\n target_include_directories(${CFFI_OUTPUT_LIBRARY} PUBLIC ${VENDORED_HEADERS_DIR})\n\n # Link the vendored library to the output library\n # https://docs.python.org/3/c-api/stable.html#limited-c-api\n target_link_libraries(${CFFI_OUTPUT_LIBRARY} PRIVATE ${CFFI_INPUT_LIBRARY})\nelseif(VENDORED_AS_SYSTEM_LIB_FOUND)\n message(STATUS \"Vendored system library found: ${VENDORED_AS_SYSTEM_LIB_LIBRARIES}\")\n target_include_directories(${CFFI_OUTPUT_LIBRARY} PRIVATE ${VENDORED_AS_SYSTEM_LIB_INCLUDE_DIRS})\n add_dependencies(${CFFI_OUTPUT_LIBRARY} cffi-c-binding)\n # On windows, using the LDFLAGS field creates /libpath... secp256k1.lib (correct), but at a later stage\n # /libpath is converted to \\libpath and fails to be interpreted as a flag by the linker\n # This may be an issue with libsecp256k1.pc, i.e. wrong slash used that triggers the slash conversion\n target_link_libraries(${CFFI_OUTPUT_LIBRARY} PRIVATE ${VENDORED_AS_SYSTEM_LIB_LIBRARIES})\n string(REPLACE \"/libpath:\" \"\" VENDORED_AS_SYSTEM_LIB_LIBRARY_DIRS ${VENDORED_AS_SYSTEM_LIB_LIBRARY_DIRS})\n string(REPLACE \"/LIBPATH:\" \"\" VENDORED_AS_SYSTEM_LIB_LIBRARY_DIRS ${VENDORED_AS_SYSTEM_LIB_LIBRARY_DIRS})\n target_link_directories(${CFFI_OUTPUT_LIBRARY} PRIVATE ${VENDORED_AS_SYSTEM_LIB_LIBRARY_DIRS})\nelse()\n message(FATAL_ERROR \"Vendored library not found.\")\nendif()\n\n\n# Add platform-specific definitions\nif(CMAKE_SYSTEM_NAME STREQUAL \"Linux\")\n target_compile_definitions(${CFFI_OUTPUT_LIBRARY} PUBLIC \"IS_LINUX\")\nendif()\nif(CMAKE_SYSTEM_NAME STREQUAL \"Darwin\")\n target_compile_definitions(${CFFI_OUTPUT_LIBRARY} PUBLIC \"IS_MACOS\")\nendif()\nif(CMAKE_SYSTEM_NAME STREQUAL \"Windows\")\n target_compile_definitions(${CFFI_OUTPUT_LIBRARY} PUBLIC \"IS_WINDOWS\")\nendif()\n" }, { "path": "cm_vendored_library/CMakeLists.txt", "content": "if (PROJECT_IGNORE_SYSTEM_LIB OR NOT VENDORED_AS_SYSTEM_LIB_FOUND)\n # Note that this could also be handled by: ExternalProject_Add\n # However, FetchContent is a more flexible way to handle this\n # https://cmake.org/cmake/help/latest/module/ExternalProject.html\n # https://cmake.org/cmake/help/latest/module/FetchContent.html\n include(GNUInstallDirs)\n include(FetchContent)\n\n # Set ULR based upon CMake definitions\n if (NOT VENDORED_UPSTREAM_URL)\n set(VENDORED_UPSTREAM_URL \"https://github.com/bitcoin-core/secp256k1/archive\")\n endif()\n\n if (NOT VENDORED_UPSTREAM_REF)\n message(STATUS \"VENDORED_UPSTREAM_REF not set, using default value.\")\n set(VENDORED_UPSTREAM_REF \"1ad5185cd42c0636104129fcc9f6a4bf9c67cc40\")\n endif()\n\n if (NOT VENDORED_UPSTREAM_SHA)\n message(STATUS \"VENDORED_UPSTREAM_SHA not set, using default value.\")\n set(VENDORED_UPSTREAM_SHA \"ba34be4319f505c5766aa80b99cfa696cbb2993bfecf7d7eb8696106c493cb8c\")\n endif()\n\n if (NOT CMAKE_BUILD_TYPE)\n set(CMAKE_BUILD_TYPE Release)\n endif()\n\n # -fPIC is needed since we will link it from a shared object\n if (VENDORED_LIBRARY_STATIC_BUILD)\n set(CMAKE_POSITION_INDEPENDENT_CODE ON)\n endif()\n\n include(UpdateVendoredLibraryOptions)\n UpdateVendoredLibraryOptions(\"VENDORED_OPTION\" \"${VENDORED_LIBRARY_OPTION_PREFIX}\")\n\n\n FetchContent_Declare(\n vendored_library\n URL \"${VENDORED_UPSTREAM_URL}/${VENDORED_UPSTREAM_REF}.tar.gz\"\n URL_HASH \"SHA256=${VENDORED_UPSTREAM_SHA}\"\n )\n FetchContent_MakeAvailable(vendored_library)\n\n if (NOT IS_DIRECTORY ${vendored_library_SOURCE_DIR}/include)\n message(FATAL_ERROR \"The system library: ${VENDORED_LIBRARY_PKG_CONFIG} was not found OR\")\n message(FATAL_ERROR \"The IGNORE_SYSTEM_LIB flag was not set (${PROJECT_IGNORE_SYSTEM_LIB}) OR\")\n message(FATAL_ERROR \"The vendored library was not installed correctly (/include does not exists). Exiting\")\n else()\n set(VENDORED_HEADERS_DIR \"${vendored_library_SOURCE_DIR}/include\" CACHE PATH \"Path to the vendored headers\")\n\n # Avoid spurious warnings when building the vendored library\n unset(VENDORED_UPSTREAM_URL PARENT_SCOPE)\n unset(VENDORED_UPSTREAM_REF PARENT_SCOPE)\n unset(VENDORED_UPSTREAM_SHA PARENT_SCOPE)\n endif()\nelse()\n include(UnsetVendoredLibraryOptions)\n UnsetVendoredLibraryOptions(\"VENDORED_OPTION\")\n unset(VENDORED_LIBRARY_OPTION_PREFIX)\n unset(VENDORED_LIBRARY_STATIC_BUILD)\n unset(VENDORED_UPSTREAM_URL)\n unset(VENDORED_UPSTREAM_REF)\n unset(VENDORED_UPSTREAM_SHA)\nendif()" }, { "path": "cmake/SetCrossCompilerGithubActions.cmake", "content": "function(SetCrossCompilerGithubActions)\n # Cross-compilation options: This is setup for Github/Actions runners\n # For Linux, we use cibuildwheel to build the wheels, which uses Docker\n if (PROJECT_CROSS_COMPILE_TARGET AND CMAKE_SYSTEM_NAME STREQUAL \"Darwin\")\n set(AUTOMATIC_OSX_TARGETS \"armv7\" \"armv7s\" \"arm64\" \"arm64e\" \"x86_64\")\n\n if (\"${PROJECT_CROSS_COMPILE_TARGET}\" IN_LIST AUTOMATIC_OSX_TARGETS)\n set(CMAKE_OSX_ARCHITECTURES ${PROJECT_CROSS_COMPILE_TARGET})\n else()\n message(FATAL_ERROR \"Cross-compilation target not supported: >${PROJECT_CROSS_COMPILE_TARGET}< (${AUTOMATIC_OSX_TARGETS})\")\n endif()\n\n elseif (PROJECT_CROSS_COMPILE_TARGET AND CMAKE_SYSTEM_NAME STREQUAL \"Windows\")\n set(AUTOMATIC_WINDOWS_TARGETS \"AMD64\" \"x86\" \"arm64\")\n\n if (\"${PROJECT_CROSS_COMPILE_TARGET}\" IN_LIST AUTOMATIC_WINDOWS_TARGETS)\n # Cross-compilation for Windows host system:\n set(CMAKE_SYSTEM_PROCESSOR ${PROJECT_CROSS_COMPILE_TARGET})\n set(CMAKE_LIBRARY_ARCHITECTURE ${PROJECT_CROSS_COMPILE_TARGET})\n else()\n message(FATAL_ERROR \"Cross-compilation target not supported: >${PROJECT_CROSS_COMPILE_TARGET}< (${AUTOMATIC_WINDOWS_TARGETS})\")\n endif()\n endif()\nendfunction()\n" }, { "path": "cmake/SetDefaultVendoredLibrary.cmake", "content": "function (SetDefaultVendoredLibrary)\n if (DEFINED VENDORED_LIBRARY_CMAKE_TARGET)\n set(VENDORED_LIBRARY_CMAKE_TARGET ${VENDORED_LIBRARY_CMAKE_TARGET})\n else()\n set(VENDORED_LIBRARY_CMAKE_TARGET \"secp256k1\")\n endif()\n set(VENDORED_LIBRARY_CMAKE_TARGET ${VENDORED_LIBRARY_CMAKE_TARGET} PARENT_SCOPE)\n\n if (DEFINED VENDORED_LIBRARY_PKG_CONFIG)\n set(VENDORED_LIBRARY_PKG_CONFIG ${VENDORED_LIBRARY_PKG_CONFIG})\n else()\n set(VENDORED_LIBRARY_PKG_CONFIG \"lib${VENDORED_LIBRARY_CMAKE_TARGET}\")\n endif()\n set(VENDORED_LIBRARY_PKG_CONFIG ${VENDORED_LIBRARY_PKG_CONFIG} PARENT_SCOPE)\n\n if (DEFINED VENDORED_LIBRARY_PKG_CONFIG_VERSION)\n set(VENDORED_LIBRARY_PKG_CONFIG_VERSION ${VENDORED_LIBRARY_PKG_CONFIG_VERSION})\n else()\n set(VENDORED_LIBRARY_PKG_CONFIG_VERSION \"0.4.1\")\n endif()\n set(VENDORED_LIBRARY_PKG_CONFIG_VERSION ${VENDORED_LIBRARY_PKG_CONFIG_VERSION} PARENT_SCOPE)\nendfunction()" }, { "path": "cmake/SetSystemLibIfExists.cmake", "content": "function (SetSystemLibIfExists)\n set(ENV{PKG_CONFIG_PATH} \"$ENV{PKG_CONFIG_PATH};$ENV{CONDA_PREFIX}/Library/lib/pkgconfig;$ENV{CONDA_PREFIX}/lib/pkgconfig\")\n if(CMAKE_SYSTEM_NAME STREQUAL \"Windows\")\n set(PKG_CONFIG_EXECUTABLE \"${PKG_CONFIG_EXECUTABLE};--msvc-syntax;--dont-define-prefix\")\n endif()\n pkg_check_modules(VENDORED_AS_SYSTEM_LIB IMPORTED_TARGET GLOBAL ${VENDORED_LIBRARY_PKG_CONFIG}>=${VENDORED_LIBRARY_PKG_CONFIG_VERSION})\nendfunction()\n" }, { "path": "cmake/UnsetVendoredLibraryOptions.cmake", "content": "function (UnsetVendoredLibraryOptions _prefix)\n get_cmake_property(_vars VARIABLES)\n string (REGEX MATCHALL \"(^|;)${_prefix}[A-Za-z0-9_]*\" _matchedVars \"${_vars}\")\n foreach (_var ${_matchedVars})\n unset (${_var} PARENT_SCOPE)\n endforeach()\nendfunction()\n" }, { "path": "cmake/UpdateVendoredLibraryOptions.cmake", "content": "function (UpdateVendoredLibraryOptions _prefix _newPrefix)\n get_cmake_property(_vars VARIABLES)\n string (REGEX MATCHALL \"(^|;)${_prefix}[A-Za-z0-9_]*\" _matchedVars \"${_vars}\")\n foreach (_var ${_matchedVars})\n string (REGEX REPLACE \"^${_prefix}\" \"${_newPrefix}\" _newVar ${_var})\n set(${_newVar} ${${_var}} PARENT_SCOPE)\n unset (${_var} PARENT_SCOPE)\n endforeach()\nendfunction()\n" }, { "path": "cmake/VerifyPythonModule.cmake", "content": "# Verify CFFI python module is available\nfunction(VerifyPythonModule module python_executable)\n find_package(Python3 REQUIRED COMPONENTS Interpreter)\n execute_process(\n COMMAND ${python_executable} -c \"import ${module}\"\n ERROR_VARIABLE _error\n OUTPUT_QUIET\n ERROR_STRIP_TRAILING_WHITESPACE\n )\n\n if(_error)\n message(FATAL_ERROR \"${module} is required to build coincurve\")\n endif()\nendfunction()\n" }, { "path": "docs/.snippets/abbrs.txt", "content": "*[ECDH]: Elliptic-curve Diffie–Hellman\n*[PyPI]: Python Package Index\n" }, { "path": "docs/.snippets/links.txt", "content": "[Bitcoin Core]: https://github.com/bitcoin/bitcoin\n[ECDH]: https://en.wikipedia.org/wiki/Elliptic-curve_Diffie%E2%80%93Hellman\n[RFC 6979]: https://tools.ietf.org/html/rfc6979\n[libsecp256k1]: https://github.com/bitcoin-core/secp256k1\n[secp256k1]: https://en.bitcoin.it/wiki/Secp256k1\n" }, { "path": "docs/api.md", "content": "# Developer Interface\n\n-----\n\nAll objects are available directly under the root namespace `coincurve`.\n\n::: coincurve.verify_signature\n\n::: coincurve.PrivateKey\n options:\n members:\n - __init__\n - sign\n - sign_recoverable\n - sign_schnorr\n - ecdh\n - add\n - multiply\n - to_int\n - to_hex\n - to_pem\n - to_der\n - from_int\n - from_hex\n - from_pem\n - from_der\n\n::: coincurve.PublicKey\n options:\n members:\n - __init__\n - verify\n - format\n - point\n - combine\n - add\n - multiply\n - combine_keys\n - from_signature_and_message\n - from_secret\n - from_valid_secret\n - from_point\n\n::: coincurve.PublicKeyXOnly\n options:\n members:\n - __init__\n - verify\n - format\n - tweak_add\n - from_secret\n - from_valid_secret\n" }, { "path": "docs/assets/css/custom.css", "content": "/* Brighter links for dark mode */\n[data-md-color-scheme=slate] {\n /* https://github.com/squidfunk/mkdocs-material/blob/9.1.2/src/assets/stylesheets/main/_colors.scss#L91-L92 */\n --md-typeset-a-color: var(--md-primary-fg-color--light);\n}\n\n/* FiraCode https://github.com/tonsky/FiraCode */\ncode { font-family: 'Fira Code', monospace; }\n@supports (font-variation-settings: normal) {\n code { font-family: 'Fira Code VF', monospace; }\n}\n\n/* https://github.com/squidfunk/mkdocs-material/issues/1522 */\n.md-typeset h5 {\n color: var(--md-default-fg-color);\n text-transform: none;\n}\n\n/* Indentation. */\ndiv.doc-contents:not(.first) {\n padding-left: 25px;\n border-left: .05rem solid var(--md-typeset-table-color);\n}\n\n/* Mark external links as such. */\na.external::after,\na.autorefs-external::after {\n /* https://primer.style/octicons/arrow-up-right-24 */\n mask-image: url('data:image/svg+xml,');\n -webkit-mask-image: url('data:image/svg+xml,');\n content: ' ';\n\n display: inline-block;\n vertical-align: middle;\n position: relative;\n\n height: 1em;\n width: 1em;\n background-color: currentColor;\n}\n\na.external:hover::after,\na.autorefs-external:hover::after {\n background-color: var(--md-accent-fg-color);\n}\n" }, { "path": "docs/benchmarks.md", "content": "# Benchmarks\n\n-----\n\n## Setup\n\nDownload [Hatch](https://hatch.pypa.io/latest/install/) or [UV](https://docs.astral.sh/uv/getting-started/installation/) in order to run the benchmarks as follows:\n\n```\n[hatch|uv] run scripts/bench.py\n```\n\n## Results\n\n| Library | Key generation | Signing | Verification | Key export | Key import |\n| --- | --- | --- | --- | --- | --- |\n| coincurve v21.0.0 | 33.4 | 52.8 | 59.0 | 12.6 | 39.4 |\n| [fastecdsa](https://github.com/AntonKueltz/fastecdsa) v3.0.1 | 1319.6 | 1449.5 | 1160.4 | 1402.9 | 15.5 |\n\n!!! note\n - the timings are in microseconds\n - signing and verification use a 16 KiB message\n - the Python version used for the benchmarks is 3.13.x\n" }, { "path": "docs/history.md", "content": "# History\n\n-----\n\nImportant changes are emphasized.\n\n## Unreleased\n\n## 21.0.0\n\n- **Breaking:** Drop support for Python 3.8\n- Add support for Python 3.13\n- Remove all runtime dependencies (`cffi` & `asn1crypto`)\n- Add `COINCURVE_VENDOR_CFFI` environment variable to control vendoring of the `_cffi_backend` module\n- Minor performance improvement by removing use of formatted string constants\n- Upgrade [libsecp256k1][] to version 0.6.0\n\n## 20.0.0\n\n- **Breaking:** CMake is now a build dependency; this is only a breaking change for redistributors as building with standard Python packaging tools will automatically use the CMake that is available on PyPI\n- **Breaking:** Stop building wheels for Windows 32-bit\n- Build wheels for Windows ARM64\n- Upgrade [libsecp256k1][] to version 0.5.0\n\n## 19.0.1\n\n- Fix regression in Windows wheels\n\n## 19.0.0\n\n- **Breaking:** Drop support for Python 3.7\n- Add support for Python 3.12\n- Upgrade [libsecp256k1][] to version 0.4.1\n\n## 18.0.0\n\n- Support Schnorr signatures\n- Add support for Python 3.11\n- Upgrade [libsecp256k1][] to the latest available version\n\n## 17.0.0\n\n- **Breaking:** Drop support for Python 3.6\n- Fix wheels for Apple M1\n- Upgrade [libsecp256k1][] to the latest available version\n\n## 16.0.0\n\n- Wheels for Apple Silicon and musl linux (Alpine)\n- No wheels for PyPy until the build system is fixed\n\n## 15.0.1\n\n- Fix the `combine` method of `PublicKey`\n\n## 15.0.0\n\n- **Breaking:** Drop support for Python 2\n- **Breaking:** Binary wheels for CPython require version 19.3 or later of ``pip`` to install\n- Build AArch64 binary wheels for Linux\n- Build binary wheels for PyPy3.6 7.3.3 & PyPy3.7 7.3.3 on Linux\n- Upgrade [libsecp256k1][] to the latest available version\n- Upgrade libgmp to the latest available version\n- Introduce `COINCURVE_UPSTREAM_REF` environment variable to select an alternative [libsecp256k1][] version when building from source\n- Support PEP 561 type hints\n- Added support for supplying a custom nonce to `PrivateKey.sign_recoverable`\n\n## 14.0.0\n\n**IMPORTANT: This will be the final release that supports Python 2.**\n\n- **New:** Binary wheels for Python 3.9\n- **Breaking:** Drop support for Python 3.5\n- Fetch [libsecp256k1][] source if the system installation lacks ECDH support\n- Fix innocuous `setuptools` warning when building from source\n- Switch CI/CD to GitHub Actions\n\n## 13.0.0\n\n- **New:** Binary wheels for Python 3.8\n- Support building on OpenBSD\n- Improve handling of PEM private key deserialization\n- Improve ECDH documentation\n- Improvements from [libsecp256k1][] master\n\n## 12.0.0\n\n- **New:** Binary wheels on Linux for PyPy3.6 v7.1.1-beta\n- **New:** Binary wheels on macOS for Python 3.8.0-alpha.3\n- **New:** Binary wheels on Linux are now also built with the new [manylinux2010](https://www.python.org/dev/peps/pep-0571) spec for 64-bit platforms\n- Improvements from [libsecp256k1][] master\n\n## 11.0.0\n\n- Fix some linking scenarios by placing bundled [libsecp256k1][] dir first in path\n- Allow override of system [libsecp256k1][] with environment variable\n- Add benchmarks\n- Use Codecov to track coverage\n- Use black for code formatting\n\n## 10.0.0\n\n- Support tox for testing\n- Compatibility with latest [libsecp256k1][] ECDH API\n- Make libgmp optional when building from source\n\n## 9.0.0\n\n- Fixed wheels for macOS\n- **Breaking:** Drop support for 32-bit macOS\n\n## 8.0.2\n\n- No longer package tests\n\n## 8.0.0\n\n- **New:** Binary wheels for Python 3.7\n- **Changed:** Binary wheels on macOS for Python 3.5 now use Homebrew\n Python for compilation due to new security requirements\n- Make build system support new GitHub & PyPI security requirements\n- Improvements from [libsecp256k1][] master\n\n## 7.1.0\n\n- Pin version of [libsecp256k1][]\n- Improve docs\n\n## 7.0.0\n\n- Improvements from [libsecp256k1][] master\n- Fix build script\n\n## 6.0.0\n\n- Resolved #6. You can choose to use this or remain on `5.2.0`. This will only be a temporary change, see 3e93480b3e38c6b9beb0bc2de83bc3630fc74c46.\n\n## 5.2.0\n\n- Added support for supplying a custom nonce to `PrivateKey.sign`\n\n## 5.1.0\n\n- Added `PublicKey.combine_keys` class method\n- Improvements to documentation\n\n## 5.0.1\n\n- Fixed an issue where secret validation would occasionally erroneously error\n on user-provided secrets (secrets not generated by Coincurve itself) if there\n were not exactly 256 bits of entropy. See #5.\n\n## 5.0.0\n\n- **Breaking:** Coincurve is now dual-licensed under the terms of `MIT` and `Apache-2.0`\n- Performance improvements from [libsecp256k1][] master\n- Improvements to documentation.\n\n## 4.5.1\n\n- First public stable release\n" }, { "path": "docs/index.md", "content": "# coincurve\n\n| | |\n| --- | --- |\n| CI/CD | [![CI - Test](https://github.com/ofek/coincurve/actions/workflows/build.yml/badge.svg){ loading=lazy }](https://github.com/ofek/coincurve/actions/workflows/build.yml) [![CI - Coverage](https://img.shields.io/codecov/c/github/ofek/coincurve/master.svg?logo=codecov&logoColor=red){ loading=lazy }](https://codecov.io/github/ofek/coincurve) |\n| Docs | [![CI - Docs](https://github.com/ofek/coincurve/actions/workflows/docs.yml/badge.svg){ loading=lazy }](https://github.com/ofek/coincurve/actions/workflows/docs.yml) |\n| Package | [![PyPI - Version](https://img.shields.io/pypi/v/coincurve.svg?logo=pypi&label=PyPI&logoColor=gold){ loading=lazy }](https://pypi.org/project/coincurve/) [![PyPI - Downloads](https://img.shields.io/pypi/dm/coincurve.svg?color=blue&label=Downloads&logo=pypi&logoColor=gold){ loading=lazy }](https://pypi.org/project/coincurve/) [![Required Python Version](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Fofek%2Fcoincurve%2FHEAD%2Fpyproject.toml){ loading=lazy }](https://pypi.org/project/coincurve/) |\n| Meta | [![Hatch project](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg){ loading=lazy }](https://github.com/ofek/dep-sync) [![linting - Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json){ loading=lazy }](https://github.com/astral-sh/ruff) [![types - Mypy](https://img.shields.io/badge/types-Mypy-blue.svg){ loading=lazy }](https://github.com/python/mypy) [![License - MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-9400d3.svg){ loading=lazy }](https://spdx.org/licenses/) [![GitHub Sponsors](https://img.shields.io/github/sponsors/ofek?logo=GitHub%20Sponsors&style=social){ loading=lazy }](https://github.com/sponsors/ofek) |\n\n-----\n\nThis library provides well-tested Python bindings for [libsecp256k1][], the heavily optimized\nC library used by [Bitcoin Core][] for operations on the elliptic curve [secp256k1][].\n\n## Features\n\n- Fastest available implementation (more than 10x faster than OpenSSL)\n- Clean, easy to use API\n- Frequent updates from the development version of [libsecp256k1][]\n- Linux, macOS, and Windows all have binary packages for multiple architectures\n- Deterministic signatures as specified by [RFC 6979][]\n- Non-malleable signatures (lower-S form) by default\n- Secure, non-malleable [ECDH][] implementation\n\n## Users\n\n- [Ethereum](https://ethereum.org)\n- [LBRY](https://lbry.com)\n- [libp2p](https://libp2p.io)\n\nand [many more](users.md)!\n\n## License\n\n`coincurve` is distributed under the terms of any of the following licenses:\n\n- [MIT](https://spdx.org/licenses/MIT.html)\n- [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html)\n\n## Navigation\n\nDesktop readers can use keyboard shortcuts to navigate.\n\n| Keys | Action |\n| --- | --- |\n| | Navigate to the \"previous\" page |\n| | Navigate to the \"next\" page |\n| | Display the search modal |\n" }, { "path": "docs/install.md", "content": "# Installation\n\n-----\n\n`coincurve` is available on PyPI and can be installed with [pip](https://pip.pypa.io):\n\n```\npip install coincurve\n```\n\n## Wheel\n\nBinary wheels are available for most platforms and require at least version `19.3` of pip to install.\n\n| | | | | |\n| --- | --- | --- | --- | --- |\n| | macOS | Windows | Linux (glibc) | Linux (musl) |\n| CPython 3.9 | | | | |\n| CPython 3.10 | | | | |\n| CPython 3.11 | | | | |\n| CPython 3.12 | | | | |\n| CPython 3.13 | | | | |\n\n## Source\n\nIf you are on a platform without support for pre-compiled wheels, you will need certain system packages in order to build from source.\n\nA few environment variables influence the build:\n\n- `COINCURVE_UPSTREAM_REF` - This is the Git reference of [libsecp256k1][] to use rather than the (frequently updated) default.\n- `COINCURVE_IGNORE_SYSTEM_LIB` - The presence of this will force fetching of [libsecp256k1][] even if it's already detected at the system level.\n- `COINCURVE_VENDOR_CFFI` - Setting this to anything other than `1` (the default) prevents vendoring of the `_cffi_backend` module. Re-distributors should make sure to require `cffi` as a runtime dependency when disabling this.\n\n!!! tip\n To avoid installing the binary wheels on compatible distributions, use the `--no-binary` option.\n\n ```\n pip install coincurve --no-binary coincurve\n ```\n\n### Alpine\n\n```\nsudo apk add autoconf automake build-base libffi-dev libtool pkgconfig python3-dev\n```\n\n### Debian/Ubuntu\n\n```\nsudo apt-get install -y autoconf automake build-essential libffi-dev libtool pkg-config python3-dev\n```\n\n### RHEL/CentOS\n\n```\nsudo yum install -y autoconf automake gcc gcc-c++ libffi-devel libtool make pkgconfig python3-devel\n```\n\n### macOS\n\n```\nxcode-select --install\nbrew install autoconf automake libffi libtool pkg-config python\n```\n" }, { "path": "docs/users.md", "content": "# Users\n\n-----\n\n## Organizations\n\n| Name | Projects |\n| --- | --- |\n| [Anyl](https://github.com/Anylsite) | |\n| [ARK](https://ark.io) | |\n| [Augur](https://www.augur.net) | |\n| [Blockcerts](https://www.blockcerts.org) | |\n| [ECIES](https://ecies.org) | |\n| [Elements](https://elementsproject.org) | |\n| [Ethereum](https://ethereum.org) | |\n| [Gnosis](https://gnosis.io) | |\n| [Golem Network](https://golem.network) | |\n| [ICON Foundation](https://icon.foundation) | |\n| [LBRY](https://lbry.com) | |\n| [libp2p](https://libp2p.io) | |\n| [Microsoft](https://www.microsoft.com) | |\n| [NuCypher](https://www.nucypher.com) | |\n| [Quantstamp](https://quantstamp.com) | |\n| [QuarkChain](https://www.quarkchain.io) | |\n| [Raiden Network](https://raiden.network) | |\n| [SKALE Network](https://skale.network) | |\n\n## Projects\n\n- [bit](https://github.com/ofek/bit/blob/776f97ae7f9b3f05157113abc913eb141b2817ee/setup.py#L44)\n- [btcrecover](https://github.com/gurnec/btcrecover/commit/f113867fa22d2f5b22175cc2b5b3892351bc1109)\n- [crankycoin](https://github.com/cranklin/crankycoin/blob/7663a1c5429b3ddd11997b6a2e3488018789bf3b/requirements.txt#L2)\n- [ForkDelta](https://github.com/forkdelta/backend-replacement/blob/97ccd1a19544f26d242a8412113086f0c0dd5760/requirements.txt#L46)\n- [Heimdall](https://github.com/maddevsio/heimdall/blob/21f16880030cfdb1c1c97969158bec02ca6c0336/requirements.txt#L14)\n- [HoneyBadgerBFT](https://github.com/initc3/HoneyBadgerBFT-Python/blob/e8bcbc081dfb5d1e7298039d47bbebf7048b8e62/setup.py#L30)\n- [JoinMarket](https://github.com/JoinMarket-Org/joinmarket-clientserver/blob/dc581e9c99d7db6436ed9f8913b6ce614bcef8d8/jmbitcoin/setup.py#L13)\n- [minichain](https://github.com/kigawas/minichain/blob/0ae0437fdc4aa05e73c4d31a8df91d371542c8fe/pyproject.toml#L13)\n- [Nekoyume](https://github.com/nekoyume/nekoyume/blob/0dec2d6f1002091f3f727bd645ce67fadd85faeb/setup.cfg#L45)\n- [NuCypher](https://github.com/nucypher/nucypher/blob/24a57e1c810aa6408ecfc24942956925146aa024/requirements.txt#L16)\n- [python-idex](https://github.com/sammchardy/python-idex/blob/24cee970172491a7f7d5f52558727a77384cce26/requirements.txt#L2)\n- [Rotki](https://github.com/rotki/rotki/blob/70508f99f890bcbd520f1efe7776194d6a5e5e06/requirements.txt#L8)\n- [Vyper](https://github.com/vyperlang/vyper/blob/3bd0bf96856554810065fa9cfb89afef7625d436/Dockerfile#L15)\n- [ZeroNet](https://github.com/zeronet-conservancy/zeronet-conservancy/blob/b6e18fd3738b4725726c5e170040deb3048c9048/requirements.txt#L12)\n" }, { "path": "hatch.toml", "content": "[envs.default]\ninstaller = \"uv\"\ndev-mode = false\n\n[envs.hatch-static-analysis]\nconfig-path = \"ruff_defaults.toml\"\ndependencies = [\"ruff==0.13.0\"]\n\n[envs.hatch-test]\ndev-mode = false\n\n[envs.types]\ndependencies = [\n \"mypy\",\n \"pytest\",\n]\n[envs.types.scripts]\ncheck = \"mypy --install-types --non-interactive {args:src/coincurve tests}\"\n\n[envs.docs]\ndependencies = [\n \"mkdocs~=1.6.1\",\n \"mkdocs-material~=9.5.40\",\n # Plugins\n \"mkdocs-minify-plugin~=0.8.0\",\n \"mkdocs-git-revision-date-localized-plugin~=1.2.9\",\n \"mkdocs-glightbox~=0.4.0\",\n \"mkdocs-redirects~=1.2.1\",\n \"mkdocstrings-python~=1.16.2\",\n \"mike~=2.1.3\",\n # Extensions\n \"pymdown-extensions~=10.11.2\",\n # Necessary for syntax highlighting in code blocks\n \"pygments~=2.18.0\",\n # Validation\n \"linkchecker~=10.5.0\",\n]\n[envs.docs.env-vars]\nSOURCE_DATE_EPOCH = \"1580601600\"\nPYTHONUNBUFFERED = \"1\"\n[envs.docs.scripts]\nbuild = \"mkdocs build --clean --strict {args}\"\nserve = \"mkdocs serve --dev-addr localhost:8000 {args}\"\nci-build = \"mike deploy --update-aliases {args}\"\nvalidate = \"linkchecker --config .linkcheckerrc site\"\n# https://github.com/linkchecker/linkchecker/issues/678\nbuild-check = [\n \"build --no-directory-urls\",\n \"validate\",\n]\n" }, { "path": "hatch_build.py", "content": "from __future__ import annotations\n\nimport os\nimport shutil\nfrom functools import cached_property\nfrom importlib.metadata import PackagePath, distribution\nfrom typing import Any\n\nimport _cffi_backend # noqa: PLC2701\nfrom hatchling.builders.hooks.plugin.interface import BuildHookInterface\n\n\nclass CustomBuildHook(BuildHookInterface):\n \"\"\"\n A build hook that copies the `_cffi_backend` extension module into the wheel so that\n the `cffi` package is not required as a runtime dependency.\n \"\"\"\n\n LICENSE_NAME = \"LICENSE-cffi\"\n\n @cached_property\n def local_cffi_license(self) -> str:\n return os.path.join(self.root, self.LICENSE_NAME)\n\n @staticmethod\n def get_cffi_distribution_license_files() -> list[PackagePath]:\n license_files = []\n\n dist_files = distribution(\"cffi\").files or []\n for f in dist_files:\n if f.name == \"LICENSE\" and f.parts[0].endswith(\".dist-info\"):\n license_files.append(f)\n break\n\n return license_files\n\n def initialize(self, version: str, build_data: dict[str, Any]) -> None: # noqa: ARG002\n cffi_shared_lib = _cffi_backend.__file__\n relative_path = f\"coincurve/{os.path.basename(cffi_shared_lib)}\"\n build_data[\"force_include\"][cffi_shared_lib] = relative_path\n\n license_files = self.get_cffi_distribution_license_files()\n if len(license_files) != 1:\n message = f\"Expected exactly one LICENSE file in cffi distribution, got {len(license_files)}\"\n raise RuntimeError(message)\n\n license_file = license_files[0]\n shutil.copy2(license_file.locate(), self.local_cffi_license)\n self.metadata.core.license_files.append(self.LICENSE_NAME)\n\n def finalize(self, version: str, build_data: dict[str, Any], artifact: str) -> None: # noqa: ARG002\n os.remove(self.local_cffi_license)\n" }, { "path": "mkdocs.yml", "content": "site_name: coincurve\nsite_description: Cross-platform Python bindings for libsecp256k1\nsite_author: Ofek Lev\nsite_url: https://ofek.dev/coincurve/\nrepo_name: ofek/coincurve\nrepo_url: https://github.com/ofek/coincurve\nedit_uri: blob/master/docs\ncopyright: 'Copyright © Ofek Lev 2017-present'\n\ndocs_dir: docs\nsite_dir: site\ntheme:\n name: material\n language: en\n font:\n text: Roboto\n code: Roboto Mono\n icon:\n logo: material/circle-multiple\n repo: fontawesome/brands/github-alt\n favicon: assets/images/favicon.ico\n palette:\n - media: \"(prefers-color-scheme: dark)\"\n scheme: slate\n primary: teal\n accent: teal\n toggle:\n icon: material/weather-night\n name: Switch to light mode\n - media: \"(prefers-color-scheme: light)\"\n scheme: default\n primary: teal\n accent: teal\n toggle:\n icon: material/weather-sunny\n name: Switch to dark mode\n features:\n - content.action.edit\n - content.code.copy\n - content.tabs.link\n - content.tooltips\n - navigation.expand\n - navigation.footer\n - navigation.instant\n - navigation.sections\n\nnav:\n - About: index.md\n - Install: install.md\n - API Reference: api.md\n - Benchmarks: benchmarks.md\n - Meta:\n - Users: users.md\n - History: history.md\n\nplugins:\n # Built-in\n search: {}\n # Extra\n glightbox: {}\n minify:\n minify_html: true\n git-revision-date-localized:\n type: date\n strict: false\n mkdocstrings:\n default_handler: python\n handlers:\n python:\n paths:\n - src\n options:\n # Rendering\n show_root_full_path: false\n # Headings\n show_root_heading: true\n show_source: false\n show_symbol_type_toc: true\n # Docstrings\n show_if_no_docstring: true\n # Signatures/annotations\n show_signature_annotations: true\n signature_crossrefs: true\n # Other\n show_bases: false\n import:\n - https://docs.python.org/3/objects.inv\n\nmarkdown_extensions:\n # Built-in\n - markdown.extensions.abbr:\n - markdown.extensions.admonition:\n - markdown.extensions.attr_list:\n - markdown.extensions.footnotes:\n - markdown.extensions.md_in_html:\n - markdown.extensions.meta:\n - markdown.extensions.tables:\n - markdown.extensions.toc:\n permalink: true\n # Extra\n - pymdownx.arithmatex:\n - pymdownx.betterem:\n smart_enable: all\n - pymdownx.caret:\n - pymdownx.critic:\n - pymdownx.details:\n - pymdownx.emoji:\n # https://github.com/twitter/twemoji\n # https://raw.githubusercontent.com/facelessuser/pymdown-extensions/master/pymdownx/twemoji_db.py\n emoji_index: !!python/name:material.extensions.emoji.twemoji\n emoji_generator: !!python/name:material.extensions.emoji.to_svg\n - pymdownx.highlight:\n guess_lang: false\n linenums_style: pymdownx-inline\n use_pygments: true\n - pymdownx.inlinehilite:\n - pymdownx.keys:\n - pymdownx.magiclink:\n repo_url_shortener: true\n repo_url_shorthand: true\n social_url_shortener: true\n social_url_shorthand: true\n normalize_issue_symbols: true\n provider: github\n user: ofek\n repo: coincurve\n - pymdownx.mark:\n - pymdownx.progressbar:\n - pymdownx.saneheaders:\n - pymdownx.smartsymbols:\n - pymdownx.snippets:\n check_paths: true\n base_path:\n - docs/.snippets\n auto_append:\n - links.txt\n - abbrs.txt\n - pymdownx.superfences:\n - pymdownx.tabbed:\n alternate_style: true\n slugify: !!python/object/apply:pymdownx.slugs.slugify\n kwds:\n case: lower\n - pymdownx.tasklist:\n custom_checkbox: true\n - pymdownx.tilde:\n\nextra:\n social:\n - icon: fontawesome/brands/github-alt\n link: https://github.com/ofek\n - icon: fontawesome/solid/blog\n link: https://ofek.dev/words/\n - icon: fontawesome/brands/x-twitter\n link: https://x.com/Ofekmeister\n - icon: fontawesome/brands/linkedin\n link: https://www.linkedin.com/in/ofeklev/\nextra_css:\n - assets/css/custom.css\n - https://cdn.jsdelivr.net/npm/firacode@6.2.0/distr/fira_code.css\n" }, { "path": "pyproject.toml", "content": "[build-system]\nbuild-backend = \"hatchling.build\"\nrequires = [\n \"hatchling>=1.27.0\",\n \"cffi\",\n \"scikit-build-core>=0.9.0\",\n \"pkgconf; sys_platform == 'win32'\",\n]\n\n[project]\nname = \"coincurve\"\nauthors = [\n { name = \"Ofek Lev\", email = \"oss@ofek.dev\" },\n]\ndescription = \"Safest and fastest Python library for secp256k1 elliptic curve operations\"\nkeywords = [\n \"bitcoin\",\n \"crypto\",\n \"cryptocurrency\",\n \"ecdh\",\n \"ecdsa\",\n \"elliptic curves\",\n \"ethereum\",\n \"libsecp256k1\",\n \"secp256k1\",\n \"schnorr\",\n]\nreadme = \"README.md\"\nlicense = \"MIT OR Apache-2.0\"\nlicense-files = [\n \"LICENSE-APACHE\",\n \"LICENSE-MIT\",\n \"NOTICE\",\n]\nrequires-python = \">=3.9\"\nclassifiers = [\n \"Development Status :: 5 - Production/Stable\",\n \"Intended Audience :: Developers\",\n \"Natural Language :: English\",\n \"Operating System :: OS Independent\",\n \"Programming Language :: Python :: Implementation :: CPython\",\n \"Programming Language :: Python :: Implementation :: PyPy\",\n \"Topic :: Software Development :: Libraries\",\n \"Topic :: Security :: Cryptography\",\n]\ndynamic = [\"version\"]\n\n[project.urls]\nHomepage = \"https://ofek.dev/coincurve/\"\nSponsor = \"https://github.com/sponsors/ofek\"\nHistory = \"https://ofek.dev/coincurve/history/\"\nTracker = \"https://github.com/ofek/coincurve/issues\"\nSource = \"https://github.com/ofek/coincurve\"\n\n# --- hatch ---\n[tool.hatch.version]\npath = \"src/coincurve/__init__.py\"\n\n[tool.hatch.build.targets.wheel.hooks.custom]\n\n[tool.hatch.build.targets.wheel.hooks.scikit-build]\nexperimental = true\nbuild.verbose = true\ncmake.build-type = \"Release\"\ncmake.source-dir = \".\"\nwheel.py-api = \"\"\nwheel.packages = []\n\n# --- scikit-build-core ---\n[tool.scikit-build.cmake.define]\nCMAKE_BUILD_TYPE = \"Release\"\n# Coincurve build options - This may be better extracted from the ENV by the CMake directly?\nPROJECT_IGNORE_SYSTEM_LIB = { env = \"COINCURVE_IGNORE_SYSTEM_LIB\", default = \"ON\" }\nPROJECT_CROSS_COMPILE_TARGET = { env = \"COINCURVE_CROSS_HOST\", default = \"\" }\n# Vendored library: SECP256K1\nVENDORED_LIBRARY_CMAKE_TARGET = \"secp256k1\"\nVENDORED_LIBRARY_PKG_CONFIG = \"libsecp256k1\"\nVENDORED_LIBRARY_PKG_CONFIG_VERSION = \"0.6.0\"\nVENDORED_UPSTREAM_URL = \"https://github.com/bitcoin-core/secp256k1/archive/\"\nVENDORED_UPSTREAM_REF = { env = \"COINCURVE_UPSTREAM_REF\", default = \"0cdc758a56360bf58a851fe91085a327ec97685a\" }\nVENDORED_UPSTREAM_SHA = { env = \"COINCURVE_UPSTREAM_SHA\", default = \"385c115a21ee1ff31d0b0320acc2b278c92f7bde971f510566ad481a38835be0\" }\n# SECP256K1 library specific build options\n# `VENDORED_OPTION` is reserved prefix for vendored library build options\nVENDORED_LIBRARY_OPTION_PREFIX = \"SECP256K1\"\nVENDORED_OPTION_DISABLE_SHARED = { env = \"COINCURVE_SECP256K1_STATIC\", default = \"ON\" }\nVENDORED_OPTION_BUILD_BENCHMARK = \"OFF\"\nVENDORED_OPTION_BUILD_TESTS = \"OFF\"\nVENDORED_OPTION_BUILD_CTIME_TESTS = \"OFF\"\nVENDORED_OPTION_BUILD_EXHAUSTIVE_TESTS = \"OFF\"\nVENDORED_OPTION_BUILD_EXAMPLES = \"OFF\"\nVENDORED_OPTION_ENABLE_MODULE_ECDH = \"ON\"\nVENDORED_OPTION_ENABLE_MODULE_RECOVERY = \"ON\"\nVENDORED_OPTION_ENABLE_MODULE_SCHNORRSIG = \"ON\"\nVENDORED_OPTION_ENABLE_MODULE_EXTRAKEYS = \"ON\"\nVENDORED_OPTION_EXPERIMENTAL = \"ON\"\n# Vendored library build options (cmake, compiler, linker, etc.)\n# VENDORED_CMAKE is reserved prefix for vendored library cmake options\n# VENDORED_CMAKE__ = \nVENDORED_LIBRARY_STATIC_BUILD = { env = \"COINCURVE_SECP256K1_STATIC\", default = \"ON\" }\n\n# --- Coverage ---\n[tool.coverage.run]\nsource_pkgs = [\"coincurve\", \"tests\"]\nbranch = true\nparallel = true\nomit = [\n \"src/coincurve/__init__.py\",\n \"tests/test_bench.py\",\n]\n\n[tool.coverage.report]\nexclude_lines =[\n \"no cov\",\n\n # Ignore missing debug-only code\n \"def __repr__\",\n \"if self\\\\.debug\",\n\n # Ignore non-runnable code\n \"if __name__ == .__main__.:\",\n]\n\n[tool.coverage.paths]\ncoincurve = [\"src/coincurve\", \"*/coincurve/src/coincurve\"]\ntests = [\"tests\", \"*/coincurve/tests\"]\n\n# --- Pytest ---\n[tool.pytest.ini_options]\naddopts = [\n \"--import-mode=importlib\",\n]\n\n# --- Mypy ---\n[tool.mypy]\ndisallow_untyped_defs = false\nfollow_imports = \"normal\"\nignore_missing_imports = true\npretty = true\nshow_column_numbers = true\nwarn_no_return = false\nwarn_unused_ignores = true\n" }, { "path": "ruff.toml", "content": "extend = \"ruff_defaults.toml\"\n\n[format]\npreview = true\n\n[lint]\npreview = true\n\n[lint.extend-per-file-ignores]\n# Implicit namespace packages\n\"cm_library_c_binding/build.py\" = [\"INP001\"]\n\"cm_library_cffi_headers/compose_cffi_headers.py\" = [\"INP001\"]\n" }, { "path": "ruff_defaults.toml", "content": "line-length = 120\n\n[format]\ndocstring-code-format = true\ndocstring-code-line-length = 80\n\n[lint]\nselect = [\n \"A001\",\n \"A002\",\n \"A003\",\n \"ARG001\",\n \"ARG002\",\n \"ARG003\",\n \"ARG004\",\n \"ARG005\",\n \"ASYNC100\",\n \"ASYNC105\",\n \"ASYNC109\",\n \"ASYNC110\",\n \"ASYNC115\",\n \"B002\",\n \"B003\",\n \"B004\",\n \"B005\",\n \"B006\",\n \"B007\",\n \"B008\",\n \"B009\",\n \"B010\",\n \"B011\",\n \"B012\",\n \"B013\",\n \"B014\",\n \"B015\",\n \"B016\",\n \"B017\",\n \"B018\",\n \"B019\",\n \"B020\",\n \"B021\",\n \"B022\",\n \"B023\",\n \"B024\",\n \"B025\",\n \"B026\",\n \"B028\",\n \"B029\",\n \"B030\",\n \"B031\",\n \"B032\",\n \"B033\",\n \"B034\",\n \"B035\",\n \"B904\",\n \"B905\",\n \"B909\",\n \"BLE001\",\n \"C400\",\n \"C401\",\n \"C402\",\n \"C403\",\n \"C404\",\n \"C405\",\n \"C406\",\n \"C408\",\n \"C409\",\n \"C410\",\n \"C411\",\n \"C413\",\n \"C414\",\n \"C415\",\n \"C416\",\n \"C417\",\n \"C418\",\n \"C419\",\n \"C420\",\n \"COM818\",\n \"DTZ001\",\n \"DTZ002\",\n \"DTZ003\",\n \"DTZ004\",\n \"DTZ005\",\n \"DTZ006\",\n \"DTZ007\",\n \"DTZ011\",\n \"DTZ012\",\n \"E101\",\n \"E112\",\n \"E113\",\n \"E115\",\n \"E116\",\n \"E201\",\n \"E202\",\n \"E203\",\n \"E211\",\n \"E221\",\n \"E222\",\n \"E223\",\n \"E224\",\n \"E225\",\n \"E226\",\n \"E227\",\n \"E228\",\n \"E231\",\n \"E241\",\n \"E242\",\n \"E251\",\n \"E252\",\n \"E261\",\n \"E262\",\n \"E265\",\n \"E266\",\n \"E271\",\n \"E272\",\n \"E273\",\n \"E274\",\n \"E275\",\n \"E401\",\n \"E402\",\n \"E502\",\n \"E701\",\n \"E702\",\n \"E703\",\n \"E711\",\n \"E712\",\n \"E713\",\n \"E714\",\n \"E721\",\n \"E722\",\n \"E731\",\n \"E741\",\n \"E742\",\n \"E743\",\n \"E902\",\n \"EM101\",\n \"EM102\",\n \"EM103\",\n \"EXE001\",\n \"EXE002\",\n \"EXE003\",\n \"EXE004\",\n \"EXE005\",\n \"F401\",\n \"F402\",\n \"F403\",\n \"F404\",\n \"F405\",\n \"F406\",\n \"F407\",\n \"F501\",\n \"F502\",\n \"F503\",\n \"F504\",\n \"F505\",\n \"F506\",\n \"F507\",\n \"F508\",\n \"F509\",\n \"F521\",\n \"F522\",\n \"F523\",\n \"F524\",\n \"F525\",\n \"F541\",\n \"F601\",\n \"F602\",\n \"F621\",\n \"F622\",\n \"F631\",\n \"F632\",\n \"F633\",\n \"F634\",\n \"F701\",\n \"F702\",\n \"F704\",\n \"F706\",\n \"F707\",\n \"F722\",\n \"F811\",\n \"F821\",\n \"F822\",\n \"F823\",\n \"F841\",\n \"F842\",\n \"F901\",\n \"FA100\",\n \"FA102\",\n \"FBT001\",\n \"FBT002\",\n \"FLY002\",\n \"FURB105\",\n \"FURB110\",\n \"FURB113\",\n \"FURB116\",\n \"FURB118\",\n \"FURB129\",\n \"FURB131\",\n \"FURB132\",\n \"FURB136\",\n \"FURB142\",\n \"FURB145\",\n \"FURB148\",\n \"FURB152\",\n \"FURB157\",\n \"FURB161\",\n \"FURB163\",\n \"FURB164\",\n \"FURB166\",\n \"FURB167\",\n \"FURB168\",\n \"FURB169\",\n \"FURB171\",\n \"FURB177\",\n \"FURB180\",\n \"FURB181\",\n \"FURB187\",\n \"FURB192\",\n \"G001\",\n \"G002\",\n \"G003\",\n \"G004\",\n \"G010\",\n \"G101\",\n \"G201\",\n \"G202\",\n \"I001\",\n \"I002\",\n \"ICN001\",\n \"ICN002\",\n \"ICN003\",\n \"INP001\",\n \"INT001\",\n \"INT002\",\n \"INT003\",\n \"ISC003\",\n \"LOG001\",\n \"LOG002\",\n \"LOG007\",\n \"LOG009\",\n \"N801\",\n \"N802\",\n \"N803\",\n \"N804\",\n \"N805\",\n \"N806\",\n \"N807\",\n \"N811\",\n \"N812\",\n \"N813\",\n \"N814\",\n \"N815\",\n \"N816\",\n \"N817\",\n \"N818\",\n \"N999\",\n \"PERF101\",\n \"PERF102\",\n \"PERF401\",\n \"PERF402\",\n \"PERF403\",\n \"PGH005\",\n \"PIE790\",\n \"PIE794\",\n \"PIE796\",\n \"PIE800\",\n \"PIE804\",\n \"PIE807\",\n \"PIE808\",\n \"PIE810\",\n \"PLC0105\",\n \"PLC0131\",\n \"PLC0132\",\n \"PLC0205\",\n \"PLC0208\",\n \"PLC0414\",\n \"PLC0415\",\n \"PLC1901\",\n \"PLC2401\",\n \"PLC2403\",\n \"PLC2701\",\n \"PLC2801\",\n \"PLC3002\",\n \"PLE0100\",\n \"PLE0101\",\n \"PLE0115\",\n \"PLE0116\",\n \"PLE0117\",\n \"PLE0118\",\n \"PLE0237\",\n \"PLE0241\",\n \"PLE0302\",\n \"PLE0303\",\n \"PLE0304\",\n \"PLE0305\",\n \"PLE0307\",\n \"PLE0308\",\n \"PLE0309\",\n \"PLE0604\",\n \"PLE0605\",\n \"PLE0643\",\n \"PLE0704\",\n \"PLE1132\",\n \"PLE1141\",\n \"PLE1142\",\n \"PLE1205\",\n \"PLE1206\",\n \"PLE1300\",\n \"PLE1307\",\n \"PLE1310\",\n \"PLE1507\",\n \"PLE1519\",\n \"PLE1520\",\n \"PLE1700\",\n \"PLE2502\",\n \"PLE2510\",\n \"PLE2512\",\n \"PLE2513\",\n \"PLE2514\",\n \"PLE2515\",\n \"PLE4703\",\n \"PLR0124\",\n \"PLR0133\",\n \"PLR0202\",\n \"PLR0203\",\n \"PLR0206\",\n \"PLR0402\",\n \"PLR1704\",\n \"PLR1711\",\n \"PLR1714\",\n \"PLR1722\",\n \"PLR1730\",\n \"PLR1733\",\n \"PLR1736\",\n \"PLR2004\",\n \"PLR2044\",\n \"PLR5501\",\n \"PLR6104\",\n \"PLR6201\",\n \"PLR6301\",\n \"PLW0108\",\n \"PLW0120\",\n \"PLW0127\",\n \"PLW0128\",\n \"PLW0129\",\n \"PLW0131\",\n \"PLW0133\",\n \"PLW0177\",\n \"PLW0211\",\n \"PLW0245\",\n \"PLW0406\",\n \"PLW0602\",\n \"PLW0603\",\n \"PLW0604\",\n \"PLW0642\",\n \"PLW0711\",\n \"PLW1501\",\n \"PLW1508\",\n \"PLW1509\",\n \"PLW1510\",\n \"PLW1514\",\n \"PLW1641\",\n \"PLW2101\",\n \"PLW2901\",\n \"PLW3201\",\n \"PLW3301\",\n \"PT001\",\n \"PT002\",\n \"PT003\",\n \"PT006\",\n \"PT007\",\n \"PT008\",\n \"PT009\",\n \"PT010\",\n \"PT011\",\n \"PT012\",\n \"PT013\",\n \"PT014\",\n \"PT015\",\n \"PT016\",\n \"PT017\",\n \"PT018\",\n \"PT019\",\n \"PT020\",\n \"PT021\",\n \"PT022\",\n \"PT023\",\n \"PT024\",\n \"PT025\",\n \"PT026\",\n \"PT027\",\n \"PYI001\",\n \"PYI002\",\n \"PYI003\",\n \"PYI004\",\n \"PYI005\",\n \"PYI006\",\n \"PYI007\",\n \"PYI008\",\n \"PYI009\",\n \"PYI010\",\n \"PYI011\",\n \"PYI012\",\n \"PYI013\",\n \"PYI014\",\n \"PYI015\",\n \"PYI016\",\n \"PYI017\",\n \"PYI018\",\n \"PYI019\",\n \"PYI020\",\n \"PYI021\",\n \"PYI024\",\n \"PYI025\",\n \"PYI026\",\n \"PYI029\",\n \"PYI030\",\n \"PYI032\",\n \"PYI033\",\n \"PYI034\",\n \"PYI035\",\n \"PYI036\",\n \"PYI041\",\n \"PYI042\",\n \"PYI043\",\n \"PYI044\",\n \"PYI045\",\n \"PYI046\",\n \"PYI047\",\n \"PYI048\",\n \"PYI049\",\n \"PYI050\",\n \"PYI051\",\n \"PYI052\",\n \"PYI053\",\n \"PYI054\",\n \"PYI055\",\n \"PYI056\",\n \"PYI058\",\n \"PYI059\",\n \"PYI062\",\n \"RET503\",\n \"RET504\",\n \"RET505\",\n \"RET506\",\n \"RET507\",\n \"RET508\",\n \"RSE102\",\n \"RUF001\",\n \"RUF002\",\n \"RUF003\",\n \"RUF005\",\n \"RUF006\",\n \"RUF007\",\n \"RUF008\",\n \"RUF009\",\n \"RUF010\",\n \"RUF012\",\n \"RUF013\",\n \"RUF015\",\n \"RUF016\",\n \"RUF017\",\n \"RUF018\",\n \"RUF019\",\n \"RUF020\",\n \"RUF021\",\n \"RUF022\",\n \"RUF023\",\n \"RUF024\",\n \"RUF026\",\n \"RUF027\",\n \"RUF028\",\n \"RUF029\",\n \"RUF100\",\n \"RUF101\",\n \"S101\",\n \"S102\",\n \"S103\",\n \"S104\",\n \"S105\",\n \"S106\",\n \"S107\",\n \"S108\",\n \"S110\",\n \"S112\",\n \"S113\",\n \"S201\",\n \"S202\",\n \"S301\",\n \"S302\",\n \"S303\",\n \"S304\",\n \"S305\",\n \"S306\",\n \"S307\",\n \"S308\",\n \"S310\",\n \"S311\",\n \"S312\",\n \"S313\",\n \"S314\",\n \"S315\",\n \"S316\",\n \"S317\",\n \"S318\",\n \"S319\",\n \"S321\",\n \"S323\",\n \"S324\",\n \"S401\",\n \"S402\",\n \"S403\",\n \"S405\",\n \"S406\",\n \"S407\",\n \"S408\",\n \"S409\",\n \"S411\",\n \"S412\",\n \"S413\",\n \"S415\",\n \"S501\",\n \"S502\",\n \"S503\",\n \"S504\",\n \"S505\",\n \"S506\",\n \"S507\",\n \"S508\",\n \"S509\",\n \"S601\",\n \"S602\",\n \"S604\",\n \"S605\",\n \"S606\",\n \"S607\",\n \"S608\",\n \"S609\",\n \"S610\",\n \"S611\",\n \"S612\",\n \"S701\",\n \"S702\",\n \"SIM101\",\n \"SIM102\",\n \"SIM103\",\n \"SIM105\",\n \"SIM107\",\n \"SIM108\",\n \"SIM109\",\n \"SIM110\",\n \"SIM112\",\n \"SIM113\",\n \"SIM114\",\n \"SIM115\",\n \"SIM116\",\n \"SIM117\",\n \"SIM118\",\n \"SIM201\",\n \"SIM202\",\n \"SIM208\",\n \"SIM210\",\n \"SIM211\",\n \"SIM212\",\n \"SIM220\",\n \"SIM221\",\n \"SIM222\",\n \"SIM223\",\n \"SIM300\",\n \"SIM910\",\n \"SIM911\",\n \"SLF001\",\n \"SLOT000\",\n \"SLOT001\",\n \"SLOT002\",\n \"T100\",\n \"T201\",\n \"T203\",\n \"TC001\",\n \"TC002\",\n \"TC003\",\n \"TC004\",\n \"TC005\",\n \"TC010\",\n \"TD004\",\n \"TD005\",\n \"TD006\",\n \"TD007\",\n \"TID251\",\n \"TID252\",\n \"TID253\",\n \"TRY002\",\n \"TRY003\",\n \"TRY004\",\n \"TRY201\",\n \"TRY203\",\n \"TRY300\",\n \"TRY301\",\n \"TRY400\",\n \"TRY401\",\n \"UP001\",\n \"UP003\",\n \"UP004\",\n \"UP005\",\n \"UP006\",\n \"UP007\",\n \"UP008\",\n \"UP009\",\n \"UP010\",\n \"UP011\",\n \"UP012\",\n \"UP013\",\n \"UP014\",\n \"UP015\",\n \"UP017\",\n \"UP018\",\n \"UP019\",\n \"UP020\",\n \"UP021\",\n \"UP022\",\n \"UP023\",\n \"UP024\",\n \"UP025\",\n \"UP026\",\n \"UP028\",\n \"UP029\",\n \"UP030\",\n \"UP031\",\n \"UP032\",\n \"UP033\",\n \"UP034\",\n \"UP035\",\n \"UP036\",\n \"UP037\",\n \"UP039\",\n \"UP040\",\n \"UP041\",\n \"UP042\",\n \"W291\",\n \"W292\",\n \"W293\",\n \"W391\",\n \"W505\",\n \"W605\",\n \"YTT101\",\n \"YTT102\",\n \"YTT103\",\n \"YTT201\",\n \"YTT202\",\n \"YTT203\",\n \"YTT204\",\n \"YTT301\",\n \"YTT302\",\n \"YTT303\",\n]\n\n[lint.per-file-ignores]\n\"**/scripts/*\" = [\n \"INP001\",\n \"T201\",\n]\n\"**/tests/**/*\" = [\n \"PLC1901\",\n \"PLR2004\",\n \"PLR6301\",\n \"S\",\n \"TID252\",\n]\n\n[lint.flake8-tidy-imports]\nban-relative-imports = \"all\"\n\n[lint.isort]\nknown-first-party = [\"coincurve\"]\n\n[lint.flake8-pytest-style]\nfixture-parentheses = false\nmark-parentheses = false\n" }, { "path": "scripts/README.md", "content": "# Scripts\n\n-----\n\nThis directory contains scripts that are used to develop the project.\n" }, { "path": "scripts/bench.py", "content": "# /// script\n# dependencies = [\n# \"coincurve\",\n# \"fastecdsa==3.0.1; sys_platform != 'win32'\",\n# \"rich\",\n# ]\n# [tool.uv.sources]\n# coincurve = { path = \"..\" }\n# ///\nimport os\nimport sys\nfrom abc import ABC, abstractmethod\nfrom decimal import Decimal\nfrom textwrap import dedent\nfrom time import perf_counter_ns\nfrom timeit import Timer\n\nfrom rich.live import Live\nfrom rich.table import Table\n\nMESSAGE = os.urandom(8192).hex()\n\n\nclass BenchmarkSpec:\n __slots__ = (\"setup\", \"statement\")\n\n def __init__(self, setup: str, statement: str):\n self.setup = dedent(setup[1:])\n self.statement = dedent(statement[1:])\n\n\nclass Benchmark(ABC):\n @staticmethod\n @abstractmethod\n def name() -> str:\n pass\n\n @staticmethod\n @abstractmethod\n def generate_key_pair() -> BenchmarkSpec:\n pass\n\n @staticmethod\n @abstractmethod\n def sign() -> BenchmarkSpec:\n pass\n\n @staticmethod\n @abstractmethod\n def verify() -> BenchmarkSpec:\n pass\n\n @staticmethod\n @abstractmethod\n def key_export() -> BenchmarkSpec:\n pass\n\n @staticmethod\n @abstractmethod\n def key_import() -> BenchmarkSpec:\n pass\n\n\nclass CoincurveBenchmark(Benchmark):\n @staticmethod\n def name() -> str:\n return \"coincurve\"\n\n @staticmethod\n def generate_key_pair() -> BenchmarkSpec:\n return BenchmarkSpec(\n \"\"\"\n from coincurve import PrivateKey\n \"\"\",\n \"\"\"\n PrivateKey()\n \"\"\",\n )\n\n @staticmethod\n def sign() -> BenchmarkSpec:\n return BenchmarkSpec(\n f\"\"\"\n from coincurve import PrivateKey\n message = {MESSAGE!r}.encode()\n private_key = PrivateKey()\n \"\"\",\n \"\"\"\n private_key.sign(message)\n \"\"\",\n )\n\n @staticmethod\n def verify() -> BenchmarkSpec:\n return BenchmarkSpec(\n f\"\"\"\n from coincurve import PrivateKey, verify_signature\n message = {MESSAGE!r}.encode()\n private_key = PrivateKey()\n signature = private_key.sign(message)\n public_key = private_key.public_key.format(compressed=False)\n \"\"\",\n \"\"\"\n assert verify_signature(signature, message, public_key)\n \"\"\",\n )\n\n @staticmethod\n def key_export() -> BenchmarkSpec:\n return BenchmarkSpec(\n \"\"\"\n from coincurve import PrivateKey\n private_key = PrivateKey()\n \"\"\",\n \"\"\"\n private_key.to_pem()\n \"\"\",\n )\n\n @staticmethod\n def key_import() -> BenchmarkSpec:\n return BenchmarkSpec(\n \"\"\"\n from coincurve import PrivateKey\n private_key = PrivateKey()\n private_key_pem = private_key.to_pem()\n \"\"\",\n \"\"\"\n PrivateKey.from_pem(private_key_pem)\n \"\"\",\n )\n\n\nclass FastecdsaBenchmark(Benchmark):\n @staticmethod\n def name() -> str:\n return \"fastecdsa\"\n\n @staticmethod\n def generate_key_pair() -> BenchmarkSpec:\n return BenchmarkSpec(\n \"\"\"\n from fastecdsa import curve, keys\n \"\"\",\n \"\"\"\n keys.gen_keypair(curve.secp256k1)\n \"\"\",\n )\n\n @staticmethod\n def sign() -> BenchmarkSpec:\n return BenchmarkSpec(\n f\"\"\"\n from fastecdsa import curve, ecdsa, keys\n message = {MESSAGE!r}\n private_key, _ = keys.gen_keypair(curve.secp256k1)\n \"\"\",\n \"\"\"\n r, s = ecdsa.sign(message, private_key, curve=curve.secp256k1)\n \"\"\",\n )\n\n @staticmethod\n def verify() -> BenchmarkSpec:\n return BenchmarkSpec(\n f\"\"\"\n from fastecdsa import curve, ecdsa, keys\n message = {MESSAGE!r}\n private_key, public_key = keys.gen_keypair(curve.secp256k1)\n r, s = ecdsa.sign(message, private_key, curve=curve.secp256k1)\n \"\"\",\n \"\"\"\n assert ecdsa.verify((r, s), message, public_key, curve=curve.secp256k1)\n \"\"\",\n )\n\n @staticmethod\n def key_export() -> BenchmarkSpec:\n return BenchmarkSpec(\n \"\"\"\n from fastecdsa import curve, keys\n from fastecdsa.encoding.pem import PEMEncoder\n private_key, _ = keys.gen_keypair(curve.secp256k1)\n encoder = PEMEncoder()\n \"\"\",\n \"\"\"\n encoder.encode_private_key(private_key, curve=curve.secp256k1)\n \"\"\",\n )\n\n @staticmethod\n def key_import() -> BenchmarkSpec:\n return BenchmarkSpec(\n \"\"\"\n from fastecdsa import curve, keys\n from fastecdsa.encoding.pem import PEMEncoder\n private_key, _ = keys.gen_keypair(curve.secp256k1)\n encoder = PEMEncoder()\n private_key_pem = encoder.encode_private_key(private_key, curve=curve.secp256k1)\n \"\"\",\n \"\"\"\n encoder.decode_private_key(private_key_pem)\n \"\"\",\n )\n\n\ndef generate_table(rows: list[list[str]]):\n table = Table()\n table.add_column(\"Library\")\n table.add_column(\"Key generation\")\n table.add_column(\"Signing\")\n table.add_column(\"Verification\")\n table.add_column(\"Key export\")\n table.add_column(\"Key import\")\n\n for row in rows:\n table.add_row(*row)\n\n return table\n\n\ndef main():\n print(sys.version)\n rows = []\n table = generate_table(rows)\n\n with Live(table, auto_refresh=False) as live:\n for benchmark in [CoincurveBenchmark, FastecdsaBenchmark]:\n row = [benchmark.name()]\n rows.append(row)\n live.update(generate_table(rows), refresh=True)\n\n for method in [\n benchmark.generate_key_pair,\n benchmark.sign,\n benchmark.verify,\n benchmark.key_export,\n benchmark.key_import,\n ]:\n spec = method()\n timer = Timer(stmt=spec.statement, setup=spec.setup, timer=perf_counter_ns)\n\n try:\n loops, _ = timer.autorange()\n times = timer.repeat(number=loops, repeat=1000)\n except Exception as e: # noqa: BLE001\n row.append(str(e))\n live.update(generate_table(rows), refresh=True)\n continue\n\n best = Decimal(min(times))\n # Convert nanoseconds to microseconds and round to 1 decimal place\n best /= 1_000\n best = best.quantize(Decimal(\"0.1\"))\n\n row.append(str(best))\n live.update(generate_table(rows), refresh=True)\n\n\nif __name__ == \"__main__\":\n main()\n" }, { "path": "src/coincurve/__init__.py", "content": "from coincurve.context import GLOBAL_CONTEXT, Context\nfrom coincurve.keys import PrivateKey, PublicKey, PublicKeyXOnly\nfrom coincurve.utils import verify_signature\n\n__version__ = \"21.0.0\"\n__all__ = [\n \"GLOBAL_CONTEXT\",\n \"Context\",\n \"PrivateKey\",\n \"PublicKey\",\n \"PublicKeyXOnly\",\n \"verify_signature\",\n]\n" }, { "path": "src/coincurve/context.py", "content": "from __future__ import annotations\n\nfrom os import urandom\nfrom threading import Lock\n\nfrom coincurve._libsecp256k1 import ffi, lib\nfrom coincurve.flags import CONTEXT_FLAGS, CONTEXT_NONE\n\n\nclass Context:\n def __init__(self, seed: bytes | None = None, flag=CONTEXT_NONE, name: str = \"\"):\n if flag not in CONTEXT_FLAGS:\n msg = f\"{flag} is an invalid context flag.\"\n raise ValueError(msg)\n self._lock = Lock()\n\n self.ctx = ffi.gc(lib.secp256k1_context_create(flag), lib.secp256k1_context_destroy)\n self.reseed(seed)\n\n self.name = name\n\n def reseed(self, seed: bytes | None = None):\n \"\"\"\n Protects against certain possible future side-channel timing attacks.\n \"\"\"\n with self._lock:\n seed = urandom(32) if not seed or len(seed) != 32 else seed # noqa: PLR2004\n res = lib.secp256k1_context_randomize(self.ctx, ffi.new(\"unsigned char [32]\", seed))\n if not res:\n msg = \"secp256k1_context_randomize\"\n raise ValueError(msg)\n\n def __repr__(self):\n return self.name or super().__repr__()\n\n\nGLOBAL_CONTEXT = Context(name=\"GLOBAL_CONTEXT\")\n" }, { "path": "src/coincurve/der.py", "content": "\"\"\"\nMinimal, dependency-free ASN.1/DER encoder & decoder for secp256k1 EC private keys.\n\nThis module implements just enough DER encoding/decoding to support:\n\n 1. Outputting a DER-encoded PKCS#8 EC private key (with an embedded ECPrivateKey per RFC 5915)\n 2. Reading such a DER-encoded EC private key\n\nOnly the following ASN.1 types are supported:\n\n - INTEGER\n - BIT STRING\n - OCTET STRING\n - OBJECT IDENTIFIER\n - SEQUENCE\n - Context-specific EXPLICIT tags (for the optional public key)\n\nThe expected DER structure is as follows:\n\n PrivateKeyInfo ::= SEQUENCE {\n version INTEGER, -- must be 0\n privateKeyAlgorithm SEQUENCE {\n algorithm OBJECT IDENTIFIER, -- id-ecPublicKey (1.2.840.10045.2.1)\n parameters OBJECT IDENTIFIER -- secp256k1 (1.3.132.0.10)\n },\n privateKey OCTET STRING -- DER encoding of ECPrivateKey\n }\n\n ECPrivateKey ::= SEQUENCE {\n version INTEGER, -- must be 1\n privateKey OCTET STRING, -- the secret bytes\n publicKey [1] EXPLICIT BIT STRING OPTIONAL -- uncompressed public key\n }\n\"\"\"\n\nfrom __future__ import annotations\n\nfrom coincurve.utils import int_to_bytes\n\n# ASN.1 DER tag bytes\nINTEGER_TAG = 0x02\nBIT_STRING_TAG = 0x03\nOCTET_STRING_TAG = 0x04\nOBJECT_IDENTIFIER_TAG = 0x06\nSEQUENCE_TAG = 0x30\n\n# OIDs\nEC_PUBKEY_OID = bytes([0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01]) # 1.2.840.10045.2.1 (ecPublicKey)\nSECP256K1_OID = bytes([0x2B, 0x81, 0x04, 0x00, 0x0A]) # 1.3.132.0.10 (secp256k1)\n\n# Pre-computed structures\nVERSION_INTEGER_ZERO = bytes([INTEGER_TAG, 0x01, 0x00]) # INTEGER 0\nVERSION_INTEGER_ONE = bytes([INTEGER_TAG, 0x01, 0x01]) # INTEGER 1\nEC_ALGORITHM_IDENTIFIER = bytes([\n SEQUENCE_TAG,\n 16,\n OBJECT_IDENTIFIER_TAG,\n len(EC_PUBKEY_OID),\n *EC_PUBKEY_OID,\n OBJECT_IDENTIFIER_TAG,\n len(SECP256K1_OID),\n *SECP256K1_OID,\n])\n\n\ndef encode_length(length: int) -> bytes:\n \"\"\"Encode a length in DER format.\"\"\"\n # Short form\n if length < 128: # noqa: PLR2004\n return bytes([length])\n\n # Long form\n length_bytes = int_to_bytes(length)\n return bytes([0x80 | len(length_bytes)]) + length_bytes\n\n\ndef encode_octet_string(value: bytes) -> bytes:\n \"\"\"Encode an OCTET STRING in DER format.\"\"\"\n length_bytes = encode_length(len(value))\n length_bytes_len = len(length_bytes)\n result = bytearray(1 + length_bytes_len + len(value))\n result[0] = OCTET_STRING_TAG\n result[1 : 1 + length_bytes_len] = length_bytes\n result[1 + length_bytes_len :] = value\n return bytes(result)\n\n\ndef encode_bit_string(value: bytes, unused_bits: int = 0) -> bytes:\n \"\"\"Encode a BIT STRING in DER format.\"\"\"\n length_bytes = encode_length(len(value) + 1)\n length_bytes_len = len(length_bytes)\n result = bytearray(1 + length_bytes_len + 1 + len(value))\n result[0] = BIT_STRING_TAG\n result[1 : 1 + length_bytes_len] = length_bytes\n result[1 + length_bytes_len] = unused_bits\n result[1 + length_bytes_len + 1 :] = value\n return bytes(result)\n\n\ndef encode_der(private_key: bytes, public_key: bytes | None = None) -> bytes:\n \"\"\"\n Encode an EC private key in DER format (PKCS#8/RFC 5208).\n Optimized for secp256k1 keys.\n\n Parameters:\n private_key: The private key as bytes (32 bytes for secp256k1)\n public_key: The public key as bytes (65 bytes uncompressed for secp256k1, starting with 0x04)\n\n Returns:\n The DER-encoded private key\n \"\"\"\n # EC private key contains version(1) + octet string + optional pubkey\n ec_key_buffer = bytearray(VERSION_INTEGER_ONE)\n\n # Add private key as octet string\n private_key_os = encode_octet_string(private_key)\n ec_key_buffer.extend(private_key_os)\n\n # Add public key if provided (optional)\n if public_key is not None:\n public_key_bs = encode_bit_string(public_key)\n pubkey_len = len(public_key_bs)\n ec_key_buffer.append(0xA1) # context-specific [1] constructed\n ec_key_buffer.extend(encode_length(pubkey_len))\n ec_key_buffer.extend(public_key_bs)\n\n # Wrap EC private key in sequence\n ec_key_seq = bytearray([SEQUENCE_TAG])\n ec_key_seq.extend(encode_length(len(ec_key_buffer)))\n ec_key_seq.extend(ec_key_buffer)\n\n # Wrap in octet string for outer structure\n ec_key_os = encode_octet_string(ec_key_seq)\n\n # Build the outer PKCS#8 structure\n result = bytearray([SEQUENCE_TAG])\n\n # Calculate total length: version(3) + alg_id(18) + octet_string(len)\n outer_len = 3 + len(EC_ALGORITHM_IDENTIFIER) + len(ec_key_os)\n result.extend(encode_length(outer_len))\n\n # Version 0\n result.extend(VERSION_INTEGER_ZERO)\n\n # Algorithm identifier (pre-computed)\n result.extend(EC_ALGORITHM_IDENTIFIER)\n\n # EC key wrapped in octet string\n result.extend(ec_key_os)\n\n return bytes(result)\n\n\ndef decode_length(data: bytes, offset: int) -> tuple[int, int]:\n \"\"\"\n Decode a DER length field.\n\n Parameters:\n data: The DER-encoded data\n offset: The current offset in the data\n\n Returns:\n Tuple of (length, new_offset)\n \"\"\"\n length_byte = data[offset]\n offset += 1\n\n # Short form\n if length_byte < 128: # noqa: PLR2004\n return length_byte, offset\n\n # Long form\n num_length_bytes = length_byte & 0x7F\n length = 0\n for _ in range(num_length_bytes):\n length = (length << 8) | data[offset]\n offset += 1\n return length, offset\n\n\ndef decode_der(der_data: bytes) -> bytes:\n \"\"\"\n Decode a DER-encoded EC private key to extract the private key secret.\n Optimized for secp256k1 keys.\n\n Parameters:\n der_data: The DER-encoded private key in PKCS#8 format\n\n Returns:\n The private key secret as bytes\n \"\"\"\n # Quick validation for performance\n if len(der_data) < 34 or der_data[0] != SEQUENCE_TAG: # noqa: PLR2004\n msg = \"Invalid DER: not a valid PKCS#8 structure\"\n raise ValueError(msg)\n\n # Skip outer sequence tag and length\n offset = 1\n _, offset = decode_length(der_data, offset)\n\n # Skip version INTEGER (should be 0)\n if der_data[offset] != INTEGER_TAG:\n msg = \"Invalid DER: expected INTEGER tag for version\"\n raise ValueError(msg)\n offset += 1\n version_len, offset = decode_length(der_data, offset)\n offset += version_len # Skip version value\n\n # Validate algorithm identifier is for EC\n if der_data[offset] != SEQUENCE_TAG:\n msg = \"Invalid DER: expected SEQUENCE tag for algorithm\"\n raise ValueError(msg)\n offset += 1\n\n alg_len, offset = decode_length(der_data, offset)\n alg_end = offset + alg_len # Store the end position of algorithm identifier\n\n # Check if first OID is EC\n if der_data[offset] != OBJECT_IDENTIFIER_TAG:\n msg = \"Invalid DER: expected OBJECT IDENTIFIER tag\"\n raise ValueError(msg)\n offset += 1\n oid_len, offset = decode_length(der_data, offset)\n algorithm_oid = der_data[offset : offset + oid_len]\n\n # Check if it's an EC key\n if oid_len != len(EC_PUBKEY_OID) or algorithm_oid != EC_PUBKEY_OID:\n msg = \"Not an EC private key\"\n raise ValueError(msg)\n\n # Skip to the end of algorithm identifier section\n offset = alg_end\n\n # Extract private key octet string\n if der_data[offset] != OCTET_STRING_TAG:\n msg = \"Invalid DER: expected OCTET STRING for private key\"\n raise ValueError(msg)\n offset += 1\n priv_len, offset = decode_length(der_data, offset)\n\n # Parse EC private key structure\n ec_data = der_data[offset : offset + priv_len]\n\n # Verify EC structure starts with sequence\n if len(ec_data) < 2 or ec_data[0] != SEQUENCE_TAG: # noqa: PLR2004\n msg = \"Invalid EC key format: missing sequence\"\n raise ValueError(msg)\n\n # Skip sequence tag and length\n ec_offset = 1\n _, ec_offset = decode_length(ec_data, ec_offset)\n\n # Skip version INTEGER (should be 1)\n if ec_data[ec_offset] != INTEGER_TAG:\n msg = \"Invalid EC key format: missing version\"\n raise ValueError(msg)\n ec_offset += 1\n ec_ver_len, ec_offset = decode_length(ec_data, ec_offset)\n ec_offset += ec_ver_len # Skip version value\n\n # Get private key octet string\n if ec_data[ec_offset] != OCTET_STRING_TAG:\n msg = \"Invalid DER: expected OCTET STRING for EC private key\"\n raise ValueError(msg)\n ec_offset += 1\n\n key_len, ec_offset = decode_length(ec_data, ec_offset)\n\n # Extract private key\n return ec_data[ec_offset : ec_offset + key_len]\n" }, { "path": "src/coincurve/ecdsa.py", "content": "from __future__ import annotations\n\nfrom typing import TYPE_CHECKING\n\nfrom coincurve._libsecp256k1 import ffi, lib\nfrom coincurve.context import GLOBAL_CONTEXT, Context\nfrom coincurve.utils import bytes_to_int, int_to_bytes, sha256\n\nif TYPE_CHECKING:\n from coincurve.types import Hasher\n\nMAX_SIG_LENGTH = 72\nCDATA_SIG_LENGTH = 64\n\n\ndef cdata_to_der(cdata, context: Context = GLOBAL_CONTEXT) -> bytes:\n der = ffi.new(\"unsigned char[72]\")\n der_length = ffi.new(\"size_t *\", MAX_SIG_LENGTH)\n\n lib.secp256k1_ecdsa_signature_serialize_der(context.ctx, der, der_length, cdata)\n\n return bytes(ffi.buffer(der, der_length[0]))\n\n\ndef der_to_cdata(der: bytes, context: Context = GLOBAL_CONTEXT):\n cdata = ffi.new(\"secp256k1_ecdsa_signature *\")\n parsed = lib.secp256k1_ecdsa_signature_parse_der(context.ctx, cdata, der, len(der))\n\n if not parsed:\n msg = \"The DER-encoded signature could not be parsed.\"\n raise ValueError(msg)\n\n return cdata\n\n\ndef recover(message: bytes, recover_sig, hasher: Hasher = sha256, context: Context = GLOBAL_CONTEXT):\n msg_hash = hasher(message) if hasher is not None else message\n if len(msg_hash) != 32: # noqa: PLR2004\n msg = \"Message hash must be 32 bytes long.\"\n raise ValueError(msg)\n pubkey = ffi.new(\"secp256k1_pubkey *\")\n\n recovered = lib.secp256k1_ecdsa_recover(context.ctx, pubkey, recover_sig, msg_hash)\n if recovered:\n return pubkey\n msg = \"failed to recover ECDSA public key\"\n raise ValueError(msg)\n\n\ndef serialize_recoverable(recover_sig, context: Context = GLOBAL_CONTEXT) -> bytes:\n output = ffi.new(\"unsigned char[64]\")\n recid = ffi.new(\"int *\")\n\n lib.secp256k1_ecdsa_recoverable_signature_serialize_compact(context.ctx, output, recid, recover_sig)\n\n return bytes(ffi.buffer(output, CDATA_SIG_LENGTH)) + int_to_bytes(recid[0])\n\n\ndef deserialize_recoverable(serialized: bytes, context: Context = GLOBAL_CONTEXT):\n if len(serialized) != 65: # noqa: PLR2004\n msg = \"Serialized signature must be 65 bytes long.\"\n raise ValueError(msg)\n\n ser_sig, rec_id = serialized[:64], bytes_to_int(serialized[64:])\n\n if not 0 <= rec_id <= 3: # noqa: PLR2004\n msg = \"Invalid recovery id.\"\n raise ValueError(msg)\n\n recover_sig = ffi.new(\"secp256k1_ecdsa_recoverable_signature *\")\n\n parsed = lib.secp256k1_ecdsa_recoverable_signature_parse_compact(context.ctx, recover_sig, ser_sig, rec_id)\n if not parsed:\n msg = \"Failed to parse recoverable signature.\"\n raise ValueError(msg)\n\n return recover_sig\n\n\n\"\"\"\nWarning:\n The functions below may change and are not tested!\n\"\"\"\n\n\ndef serialize_compact(raw_sig, context: Context = GLOBAL_CONTEXT): # no cov\n output = ffi.new(\"unsigned char[64]\")\n\n res = lib.secp256k1_ecdsa_signature_serialize_compact(context.ctx, output, raw_sig)\n if not res:\n msg = \"secp256k1_ecdsa_signature_serialize_compact\"\n raise ValueError(msg)\n\n return bytes(ffi.buffer(output, CDATA_SIG_LENGTH))\n\n\ndef deserialize_compact(ser_sig: bytes, context: Context = GLOBAL_CONTEXT): # no cov\n if len(ser_sig) != 64: # noqa: PLR2004\n msg = \"invalid signature length\"\n raise ValueError(msg)\n\n raw_sig = ffi.new(\"secp256k1_ecdsa_signature *\")\n res = lib.secp256k1_ecdsa_signature_parse_compact(context.ctx, raw_sig, ser_sig)\n if not res:\n msg = \"secp256k1_ecdsa_signature_parse_compact\"\n raise ValueError(msg)\n\n return raw_sig\n\n\ndef signature_normalize(raw_sig, context: Context = GLOBAL_CONTEXT): # no cov\n \"\"\"\n Check and optionally convert a signature to a normalized lower-S form.\n\n This function always return a tuple containing a boolean (True if\n not previously normalized or False if signature was already\n normalized), and the normalized signature.\n \"\"\"\n sigout = ffi.new(\"secp256k1_ecdsa_signature *\")\n\n res = lib.secp256k1_ecdsa_signature_normalize(context.ctx, sigout, raw_sig)\n\n return not not res, sigout # noqa: SIM208\n\n\ndef recoverable_convert(recover_sig, context: Context = GLOBAL_CONTEXT): # no cov\n normal_sig = ffi.new(\"secp256k1_ecdsa_signature *\")\n\n lib.secp256k1_ecdsa_recoverable_signature_convert(context.ctx, normal_sig, recover_sig)\n\n return normal_sig\n" }, { "path": "src/coincurve/flags.py", "content": "from __future__ import annotations\n\nfrom coincurve._libsecp256k1 import lib\n\nCONTEXT_NONE = lib.SECP256K1_CONTEXT_NONE\nCONTEXT_FLAGS = {\n CONTEXT_NONE,\n}\n\nEC_COMPRESSED = lib.SECP256K1_EC_COMPRESSED\nEC_UNCOMPRESSED = lib.SECP256K1_EC_UNCOMPRESSED\n\n# Additional flags available from libsecp256k1\n# lib.SECP256K1_TAG_PUBKEY_EVEN\n# lib.SECP256K1_TAG_PUBKEY_ODD\n# lib.SECP256K1_TAG_PUBKEY_UNCOMPRESSED\n# lib.SECP256K1_TAG_PUBKEY_HYBRID_EVEN\n# lib.SECP256K1_TAG_PUBKEY_HYBRID_ODD\n" }, { "path": "src/coincurve/keys.py", "content": "from __future__ import annotations\n\nimport os\nfrom typing import TYPE_CHECKING\n\nfrom coincurve._libsecp256k1 import ffi, lib\nfrom coincurve.context import GLOBAL_CONTEXT, Context\nfrom coincurve.der import decode_der, encode_der\nfrom coincurve.ecdsa import cdata_to_der, der_to_cdata, deserialize_recoverable, recover, serialize_recoverable\nfrom coincurve.flags import EC_COMPRESSED, EC_UNCOMPRESSED\nfrom coincurve.utils import (\n DEFAULT_NONCE,\n bytes_to_int,\n der_to_pem,\n get_valid_secret,\n hex_to_bytes,\n int_to_bytes_padded,\n pad_scalar,\n pem_to_der,\n sha256,\n validate_secret,\n)\n\nif TYPE_CHECKING:\n from coincurve.types import Hasher, Nonce\n\n\nclass PrivateKey:\n def __init__(self, secret: bytes | None = None, context: Context = GLOBAL_CONTEXT):\n \"\"\"\n Initializes a private key.\n\n Parameters:\n secret: The secret used to initialize the private key.\n If not provided, a new key will be generated.\n context: The context to use.\n \"\"\"\n self.secret: bytes = validate_secret(secret) if secret is not None else get_valid_secret()\n self.context = context\n self.public_key: PublicKey = PublicKey.from_valid_secret(self.secret, self.context)\n self.public_key_xonly: PublicKeyXOnly = PublicKeyXOnly.from_valid_secret(self.secret, self.context)\n\n def sign(self, message: bytes, hasher: Hasher = sha256, custom_nonce: Nonce = DEFAULT_NONCE) -> bytes:\n \"\"\"\n Creates an ECDSA signature.\n\n Parameters:\n message: The message to sign.\n hasher (collections.abc.Callable[[bytes], bytes] | None): The hash function to use, which must\n return 32 bytes. By default, the `sha256` algorithm is used. If `None`, no hashing occurs.\n custom_nonce (tuple[ffi.CData, ffi.CData]): Custom nonce data in the form `(nonce_function, input_data)`.\n For more information, refer to the `libsecp256k1` documentation\n [here](https://github.com/bitcoin-core/secp256k1/blob/v0.6.0/include/secp256k1.h#L637-L642).\n\n Returns:\n The ECDSA signature.\n\n Raises:\n ValueError: If the message hash was not 32 bytes long, the nonce generation\n function failed, or the private key was invalid.\n \"\"\"\n msg_hash = hasher(message) if hasher is not None else message\n if len(msg_hash) != 32: # noqa: PLR2004\n msg = \"Message hash must be 32 bytes long.\"\n raise ValueError(msg)\n\n signature = ffi.new(\"secp256k1_ecdsa_signature *\")\n nonce_fn, nonce_data = custom_nonce\n\n signed = lib.secp256k1_ecdsa_sign(self.context.ctx, signature, msg_hash, self.secret, nonce_fn, nonce_data)\n\n if not signed:\n msg = \"The nonce generation function failed, or the private key was invalid.\"\n raise ValueError(msg)\n\n return cdata_to_der(signature, self.context)\n\n def sign_schnorr(self, message: bytes, aux_randomness: bytes = b\"\") -> bytes:\n \"\"\"\n Creates a Schnorr signature.\n\n Parameters:\n message: The message to sign.\n aux_randomness: 32 bytes of fresh randomness, empty bytestring (auto-generated),\n or None (no randomness).\n\n Returns:\n The Schnorr signature.\n\n Raises:\n ValueError: If the message was not 32 bytes long, the optional auxiliary\n random data was not 32 bytes long, signing failed, or the signature was invalid.\n \"\"\"\n if len(message) != 32: # noqa: PLR2004\n msg = \"Message must be 32 bytes long.\"\n raise ValueError(msg)\n if aux_randomness == b\"\":\n aux_randomness = os.urandom(32)\n elif aux_randomness is None:\n aux_randomness = ffi.NULL\n elif len(aux_randomness) != 32: # noqa: PLR2004\n msg = \"Auxiliary random data must be 32 bytes long.\"\n raise ValueError(msg)\n\n keypair = ffi.new(\"secp256k1_keypair *\")\n res = lib.secp256k1_keypair_create(self.context.ctx, keypair, self.secret)\n if not res:\n msg = \"Secret was invalid\"\n raise ValueError(msg)\n\n signature = ffi.new(\"unsigned char[64]\")\n res = lib.secp256k1_schnorrsig_sign32(self.context.ctx, signature, message, keypair, aux_randomness)\n if not res:\n msg = \"Signing failed\"\n raise ValueError(msg)\n\n res = lib.secp256k1_schnorrsig_verify(\n self.context.ctx, signature, message, len(message), self.public_key_xonly.public_key\n )\n if not res:\n msg = \"Invalid signature\"\n raise ValueError(msg)\n\n return bytes(ffi.buffer(signature))\n\n def sign_recoverable(self, message: bytes, hasher: Hasher = sha256, custom_nonce: Nonce = DEFAULT_NONCE) -> bytes:\n \"\"\"\n Creates a recoverable ECDSA signature.\n\n Parameters:\n message: The message to sign.\n hasher (collections.abc.Callable[[bytes], bytes] | None): The hash function to use, which must\n return 32 bytes. By default, the `sha256` algorithm is used. If `None`, no hashing occurs.\n custom_nonce (tuple[ffi.CData, ffi.CData]): Custom nonce data in the form `(nonce_function, input_data)`.\n For more information, refer to the `libsecp256k1` documentation\n [here](https://github.com/bitcoin-core/secp256k1/blob/v0.6.0/include/secp256k1.h#L637-L642).\n\n Returns:\n The recoverable ECDSA signature.\n\n Raises:\n ValueError: If the message hash was not 32 bytes long, the nonce generation\n function failed, or the private key was invalid.\n \"\"\"\n msg_hash = hasher(message) if hasher is not None else message\n if len(msg_hash) != 32: # noqa: PLR2004\n msg = \"Message hash must be 32 bytes long.\"\n raise ValueError(msg)\n\n signature = ffi.new(\"secp256k1_ecdsa_recoverable_signature *\")\n nonce_fn, nonce_data = custom_nonce\n\n signed = lib.secp256k1_ecdsa_sign_recoverable(\n self.context.ctx, signature, msg_hash, self.secret, nonce_fn, nonce_data\n )\n\n if not signed:\n msg = \"The nonce generation function failed, or the private key was invalid.\"\n raise ValueError(msg)\n\n return serialize_recoverable(signature, self.context)\n\n def ecdh(self, public_key: bytes) -> bytes:\n \"\"\"\n Computes an EC Diffie-Hellman secret in constant time.\n\n !!! note\n This prevents malleability by returning `sha256(compressed_public_key)` instead of the `x` coordinate\n directly.\n\n Parameters:\n public_key: The formatted public key.\n\n Returns:\n The 32-byte shared secret.\n\n Raises:\n ValueError: If the public key could not be parsed or was invalid.\n \"\"\"\n secret = ffi.new(\"unsigned char [32]\")\n\n lib.secp256k1_ecdh(self.context.ctx, secret, PublicKey(public_key).public_key, self.secret, ffi.NULL, ffi.NULL)\n\n return bytes(ffi.buffer(secret, 32))\n\n def add(self, scalar: bytes, update: bool = False) -> PrivateKey: # noqa: FBT001, FBT002\n \"\"\"\n Adds a scalar to the private key.\n\n Parameters:\n scalar: The scalar with which to add.\n update: Whether to update the private key in-place.\n\n Returns:\n The new private key, or the modified private key if `update` is `True`.\n\n Raises:\n ValueError: If the tweak was out of range or the resulting private key was invalid.\n \"\"\"\n scalar = pad_scalar(scalar)\n\n secret = ffi.new(\"unsigned char [32]\", self.secret)\n\n success = lib.secp256k1_ec_seckey_tweak_add(self.context.ctx, secret, scalar)\n\n if not success:\n msg = \"The tweak was out of range, or the resulting private key is invalid.\"\n raise ValueError(msg)\n\n secret = bytes(ffi.buffer(secret, 32))\n\n if update:\n self.secret = secret\n self._update_public_key()\n return self\n\n return PrivateKey(secret, self.context)\n\n def multiply(self, scalar: bytes, update: bool = False) -> PrivateKey: # noqa: FBT001, FBT002\n \"\"\"\n Multiplies the private key by a scalar.\n\n Parameters:\n scalar: The scalar with which to multiply.\n update: Whether to update the private key in-place.\n\n Returns:\n The new private key, or the modified private key if `update` is `True`.\n \"\"\"\n scalar = validate_secret(scalar)\n\n secret = ffi.new(\"unsigned char [32]\", self.secret)\n\n lib.secp256k1_ec_seckey_tweak_mul(self.context.ctx, secret, scalar)\n\n secret = bytes(ffi.buffer(secret, 32))\n\n if update:\n self.secret = secret\n self._update_public_key()\n return self\n\n return PrivateKey(secret, self.context)\n\n def to_hex(self) -> str:\n \"\"\"\n Returns the private key encoded as a hex string.\n \"\"\"\n return self.secret.hex()\n\n def to_int(self) -> int:\n \"\"\"\n Returns the private key as an integer.\n \"\"\"\n return bytes_to_int(self.secret)\n\n def to_pem(self) -> bytes:\n \"\"\"\n Returns the private key encoded in PEM format.\n \"\"\"\n return der_to_pem(self.to_der())\n\n def to_der(self) -> bytes:\n \"\"\"\n Returns the private key encoded in DER format.\n \"\"\"\n return encode_der(self.secret, self.public_key.format(compressed=False))\n\n @classmethod\n def from_hex(cls, hexed: str, context: Context = GLOBAL_CONTEXT) -> PrivateKey:\n \"\"\"\n Creates a private key from a hex string.\n\n Parameters:\n hexed: The private key encoded as a hex string.\n context: The context to use.\n\n Returns:\n The private key.\n \"\"\"\n return PrivateKey(hex_to_bytes(hexed), context)\n\n @classmethod\n def from_int(cls, num: int, context: Context = GLOBAL_CONTEXT) -> PrivateKey:\n \"\"\"\n Creates a private key from an integer.\n\n Parameters:\n num: The private key as an integer.\n context: The context to use.\n\n Returns:\n The private key.\n \"\"\"\n return PrivateKey(int_to_bytes_padded(num), context)\n\n @classmethod\n def from_pem(cls, pem: bytes, context: Context = GLOBAL_CONTEXT) -> PrivateKey:\n \"\"\"\n Creates a private key from PEM format.\n\n Parameters:\n pem: The private key encoded in PEM format.\n context: The context to use.\n\n Returns:\n The private key.\n \"\"\"\n return PrivateKey(decode_der(pem_to_der(pem)), context)\n\n @classmethod\n def from_der(cls, der: bytes, context: Context = GLOBAL_CONTEXT) -> PrivateKey:\n \"\"\"\n Creates a private key from DER format.\n\n Parameters:\n der: The private key encoded in DER format.\n context: The context to use.\n\n Returns:\n The private key.\n \"\"\"\n return PrivateKey(decode_der(der), context)\n\n def _update_public_key(self):\n created = lib.secp256k1_ec_pubkey_create(self.context.ctx, self.public_key.public_key, self.secret)\n\n if not created:\n msg = \"Invalid secret.\"\n raise ValueError(msg)\n\n def __eq__(self, other) -> bool:\n return self.secret == other.secret\n\n def __hash__(self) -> int:\n return hash(self.secret)\n\n\nclass PublicKey:\n def __init__(self, data: bytes | ffi.CData, context: Context = GLOBAL_CONTEXT):\n \"\"\"\n Initializes a public key.\n\n Parameters:\n data (bytes): The formatted public key. This class supports parsing\n compressed (33 bytes, header byte `0x02` or `0x03`),\n uncompressed (65 bytes, header byte `0x04`), or\n hybrid (65 bytes, header byte `0x06` or `0x07`) format public keys.\n context: The context to use.\n\n Raises:\n ValueError: If the public key could not be parsed or was invalid.\n \"\"\"\n if not isinstance(data, bytes):\n self.public_key = data\n else:\n public_key = ffi.new(\"secp256k1_pubkey *\")\n\n parsed = lib.secp256k1_ec_pubkey_parse(context.ctx, public_key, data, len(data))\n\n if not parsed:\n msg = \"The public key could not be parsed or is invalid.\"\n raise ValueError(msg)\n\n self.public_key = public_key\n\n self.context = context\n\n @classmethod\n def from_secret(cls, secret: bytes, context: Context = GLOBAL_CONTEXT) -> PublicKey:\n \"\"\"\n Derives a public key from a private key secret.\n\n Parameters:\n secret: The private key secret.\n context: The context to use.\n\n Returns:\n The public key.\n\n Raises:\n ValueError: If an invalid secret was used.\n \"\"\"\n public_key = ffi.new(\"secp256k1_pubkey *\")\n\n created = lib.secp256k1_ec_pubkey_create(context.ctx, public_key, validate_secret(secret))\n\n if not created: # no cov\n msg = (\n \"Somehow an invalid secret was used. Please \"\n \"submit this as an issue here: \"\n \"https://github.com/ofek/coincurve/issues/new\"\n )\n raise ValueError(msg)\n\n return PublicKey(public_key, context)\n\n @classmethod\n def from_valid_secret(cls, secret: bytes, context: Context = GLOBAL_CONTEXT) -> PublicKey:\n \"\"\"\n Derives a public key from a valid private key secret, avoiding input checks.\n\n Parameters:\n secret: The private key secret.\n context: The context to use.\n\n Returns:\n The public key.\n\n Raises:\n ValueError: If the secret was invalid.\n \"\"\"\n public_key = ffi.new(\"secp256k1_pubkey *\")\n\n created = lib.secp256k1_ec_pubkey_create(context.ctx, public_key, secret)\n\n if not created:\n msg = \"Invalid secret.\"\n raise ValueError(msg)\n\n return PublicKey(public_key, context)\n\n @classmethod\n def from_point(cls, x: int, y: int, context: Context = GLOBAL_CONTEXT) -> PublicKey:\n \"\"\"\n Derives a public key from a coordinate point.\n\n Parameters:\n x: The x coordinate.\n y: The y coordinate.\n context: The context to use.\n\n Returns:\n The public key.\n \"\"\"\n return PublicKey(b\"\\x04\" + int_to_bytes_padded(x) + int_to_bytes_padded(y), context)\n\n @classmethod\n def from_signature_and_message(\n cls, signature: bytes, message: bytes, hasher: Hasher = sha256, context: Context = GLOBAL_CONTEXT\n ) -> PublicKey:\n \"\"\"\n Recovers an ECDSA public key from a recoverable signature.\n\n Parameters:\n signature: The recoverable ECDSA signature.\n message: The message that was supposedly signed.\n hasher (collections.abc.Callable[[bytes], bytes] | None): The hash function to use, which must\n return 32 bytes. By default, the `sha256` algorithm is used. If `None`, no hashing occurs.\n context: The context to use.\n\n Returns:\n The public key that signed the message.\n\n Raises:\n ValueError: If the message hash was not 32 bytes long or recovery of the\n ECDSA public key failed.\n \"\"\"\n return PublicKey(\n recover(message, deserialize_recoverable(signature, context=context), hasher=hasher, context=context)\n )\n\n @classmethod\n def combine_keys(cls, public_keys: list[PublicKey], context: Context = GLOBAL_CONTEXT) -> PublicKey:\n \"\"\"\n Adds a number of public keys together.\n\n Parameters:\n public_keys: A sequence of public keys.\n context: The context to use.\n\n Returns:\n The combined public key.\n\n Raises:\n ValueError: If the sum of the public keys was invalid.\n \"\"\"\n public_key = ffi.new(\"secp256k1_pubkey *\")\n\n combined = lib.secp256k1_ec_pubkey_combine(\n context.ctx, public_key, [pk.public_key for pk in public_keys], len(public_keys)\n )\n\n if not combined:\n msg = \"The sum of the public keys is invalid.\"\n raise ValueError(msg)\n\n return PublicKey(public_key, context)\n\n def format(self, compressed: bool = True) -> bytes: # noqa: FBT001, FBT002\n \"\"\"\n Formats the public key.\n\n Parameters:\n compressed: Whether to use the compressed format.\n\n Returns:\n The 33 byte formatted public key, or the 65 byte formatted public key\n if `compressed` is `False`.\n \"\"\"\n length = 33 if compressed else 65\n serialized = ffi.new(\"unsigned char [%d]\" % length) # noqa: UP031\n output_len = ffi.new(\"size_t *\", length)\n\n lib.secp256k1_ec_pubkey_serialize(\n self.context.ctx, serialized, output_len, self.public_key, EC_COMPRESSED if compressed else EC_UNCOMPRESSED\n )\n\n return bytes(ffi.buffer(serialized, length))\n\n def point(self) -> tuple[int, int]:\n \"\"\"\n Returns the public key as a coordinate point.\n \"\"\"\n public_key = self.format(compressed=False)\n return bytes_to_int(public_key[1:33]), bytes_to_int(public_key[33:])\n\n def verify(self, signature: bytes, message: bytes, hasher: Hasher = sha256) -> bool:\n \"\"\"\n Verifies an ECDSA signature.\n\n Parameters:\n signature: The ECDSA signature.\n message: The message that was supposedly signed.\n hasher (collections.abc.Callable[[bytes], bytes] | None): The hash function to use, which must\n return 32 bytes. By default, the `sha256` algorithm is used. If `None`, no hashing occurs.\n\n Returns:\n A boolean indicating whether the signature is correct.\n\n Raises:\n ValueError: If the message hash was not 32 bytes long or the\n DER-encoded signature could not be parsed.\n \"\"\"\n msg_hash = hasher(message) if hasher is not None else message\n if len(msg_hash) != 32: # noqa: PLR2004\n msg = \"Message hash must be 32 bytes long.\"\n raise ValueError(msg)\n\n verified = lib.secp256k1_ecdsa_verify(self.context.ctx, der_to_cdata(signature), msg_hash, self.public_key)\n\n # A performance hack to avoid global bool() lookup.\n return not not verified # noqa: SIM208\n\n def add(self, scalar: bytes, update: bool = False) -> PublicKey: # noqa: FBT001, FBT002\n \"\"\"\n Adds a scalar to the public key.\n\n Parameters:\n scalar: The scalar with which to add.\n update: Whether to update the public key in-place.\n\n Returns:\n The new public key, or the modified public key if `update` is `True`.\n\n Raises:\n ValueError: If the tweak was out of range or the resulting public key was invalid.\n \"\"\"\n scalar = pad_scalar(scalar)\n\n new_key = ffi.new(\"secp256k1_pubkey *\", self.public_key[0])\n\n success = lib.secp256k1_ec_pubkey_tweak_add(self.context.ctx, new_key, scalar)\n\n if not success:\n msg = \"The tweak was out of range, or the resulting public key is invalid.\"\n raise ValueError(msg)\n\n if update:\n self.public_key = new_key\n return self\n\n return PublicKey(new_key, self.context)\n\n def multiply(self, scalar: bytes, update: bool = False) -> PublicKey: # noqa: FBT001, FBT002\n \"\"\"\n Multiplies the public key by a scalar.\n\n Parameters:\n scalar: The scalar with which to multiply.\n update: Whether to update the public key in-place.\n\n Returns:\n The new public key, or the modified public key if `update` is `True`.\n \"\"\"\n scalar = validate_secret(scalar)\n\n new_key = ffi.new(\"secp256k1_pubkey *\", self.public_key[0])\n\n lib.secp256k1_ec_pubkey_tweak_mul(self.context.ctx, new_key, scalar)\n\n if update:\n self.public_key = new_key\n return self\n\n return PublicKey(new_key, self.context)\n\n def combine(self, public_keys: list[PublicKey], update: bool = False) -> PublicKey: # noqa: FBT001, FBT002\n \"\"\"\n Adds a number of public keys together.\n\n Parameters:\n public_keys: A sequence of public keys.\n update: Whether to update the public key in-place.\n\n Returns:\n The combined public key, or the modified public key if `update` is `True`.\n\n Raises:\n ValueError: If the sum of the public keys was invalid.\n \"\"\"\n new_key = ffi.new(\"secp256k1_pubkey *\")\n\n combined = lib.secp256k1_ec_pubkey_combine(\n self.context.ctx, new_key, [pk.public_key for pk in [self, *public_keys]], len(public_keys) + 1\n )\n\n if not combined:\n msg = \"The sum of the public keys is invalid.\"\n raise ValueError(msg)\n\n if update:\n self.public_key = new_key\n return self\n\n return PublicKey(new_key, self.context)\n\n def __eq__(self, other) -> bool:\n return self.format(compressed=False) == other.format(compressed=False)\n\n def __hash__(self) -> int:\n return hash(self.format(compressed=False))\n\n\nclass PublicKeyXOnly:\n def __init__(self, data: bytes | ffi.CData, parity: bool = False, context: Context = GLOBAL_CONTEXT): # noqa: FBT001, FBT002\n \"\"\"\n Initializes a BIP340 `x-only` public key.\n\n Parameters:\n data (bytes): The formatted public key.\n parity: Whether the encoded point is the negation of the public key.\n context: The context to use.\n\n Raises:\n ValueError: If the public key could not be parsed or is invalid.\n \"\"\"\n if not isinstance(data, bytes):\n self.public_key = data\n else:\n public_key = ffi.new(\"secp256k1_xonly_pubkey *\")\n parsed = lib.secp256k1_xonly_pubkey_parse(context.ctx, public_key, data)\n if not parsed:\n msg = \"The public key could not be parsed or is invalid.\"\n raise ValueError(msg)\n\n self.public_key = public_key\n\n self.parity = parity\n self.context = context\n\n @classmethod\n def from_secret(cls, secret: bytes, context: Context = GLOBAL_CONTEXT) -> PublicKeyXOnly:\n \"\"\"\n Derives an x-only public key from a private key secret.\n\n Parameters:\n secret: The private key secret.\n context: The context to use.\n\n Returns:\n The x-only public key.\n\n Raises:\n ValueError: If the secret was invalid.\n \"\"\"\n keypair = ffi.new(\"secp256k1_keypair *\")\n res = lib.secp256k1_keypair_create(context.ctx, keypair, validate_secret(secret))\n if not res:\n msg = \"Secret was invalid\"\n raise ValueError(msg)\n\n xonly_pubkey = ffi.new(\"secp256k1_xonly_pubkey *\")\n pk_parity = ffi.new(\"int *\")\n res = lib.secp256k1_keypair_xonly_pub(context.ctx, xonly_pubkey, pk_parity, keypair)\n\n return cls(xonly_pubkey, parity=not not pk_parity[0], context=context) # noqa: SIM208\n\n @classmethod\n def from_valid_secret(cls, secret: bytes, context: Context = GLOBAL_CONTEXT) -> PublicKeyXOnly:\n \"\"\"\n Derives an x-only public key from a valid private key secret, avoiding input checks.\n\n Parameters:\n secret: The private key secret.\n context: The context to use.\n\n Returns:\n The x-only public key.\n\n Raises:\n ValueError: If the secret was invalid.\n \"\"\"\n keypair = ffi.new(\"secp256k1_keypair *\")\n res = lib.secp256k1_keypair_create(context.ctx, keypair, secret)\n if not res:\n msg = \"Secret was invalid\"\n raise ValueError(msg)\n\n xonly_pubkey = ffi.new(\"secp256k1_xonly_pubkey *\")\n pk_parity = ffi.new(\"int *\")\n res = lib.secp256k1_keypair_xonly_pub(context.ctx, xonly_pubkey, pk_parity, keypair)\n\n return cls(xonly_pubkey, parity=not not pk_parity[0], context=context) # noqa: SIM208\n\n def format(self) -> bytes:\n \"\"\"\n Serializes the public key.\n\n Returns:\n The public key serialized as 32 bytes.\n\n Raises:\n ValueError: If the public key in `self.public_key` is invalid.\n \"\"\"\n output32 = ffi.new(\"unsigned char [32]\")\n\n res = lib.secp256k1_xonly_pubkey_serialize(self.context.ctx, output32, self.public_key)\n if not res:\n msg = \"Public key in self.public_key must be valid\"\n raise ValueError(msg)\n\n return bytes(ffi.buffer(output32, 32))\n\n def verify(self, signature: bytes, message: bytes) -> bool:\n \"\"\"\n Verifies a Schnorr signature over a given message.\n\n Parameters:\n signature: The 64-byte Schnorr signature to verify.\n message: The message to be verified.\n\n Returns:\n A boolean indicating whether the signature is correct.\n\n Raises:\n ValueError: If the signature is not 64 bytes long.\n \"\"\"\n if len(signature) != 64: # noqa: PLR2004\n msg = \"Signature must be 64 bytes long.\"\n raise ValueError(msg)\n\n return not not lib.secp256k1_schnorrsig_verify( # noqa: SIM208\n self.context.ctx, signature, message, len(message), self.public_key\n )\n\n def tweak_add(self, scalar: bytes) -> None:\n \"\"\"\n Adds a scalar to the public key.\n\n Parameters:\n scalar: The scalar with which to add.\n\n Returns:\n The modified public key.\n\n Raises:\n ValueError: If the tweak was out of range or the resulting public key would be invalid.\n \"\"\"\n scalar = pad_scalar(scalar)\n\n out_pubkey = ffi.new(\"secp256k1_pubkey *\")\n res = lib.secp256k1_xonly_pubkey_tweak_add(self.context.ctx, out_pubkey, self.public_key, scalar)\n if not res:\n msg = \"The tweak was out of range, or the resulting public key would be invalid\"\n raise ValueError(msg)\n\n pk_parity = ffi.new(\"int *\")\n lib.secp256k1_xonly_pubkey_from_pubkey(self.context.ctx, self.public_key, pk_parity, out_pubkey)\n self.parity = not not pk_parity[0] # noqa: SIM208\n\n def __eq__(self, other) -> bool:\n res = lib.secp256k1_xonly_pubkey_cmp(self.context.ctx, self.public_key, other.public_key)\n return res == 0\n\n def __hash__(self) -> int:\n return hash(self.format())\n" }, { "path": "src/coincurve/py.typed", "content": "" }, { "path": "src/coincurve/types.py", "content": "from __future__ import annotations\n\nfrom collections.abc import Callable\n\nfrom coincurve._libsecp256k1 import ffi\n\nHasher = Callable[[bytes], bytes] | None\nNonce = tuple[ffi.CData, ffi.CData]\n" }, { "path": "src/coincurve/utils.py", "content": "from __future__ import annotations\n\nfrom base64 import b64decode, b64encode\nfrom hashlib import sha256 as _sha256\nfrom os import environ, urandom\nfrom typing import TYPE_CHECKING\n\nfrom coincurve._libsecp256k1 import ffi, lib\nfrom coincurve.context import GLOBAL_CONTEXT, Context\n\nif TYPE_CHECKING:\n from collections.abc import Generator\n\n from coincurve.types import Hasher\n\nGROUP_ORDER = (\n b\"\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xfe\\xba\\xae\\xdc\\xe6\\xafH\\xa0;\\xbf\\xd2^\\x8c\\xd06AA\"\n)\nGROUP_ORDER_INT = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141\nKEY_SIZE = 32\nMSG_HASH_SIZE = 32\nZERO = b\"\\x00\"\nPEM_HEADER = b\"-----BEGIN PRIVATE KEY-----\\n\"\nPEM_FOOTER = b\"-----END PRIVATE KEY-----\\n\"\n\n\nif environ.get(\"COINCURVE_BUILDING_DOCS\") != \"true\":\n DEFAULT_NONCE = (ffi.NULL, ffi.NULL)\n\n def sha256(bytestr: bytes) -> bytes:\n return _sha256(bytestr).digest()\n\nelse: # no cov\n\n class __Nonce(tuple): # noqa: SLOT001\n def __repr__(self) -> str:\n return \"(ffi.NULL, ffi.NULL)\"\n\n class __HasherSHA256:\n def __call__(self, bytestr: bytes) -> bytes:\n return _sha256(bytestr).digest()\n\n def __repr__(self) -> str:\n return \"sha256\"\n\n DEFAULT_NONCE = __Nonce((ffi.NULL, ffi.NULL))\n sha256 = __HasherSHA256()\n\n\ndef pad_hex(hexed: str) -> str:\n # Pad odd-length hex strings.\n return hexed if not len(hexed) & 1 else f\"0{hexed}\"\n\n\ndef bytes_to_int(bytestr: bytes) -> int:\n return int.from_bytes(bytestr, \"big\")\n\n\ndef int_to_bytes(num: int) -> bytes:\n return num.to_bytes((num.bit_length() + 7) // 8 or 1, \"big\")\n\n\ndef int_to_bytes_padded(num: int) -> bytes:\n return pad_scalar(num.to_bytes((num.bit_length() + 7) // 8 or 1, \"big\"))\n\n\ndef hex_to_bytes(hexed: str) -> bytes:\n return pad_scalar(bytes.fromhex(pad_hex(hexed)))\n\n\ndef chunk_data(data: bytes, size: int) -> Generator[bytes, None, None]:\n return (data[i : i + size] for i in range(0, len(data), size))\n\n\ndef der_to_pem(der: bytes) -> bytes:\n return b\"\".join([PEM_HEADER, b\"\\n\".join(chunk_data(b64encode(der), 64)), b\"\\n\", PEM_FOOTER])\n\n\ndef pem_to_der(pem: bytes) -> bytes:\n return b64decode(b\"\".join(pem.strip().splitlines()[1:-1]))\n\n\ndef get_valid_secret() -> bytes:\n while True:\n secret = urandom(KEY_SIZE)\n if ZERO < secret < GROUP_ORDER:\n return secret\n\n\ndef pad_scalar(scalar: bytes) -> bytes:\n return (ZERO * (KEY_SIZE - len(scalar))) + scalar\n\n\ndef validate_secret(secret: bytes) -> bytes:\n if not 0 < bytes_to_int(secret) < GROUP_ORDER_INT:\n msg = f\"Secret scalar must be greater than 0 and less than {GROUP_ORDER_INT}.\"\n raise ValueError(msg)\n return pad_scalar(secret)\n\n\ndef verify_signature(\n signature: bytes, message: bytes, public_key: bytes, hasher: Hasher = sha256, context: Context = GLOBAL_CONTEXT\n) -> bool:\n \"\"\"\n Verify an ECDSA signature.\n\n Parameters:\n signature: The ECDSA signature.\n message: The message that was supposedly signed.\n public_key: The formatted public key.\n hasher (collections.abc.Callable[[bytes], bytes] | None): The hash function to use, which must return 32 bytes.\n By default, the `sha256` algorithm is used. If `None`, no hashing occurs.\n context: The secp256k1 context.\n\n Returns:\n A boolean indicating whether or not the signature is correct.\n\n Raises:\n ValueError: If the public key could not be parsed or was invalid, the\n message hash was not 32 bytes long, or the DER-encoded signature\n could not be parsed.\n \"\"\"\n pubkey = ffi.new(\"secp256k1_pubkey *\")\n\n pubkey_parsed = lib.secp256k1_ec_pubkey_parse(context.ctx, pubkey, public_key, len(public_key))\n\n if not pubkey_parsed:\n msg = \"The public key could not be parsed or is invalid.\"\n raise ValueError(msg)\n\n msg_hash = hasher(message) if hasher is not None else message\n if len(msg_hash) != MSG_HASH_SIZE:\n msg = \"Message hash must be 32 bytes long.\"\n raise ValueError(msg)\n\n sig = ffi.new(\"secp256k1_ecdsa_signature *\")\n\n sig_parsed = lib.secp256k1_ecdsa_signature_parse_der(context.ctx, sig, signature, len(signature))\n\n if not sig_parsed:\n msg = \"The DER-encoded signature could not be parsed.\"\n raise ValueError(msg)\n\n verified = lib.secp256k1_ecdsa_verify(context.ctx, sig, msg_hash, pubkey)\n\n # A performance hack to avoid global bool() lookup.\n return not not verified # noqa: SIM208\n" }, { "path": "tests/__init__.py", "content": "" }, { "path": "tests/conftest.py", "content": "import pytest\n\nPRIVATE_KEY_BYTES = b\"\\xc2\\x8a\\x9f\\x80s\\x8fw\\rRx\\x03\\xa5f\\xcfo\\xc3\\xed\\xf6\\xce\\xa5\\x86\\xc4\\xfcJR#\\xa5\\xady~\\x1a\\xc3\"\nPRIVATE_KEY_DER = (\n b\"0\\x81\\x84\\x02\\x01\\x000\\x10\\x06\\x07*\\x86H\\xce=\\x02\\x01\\x06\"\n b\"\\x05+\\x81\\x04\\x00\\n\\x04m0k\\x02\\x01\\x01\\x04 \\xc2\\x8a\\x9f\"\n b\"\\x80s\\x8fw\\rRx\\x03\\xa5f\\xcfo\\xc3\\xed\\xf6\\xce\\xa5\\x86\\xc4\"\n b\"\\xfcJR#\\xa5\\xady~\\x1a\\xc3\\xa1D\\x03B\\x00\\x04=\\\\(u\\xc9\\xbd\"\n b\"\\x11hu\\xa7\\x1a]\\xb6L\\xff\\xcb\\x139k\\x16=\\x03\\x9b\\x1d\\x93'\"\n b\"\\x82H\\x91\\x80C4v\\xa45**\\xdd\\x00\\xeb\\xb0\\xd5\\xc9LQ[r\\xeb\"\n b\"\\x10\\xf1\\xfd\\x8f?\\x03\\xb4/J+%[\\xfc\\x9a\\xa9\\xe3\"\n)\nPRIVATE_KEY_HEX = \"c28a9f80738f770d527803a566cf6fc3edf6cea586c4fc4a5223a5ad797e1ac3\"\nPRIVATE_KEY_NUM = 87993618360805341115891506172036624893404292644470266399436498750715784469187\nPRIVATE_KEY_PEM = (\n b\"-----BEGIN PRIVATE KEY-----\\n\"\n b\"MIGEAgEAMBAGByqGSM49AgEGBSuBBAAKBG0wawIBAQQgwoqfgHOPdw1SeAOlZs9v\\n\"\n b\"w+32zqWGxPxKUiOlrXl+GsOhRANCAAQ9XCh1yb0RaHWnGl22TP/LEzlrFj0Dmx2T\\n\"\n b\"J4JIkYBDNHakNSoq3QDrsNXJTFFbcusQ8f2PPwO0L0orJVv8mqnj\\n\"\n b\"-----END PRIVATE KEY-----\\n\"\n)\nPUBLIC_KEY_COMPRESSED = b\"\\x03=\\\\(u\\xc9\\xbd\\x11hu\\xa7\\x1a]\\xb6L\\xff\\xcb\\x139k\\x16=\\x03\\x9b\\x1d\\x93'\\x82H\\x91\\x80C4\"\nPUBLIC_KEY_UNCOMPRESSED = (\n b\"\\x04=\\\\(u\\xc9\\xbd\\x11hu\\xa7\\x1a]\\xb6L\\xff\\xcb\\x139k\\x16=\\x03\"\n b\"\\x9b\\x1d\\x93'\\x82H\\x91\\x80C4v\\xa45**\\xdd\\x00\\xeb\\xb0\\xd5\\xc9\"\n b\"LQ[r\\xeb\\x10\\xf1\\xfd\\x8f?\\x03\\xb4/J+%[\\xfc\\x9a\\xa9\\xe3\"\n)\nPUBLIC_KEY_X = 27753912938952041417634381842191885283234814940840273460372041880794577257268\nPUBLIC_KEY_Y = 53663045980837260634637807506183816949039230809110041985901491152185762425315\n\nMESSAGE = (\n b\"\\xdfw\\xeb)\\t2R8\\xda5\\x02\\xadE\\xdd\\xce\\xd2\\xe0\\xb4\\xf1\\x81\\xe7\\xdf\"\n b\":\\xce\\x82m\\xcf\\x99\\xf3o\\x9d\\xe6\\xfb\\xe4\\x98O\\x88\\xcfh\\xbe\\xfd\\xc2\"\n b\"{\\xafm\\xb3\\xff\\xb4QR\\xffPu$\\xfc>A'\\x03t\\xc5\\xf9\\xd8\\xf3I,\\xaa\\\"*\"\n b\"\\xd7q\\xfe\\xb7]\\x11\\xa9uB'd\\x89\\x03'3\\xb8/\\x80\\xa2#\\x00\\xa2\\xfe\"\n b\"\\xff\\xae\\xb0\\x86\\xc1/ o\\xc8]?\\xa05L\\xff8\\x8az\\x92\\xc9\\xab\\x9fg0|\"\n b'\\\\5\\x98\\xfaG\\x9b#\\xec\\x1a\\xc5\\x10\\xd6\\x08\\x9c:\\x01\"\\x0c\\x812O/i'\n b'\\xc4WI\\x0c\\r\\xd8\\x81-m1_\\x14]$\\xf8\\x16\\xef\\x1e\\x1d\\xb0\"Q\\x1a\\xcf'\n b'`R\\xae\\x0c\"r2\\x9a\\xa3\\xdb\\xc4W} GROUP_ORDER\n\n secret = validate_secret(secret)\n assert len(secret) == 32\n assert ZERO < secret < GROUP_ORDER\n\n def test_out_of_range(self):\n with pytest.raises(ValueError, match=f\"Secret scalar must be greater than 0 and less than {GROUP_ORDER_INT}\"):\n validate_secret(ZERO)\n\n with pytest.raises(ValueError, match=f\"Secret scalar must be greater than 0 and less than {GROUP_ORDER_INT}\"):\n validate_secret(GROUP_ORDER)\n\n\ndef test_bytes_int_conversion():\n bytestr = b\"\\x00\" + urandom(31)\n assert pad_scalar(int_to_bytes(bytes_to_int(bytestr))) == bytestr\n\n\ndef test_bytes_int_conversion_padded():\n bytestr = b\"\\x00\" + urandom(31)\n assert int_to_bytes_padded(bytes_to_int(bytestr)) == bytestr\n\n\ndef test_der_conversion(samples):\n assert pem_to_der(der_to_pem(samples[\"PRIVATE_KEY_DER\"])) == samples[\"PRIVATE_KEY_DER\"]\n\n\ndef test_verify_signature(samples):\n assert verify_signature(samples[\"SIGNATURE\"], samples[\"MESSAGE\"], samples[\"PUBLIC_KEY_COMPRESSED\"])\n assert verify_signature(samples[\"SIGNATURE\"], samples[\"MESSAGE\"], samples[\"PUBLIC_KEY_UNCOMPRESSED\"])\n\n\ndef test_chunk_data():\n assert list(chunk_data(\"4fadd1977328c11efc1c1d8a781aa6b9677984d3e0b\", 2)) == [\n \"4f\",\n \"ad\",\n \"d1\",\n \"97\",\n \"73\",\n \"28\",\n \"c1\",\n \"1e\",\n \"fc\",\n \"1c\",\n \"1d\",\n \"8a\",\n \"78\",\n \"1a\",\n \"a6\",\n \"b9\",\n \"67\",\n \"79\",\n \"84\",\n \"d3\",\n \"e0\",\n \"b\",\n ]\n\n\nif __name__ == \"__main__\":\n pytest.main([\"-v\", __file__])\n" } ]