minizign 0.0.1__tar.gz

minizign-0.0.1/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Tobias Simetsreiter
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

minizign-0.0.1/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: minizign
+Version: 0.0.1
+Summary: a native cpython extension for minisign using zig
+Author-email: Tobias Simetsreiter <dasimmet@gmail.com>
+Maintainer-email: Tobias Simetsreiter <dasimmet@gmail.com>
+License-Expression: MIT
+Keywords: zig,ziglang,cpython,native,sdist,minisign,minisign-zig
+Requires-Python: >=3.9
+Project-URL: Homepage, https://codeberg.org/dasimmet/minizign
+Project-URL: Issues, https://codeberg.org/dasimmet/minizign/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Zig
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Description-Content-Type: text/markdown
+
+# minizign
+
+Fast, lightweight Python bindings for the Zig [minisign](https://jedisct1.github.io/minisign/) implementation.
+
+`minizign` provides high-performance cryptographic signing and verification using Ed25519 and Blake2b-512 with full Minisign format compatibility.
+
+---
+
+## Features
+
+- **Standard Minisign Compatibility**: Interoperable with official `minisign` files, keys, and signatures.
+- **Multiple Input Types**: Sign and verify `str`, `bytes`, `bytearray`, `memoryview`, integer file descriptors (`int`), and file-like objects.
+- **Streaming Hashing**: Fast chunked hashing (Blake2b-512) for large files and file descriptors without loading entire files into memory.
+- **Direct Output Writing**: Write signatures and keys directly to integer file descriptors or file-like streams.
+- **Full Comment Support**: Custom trusted comments and untrusted comments on signatures, public keys, and secret keys.
+- **Type Annotations**: Fully typed with PEP 561 `.pyi` stubs.
+
+---
+
+## Installation
+
+```bash
+pip install minizign
+```
+
+---
+
+## Quickstart
+
+### Keypair Generation
+
+```python
+import minizign
+
+# Generate a new random secret key
+sk = minizign.SecretKey(untrusted_comment="my secret key")
+
+# Derive the corresponding public key
+pk = sk.getPublicKey(untrusted_comment="my public key")
+
+# Export keys as Minisign formatted strings
+sk_str = sk.toString()
+pk_str = pk.toString()
+
+print("Public Key:")
+print(pk_str)
+```
+
+### Signing and Verifying Data
+
+```python
+import minizign
+
+sk = minizign.SecretKey()
+pk = sk.getPublicKey()
+
+# Sign a string or bytes
+message = "Hello, world!"
+sig = sk.sign(
+    message,
+    trusted_comment="trusted timestamp",
+    untrusted_comment="signature from minizign"
+)
+
+# Verify with PublicKey or Signature object
+is_valid = pk.verify(message, sig)
+print("Valid:", is_valid)  # True
+
+# Verify using top-level helper
+print("Valid:", minizign.verify(message, sig, pk))  # True
+```
+
+### Signing Files and File Descriptors (Streaming)
+
+```python
+import os
+import minizign
+
+sk = minizign.SecretKey()
+pk = sk.getPublicKey()
+
+# Sign a file stream directly
+with open("large_dataset.tar.gz", "rb") as f:
+    sig = sk.sign(f, trusted_comment="release archive")
+
+# Verify with file object
+with open("large_dataset.tar.gz", "rb") as f:
+    assert pk.verify(f, sig)
+
+# Sign using an OS file descriptor and write signature directly to another fd
+fd_in = os.open("document.pdf", os.O_RDONLY)
+fd_out = os.open("document.pdf.minisig", os.O_WRONLY | os.O_CREAT | os.O_TRUNC)
+
+sig = sk.sign(fd_in, out=fd_out, trusted_comment="approved")
+
+os.close(fd_in)
+os.close(fd_out)
+```
+
+### Loading Keys and Signatures
+
+```python
+import minizign
+
+# Load from serialized strings
+pk = minizign.PublicKey("untrusted comment: minisign public key\nRWR...\n")
+sig = minizign.Signature("untrusted comment: ...\n...\ntrusted comment: ...\n...\n")
+
+# Load from file or file descriptor
+with open("minisign.pub", "r") as f:
+    pk_from_file = minizign.PublicKey(f)
+
+# Inspect properties
+print(sig.trusted_comment)
+print(sig.untrusted_comment)
+print(sig.signature)        # 64 bytes
+print(sig.global_signature) # 64 bytes
+print(sig.key_id)           # 8 bytes
+```
+
+---
+
+## API Reference
+
+### Module Functions
+
+- **`minizign.sign(secret_key, message, trusted_comment=None, untrusted_comment=None, out=None, timestamp=None) -> Signature`**  
+  Sign a message with a `SecretKey`. Output can optionally be written to a file descriptor or file object. A custom `timestamp` (`int`, `float`, or `str`) can be supplied.
+
+- **`minizign.verify(message, signature, public_key) -> bool`**  
+  Verify a signature against a message and a `PublicKey`.
+
+### `SecretKey`
+- **`SecretKey(str=None, *, untrusted_comment=None, comment=None)`**: Generate a new random key or load from input (`str`, `bytes`, `int` fd, or file object).
+- **`sk.getPublicKey(untrusted_comment=None, *, comment=None) -> PublicKey`**: Extract the corresponding public key.
+- **`sk.sign(message, trusted_comment=None, untrusted_comment=None, out=None, timestamp=None) -> Signature`**: Sign `message` (`str`, `bytes`, `bytearray`, `memoryview`, `int` fd, or file).
+- **`sk.signBytes(data, ...)`** / **`sk.signString(message, ...)`**: Aliases for `sign`.
+- **`sk.toString(out=None, *, untrusted_comment=None, comment=None) -> Optional[str]`**: Format as serialized Minisign secret key string or write to `out`.
+- **`sk.write(out, *, untrusted_comment=None, comment=None) -> None`**: Write secret key to an output destination.
+- **Properties**: `untrusted_comment`, `comment`, `key_id`, `secret_key`.
+
+### `PublicKey`
+- **`PublicKey(str=None, *, untrusted_comment=None, comment=None)`**: Load a public key from string, bytes, file descriptor, or file.
+- **`pk.verify(message, signature) -> bool`**: Verify a signature against a message (`str`, `bytes`, `bytearray`, `memoryview`, `int` fd, or file).
+- **`pk.verifyString(message, signature) -> bool`**: Alias for `verify`.
+- **`pk.toString(out=None, *, untrusted_comment=None, comment=None) -> Optional[str]`**: Format as Minisign public key string or write to `out`.
+- **`pk.write(out, *, untrusted_comment=None, comment=None) -> None`**: Write public key to an output destination.
+- **Properties**: `untrusted_comment`, `comment`, `key_id`, `key`, `public_key`.
+
+### `Signature`
+- **`Signature(str=None, *, untrusted_comment=None, comment=None)`**: Parse a signature from string, bytes, file descriptor, or file.
+- **`sig.verify(message, public_key) -> bool`**: Verify this signature against a message and public key.
+- **`sig.toString(out=None) -> Optional[str]`**: Format as Minisign signature string or write to `out`.
+- **`sig.write(out) -> None`**: Write signature to an output destination.
+- **Properties**: `trusted_comment`, `untrusted_comment`, `comment`, `signature`, `global_signature`, `key_id`.
+
+---
+
+## License
+
+MIT / Apache-2.0

minizign-0.0.1/build.zig

@@ -0,0 +1,152 @@
+const std = @import("std");
+const Build = std.Build;
+const zig_python_sdist = @import("zig_python_sdist");
+const zon = @import("build.zig.zon");
+
+pub fn build(b: *Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+    const minizign = b.dependency("minizign", .{
+        .@"no-cli" = true,
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // this target and section of our build is used at pip install time
+    const ext_install_step = b.step("bdist-wheel", "build python extension module");
+
+    // TODO: generate the .pyi after wheel build with:
+    // stubgen -p minizign -o .
+    ext_install_step.dependOn(
+        &b.addInstallFile(b.path("src/minizign.pyi"), "lib/minizign.pyi").step,
+    );
+    // this generates a python sdist archive
+    const sdist = zig_python_sdist.createSdistStep(b, .{
+        .name = "minizign",
+        .version = zon.version,
+        .description = b.path("README.md"),
+        .build = .{
+            .args = &.{
+                ext_install_step.name,
+                b.fmt("-Doptimize={s}", .{@tagName(optimize)}),
+                "--fork=zig-pkg/minizign",
+                "--verbose",
+            },
+        },
+        .extra_pkg_info = @import("pkg-info.zon"),
+        .files = &.{
+            .{ .src = b.path("pkg-info.zon"), .dest = "pkg-info.zon" },
+            .{ .src = b.path("build.zig.zon"), .dest = "build.zig.zon" },
+            .{ .src = b.path("build.zig"), .dest = "build.zig" },
+            .{ .src = b.path("src/minizign_py.zig"), .dest = "src/minizign_py.zig" },
+            .{ .src = b.path("src/minizign.pyi"), .dest = "src/minizign.pyi" },
+            .{ .src = b.path("LICENSE"), .dest = "LICENSE" },
+        },
+        .directories = &.{
+            .{ .src = minizign.path(""), .dest = "zig-pkg/minizign" },
+            .{ .src = minizign.path("src"), .dest = "zig-pkg/minizign/src" },
+        },
+        .compression = .best,
+    });
+
+    const sdistfile = b.addInstallFileWithDir(
+        sdist.getEmittedArchive(),
+        .{ .custom = "src" },
+        sdist.basename,
+    );
+    b.getInstallStep().dependOn(&sdistfile.step);
+
+    // we can use a python virtual environment inside
+    // the zig cache to test pip installation
+    const test_pip_install = zig_python_sdist.createVenvInstallTest(
+        b,
+        .{
+            .sdist = sdist.getEmittedArchive(),
+            .unittest_py = &.{b.path("src/tests.py")},
+            .twine_check = true,
+            .no_clean = b.option(bool, "pip-no-clean", "dont cleanup pip temp dirs") orelse false,
+        },
+    );
+    b.step("test-pip-install", "test building and installing the source distributuin, then run tests").dependOn(test_pip_install.step);
+
+    const cpython = zig_python_sdist.createCPythonModule(b, .{
+        .target = target,
+        .version = zon.version,
+        .optimize = .Debug,
+        .macros = &.{
+            .{ "Py_LIMITED_API", "0x03090000" }, // use the limited api from 3.9.0
+        },
+    });
+    const lib = b.addLibrary(.{
+        .name = "minizign",
+        .root_module = b.addModule(@tagName(zon.name), .{
+            .root_source_file = b.path("src/minizign_py.zig"),
+            .target = target,
+            .optimize = optimize,
+            .imports = &.{
+                .{ .name = "cpython", .module = cpython },
+                .{
+                    .name = "minizign",
+                    .module = minizign.module("minizign"),
+                },
+            },
+        }),
+        .linkage = .dynamic,
+    });
+    const ext_path = zig_python_sdist.CPython.renameExtLib(b, lib);
+    const ext_install = zig_python_sdist.installExtLib(b, lib);
+    ext_install_step.dependOn(&ext_install.step);
+
+    {
+        const ext_tests = ext_path.wf.addCopyFile(b.path("src/tests.py"), "tests.py");
+        const test_run = Build.Step.Run.create(b, "unittest");
+        test_run.setCwd(ext_path.wf.getDirectory());
+        test_run.setEnvironmentVariable("PYTHONPATH", ".");
+        test_run.addFileArg(zig_python_sdist.CPython.find(b));
+        if (b.option(bool, "tracetest", "run unittest with tracing") orelse false) {
+            test_run.addArgs(&.{ "-m", "trace", "--trace" });
+        } else {
+            test_run.addArgs(&.{ "-m", "unittest" });
+        }
+        test_run.addDirectoryArg(ext_tests);
+        b.step("test-bdist", "run unittests against the extension").dependOn(&test_run.step);
+    }
+
+    const usf = b.addUpdateSourceFiles();
+    b.step("update-src", "updates the pyi file. needs 'mypy' installed").dependOn(&usf.step);
+
+    {
+        const stubgen_run = Build.Step.Run.create(b, "stubgen");
+        stubgen_run.setCwd(ext_path.wf.getDirectory());
+        stubgen_run.addArgs(&.{
+            "stubgen",
+            "-m",
+            lib.name,
+            "-o",
+        });
+        const stub_dir = stubgen_run.addOutputDirectoryArg("stubgen");
+        stubgen_run.addArg("--search-path");
+        stubgen_run.addDirectoryArg(ext_path.wf.getDirectory());
+        usf.addCopyFileToSource(
+            stub_dir.path(b, b.fmt("{s}.pyi", .{lib.name})),
+            b.fmt("src/{s}.pyi", .{lib.name}),
+        );
+    }
+
+    const opt_check_fmt = b.option(bool, "check-fmt", "Check formatting without modifying files") orelse false;
+    const opt_fmt_check = b.option(bool, "fmt-check", "Check formatting without modifying files") orelse false;
+    const check_fmt = opt_check_fmt or opt_fmt_check;
+    const fmt_step = b.step("fmt", "Run zig fmt");
+    const fmt = b.addFmt(.{
+        .paths = &.{
+            "src",
+            "build.zig",
+            "build.zig.zon",
+        },
+        .check = check_fmt,
+    });
+    fmt_step.dependOn(&fmt.step);
+    if (check_fmt) {
+        b.getInstallStep().dependOn(&fmt.step);
+    }
+}

minizign-0.0.1/build.zig.zon

@@ -0,0 +1,23 @@
+.{
+    .name = .minizign_py,
+    .version = "0.0.1",
+    .minimum_zig_version = "0.16.0",
+    .dependencies = .{
+        .minizign = .{
+            .url = "git+https://github.com/dasimmet/zig-minisign.git?ref=make-clap-optional#6afbab9dbe666f0dcd2f281d48fcea69a976e99d",
+            .hash = "minizign-0.1.13-gg18cU8iAQArW3UTkAHQh8nF0LlW5FawU3qTQ7Nxc2N6",
+        },
+        .zig_python_sdist = .{
+            .url = "git+https://codeberg.org/dasimmet/zig-python-sdist.git#40512e233eeb00482e58c2bae1a1c902e2a20c2d",
+            .hash = "zig_python_sdist-0.0.4-wjgdOvsbAQDeIlnTARjUVNTPzEUetowFy5W_Vue33_6r",
+        },
+    },
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "README.md",
+        "pkg-info.zon",
+        "src",
+    },
+    .fingerprint = 0x703e87b667b760da,
+}

minizign-0.0.1/pkg-info.zon

@@ -0,0 +1,15 @@
+.{
+    .{ .key = "Summary", .value = "a native cpython extension for minisign using zig" },
+    .{ .key = "Author-email", .value = "Tobias Simetsreiter <dasimmet@gmail.com>" },
+    .{ .key = "Maintainer-email", .value = "Tobias Simetsreiter <dasimmet@gmail.com>" },
+    .{ .key = "License-Expression", .value = "MIT" },
+    .{ .key = "Keywords", .value = "zig,ziglang,cpython,native,sdist,minisign,minisign-zig" },
+    .{ .key = "Requires-Python", .value = ">=3.9" },
+    .{ .key = "Project-URL", .value = "Homepage, https://codeberg.org/dasimmet/minizign" },
+    .{ .key = "Project-URL", .value = "Issues, https://codeberg.org/dasimmet/minizign/issues" },
+    .{ .key = "Classifier", .value = "Development Status :: 4 - Beta" },
+    .{ .key = "Classifier", .value = "Programming Language :: Python :: 3" },
+    .{ .key = "Classifier", .value = "Programming Language :: Zig" },
+    .{ .key = "Classifier", .value = "Intended Audience :: Developers" },
+    .{ .key = "Classifier", .value = "Topic :: Software Development :: Libraries" },
+}

minizign-0.0.1/setup.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+
+from setuptools import setup
+from setuptools.command.bdist_wheel import bdist_wheel
+import subprocess
+import sys
+import os
+import json
+import glob
+import shutil
+
+with open("setup.zig.json") as fd:
+    setup_json = json.load(fd)
+
+
+def mkversion(v, need_release=False):
+    '''assembles a dict of semantic version to string'''
+    if need_release:
+        assert v['pre'] == None, "cannot use version with pre: " + str(v)
+        assert v['build'] == None, "cannot use version with build: " + str(v)
+    return str(v['major']) + '.' + str(
+        v['minor']) + '.' + str(v['patch'])
+
+
+class ZigBuildWheel(bdist_wheel):
+    def run(self, *args, **kwargs):
+
+        import ziglang
+        zig_exe = os.path.join(
+            os.path.dirname(ziglang.__file__), "zig")
+
+        cwd = os.getcwd()
+        print("zig build dir:", cwd, file=sys.stderr)
+        print("using zig exe:", zig_exe, file=sys.stderr)
+
+        extra_build_args = setup_json['build']['args']
+        build_cmd = [zig_exe, 'build'] + extra_build_args
+
+        print("zig build:", build_cmd, file=sys.stderr)
+        subprocess.check_call(build_cmd)
+
+        os.makedirs(self.bdist_dir, exist_ok=True)
+        copy_pattern = setup_json['build']['copy_pattern']
+        for pattern in copy_pattern:
+            artifacts = glob.glob(pattern)
+            if len(artifacts) == 0:
+                raise Exception(
+                    'no zig artifacts found in {}/{}'.format(cwd, pattern))
+
+            for it in artifacts:
+                shutil.copyfile(it, os.path.join(
+                    self.bdist_dir, os.path.basename(it)))
+
+        return super().run(*args, **kwargs)
+
+
+setup(
+    name=setup_json['name'],
+    version=mkversion(setup_json['version']),
+    cmdclass={'bdist_wheel': ZigBuildWheel},
+    install_requires=setup_json['install_requires'],
+    entry_points=setup_json['entry_points'],
+    packages=setup_json['build']['packages'],
+    setup_requires=[
+        "setuptools",
+        "wheel",
+        "ziglang==" + mkversion(setup_json['zig_version'], need_release=True),
+    ] + setup_json['build']['requires'],
+)

minizign-0.0.1/setup.zig.json

@@ -0,0 +1 @@
+{"name":"minizign","version":{"major":0,"minor":0,"patch":1,"pre":null,"build":null},"zig_version":{"major":0,"minor":16,"patch":0,"pre":null,"build":null},"build":{"args":["--fork=zig-pkg/zig_python_sdist-0.0.4","bdist-wheel","-Doptimize=ReleaseSmall","--fork=zig-pkg/minizign","--verbose"],"requires":[],"packages":[],"copy_pattern":["zig-out/lib/*"]},"install_requires":[],"entry_points":{"console_scripts":[],"gui_scripts":[]}}

minizign-0.0.1/src/minizign.pyi

@@ -0,0 +1,158 @@
+from typing import Union, Optional, Any, BinaryIO, TextIO
+
+__version__: dict
+__version_str__: str
+__zig_builtin__: dict
+
+MessageInput = Union[str, bytes, bytearray, memoryview, int, BinaryIO, TextIO]
+OutputDestination = Union[int, BinaryIO, TextIO]
+SignatureInput = Union['Signature', str, bytes, bytearray, memoryview, int, BinaryIO, TextIO]
+PublicKeyInput = Union['PublicKey', str, bytes, bytearray, memoryview, int, BinaryIO, TextIO]
+SecretKeyInput = Union['SecretKey', str, bytes, bytearray, memoryview, int, BinaryIO, TextIO]
+
+def sign(
+    secret_key: 'SecretKey',
+    message: MessageInput,
+    trusted_comment: Optional[Union[str, bytes]] = None,
+    untrusted_comment: Optional[Union[str, bytes]] = None,
+    out: Optional[OutputDestination] = None,
+    timestamp: Optional[Union[int, float, str, bytes]] = None,
+) -> 'Signature': ...
+
+def verify(
+    message: MessageInput,
+    signature: SignatureInput,
+    public_key: PublicKeyInput,
+) -> bool: ...
+
+class Signature:
+    trusted_comment: str
+    untrusted_comment: str
+    comment: str
+    signature: bytes
+    global_signature: bytes
+    key_id: bytes
+
+    def __init__(
+        self,
+        str: Optional[Union[str, bytes, int, BinaryIO, TextIO]] = None,
+        *,
+        untrusted_comment: Optional[Union[str, bytes]] = None,
+        comment: Optional[Union[str, bytes]] = None,
+    ) -> None: ...
+
+    def toString(self, out: Optional[OutputDestination] = None) -> Optional[str]: ...
+    def write(self, out: OutputDestination) -> None: ...
+    def verify(
+        self,
+        message: MessageInput,
+        public_key: PublicKeyInput,
+    ) -> bool: ...
+
+    @classmethod
+    def __class_getitem__(cls, item: Any) -> Any: ...
+
+class PublicKey:
+    untrusted_comment: str
+    comment: str
+    key_id: bytes
+    key: bytes
+    public_key: bytes
+
+    def __init__(
+        self,
+        str: Optional[Union[str, bytes, int, BinaryIO, TextIO]] = None,
+        *,
+        untrusted_comment: Optional[Union[str, bytes]] = None,
+        comment: Optional[Union[str, bytes]] = None,
+    ) -> None: ...
+
+    def toString(
+        self,
+        out: Optional[OutputDestination] = None,
+        *,
+        untrusted_comment: Optional[Union[str, bytes]] = None,
+        comment: Optional[Union[str, bytes]] = None,
+    ) -> Optional[str]: ...
+    def write(
+        self,
+        out: OutputDestination,
+        *,
+        untrusted_comment: Optional[Union[str, bytes]] = None,
+        comment: Optional[Union[str, bytes]] = None,
+    ) -> None: ...
+    def verify(
+        self,
+        message: MessageInput,
+        signature: SignatureInput,
+    ) -> bool: ...
+    def verifyString(
+        self,
+        message: MessageInput,
+        signature: SignatureInput,
+    ) -> bool: ...
+
+    @classmethod
+    def __class_getitem__(cls, item: Any) -> Any: ...
+
+class SecretKey:
+    untrusted_comment: str
+    comment: str
+    key_id: bytes
+    secret_key: bytes
+
+    def __init__(
+        self,
+        str: Optional[Union[str, bytes, int, BinaryIO, TextIO]] = None,
+        *,
+        untrusted_comment: Optional[Union[str, bytes]] = None,
+        comment: Optional[Union[str, bytes]] = None,
+    ) -> None: ...
+
+    def getPublicKey(
+        self,
+        untrusted_comment: Optional[Union[str, bytes]] = None,
+        *,
+        comment: Optional[Union[str, bytes]] = None,
+    ) -> PublicKey: ...
+    def sign(
+        self,
+        message: MessageInput,
+        trusted_comment: Optional[Union[str, bytes]] = None,
+        untrusted_comment: Optional[Union[str, bytes]] = None,
+        out: Optional[OutputDestination] = None,
+        timestamp: Optional[Union[int, float, str, bytes]] = None,
+    ) -> Signature: ...
+    def signString(
+        self,
+        message: MessageInput,
+        trusted_comment: Optional[Union[str, bytes]] = None,
+        untrusted_comment: Optional[Union[str, bytes]] = None,
+        out: Optional[OutputDestination] = None,
+        timestamp: Optional[Union[int, float, str, bytes]] = None,
+    ) -> Signature: ...
+    def signBytes(
+        self,
+        data: MessageInput,
+        trusted_comment: Optional[Union[str, bytes]] = None,
+        untrusted_comment: Optional[Union[str, bytes]] = None,
+        out: Optional[OutputDestination] = None,
+        timestamp: Optional[Union[int, float, str, bytes]] = None,
+    ) -> Signature: ...
+    def toString(
+        self,
+        out: Optional[OutputDestination] = None,
+        *,
+        untrusted_comment: Optional[Union[str, bytes]] = None,
+        comment: Optional[Union[str, bytes]] = None,
+    ) -> Optional[str]: ...
+    def write(
+        self,
+        out: OutputDestination,
+        *,
+        untrusted_comment: Optional[Union[str, bytes]] = None,
+        comment: Optional[Union[str, bytes]] = None,
+    ) -> None: ...
+
+    @classmethod
+    def __class_getitem__(cls, item: Any) -> Any: ...