iricity-frontier-shared 0.5.0__tar.gz

iricity_frontier_shared-0.5.0/LICENSE

@@ -0,0 +1,178 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Iricity Leadership Private Limited (OPC)

iricity_frontier_shared-0.5.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: iricity-frontier-shared
+Version: 0.5.0
+Summary: Python implementation of the Frontier State Protocol primitives: RFC 8785 canonical JSON, SHA-256 hashing, ed25519 identity as did:key, signed envelopes, signed receipt chains and regulator-issued authorization credentials (eddsa-jcs-2022), verified against the published conformance vectors.
+Author: Iricity Leadership Private Limited
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/iricity/iricity-frontier-shared-py
+Project-URL: Vectors, https://github.com/iricity/iricity-frontier-shared
+Keywords: canonical-json,rfc8785,ed25519,did-key,receipts,provenance,space
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cryptography>=42
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Dynamic: license-file
+
+# frontier-shared (Python)
+
+Python implementation of the Frontier State Protocol primitives, byte-for-byte compatible with the JavaScript reference `@iricity/frontier-shared`. Its purpose is to prove that the specification is portable: it passes the published conformance vectors with no suite skipped.
+
+| Module | Provides | Standard |
+| --- | --- | --- |
+| `frontier_shared.canonical` | `canonical_json`, `format_number` | RFC 8785, ECMAScript number formatting |
+| `frontier_shared.hashing` | `hash_payload`, `hash_record`, `hash_text`, `hash_bytes`, `sha256_hex` | SHA-256 over canonical JSON, `sha256:` prefixed hex |
+| `frontier_shared.base58` | `base58_encode`, `base58_decode` | base58btc, multibase `z` |
+| `frontier_shared.keys` | `KeyPair`, `did_from_public_key_bytes`, `sign_bytes`, `verify_bytes` | W3C did:key, RFC 8032 Ed25519 |
+| `frontier_shared.envelope` | `create_envelope`, `verify_envelope` | `state-envelope/1` |
+| `frontier_shared.receipt` | `create_receipt_record`, `verify_receipt_record`, `verify_receipt_chain` | `state-receipt/1` |
+| `frontier_shared.credential` | `issue_authorization_credential`, `verify_credential`, `verify_authorization_credential`, `credential_hash_data` | regulator-issued authorizations: W3C Verifiable Credentials with an `eddsa-jcs-2022` Data Integrity proof |
+| `frontier_shared.conformance` | `run_conformance`, console script `frontier-shared-conformance` | vectors version 3, nine suites |
+
+Only runtime dependency: `cryptography`.
+
+## Install and verify
+
+```
+pip install iricity-frontier-shared
+frontier-shared-conformance
+```
+
+```
+conformance vectors 2: 60 passed, 0 failed, 0 skipped
+RESULT: conformant
+```
+
+Pass a path to run against a different vectors file, for example the one in the JavaScript repository:
+
+```
+frontier-shared-conformance ../iricity-frontier-shared/conformance/vectors.json
+```
+
+## Use
+
+```python
+from frontier_shared import KeyPair, create_envelope, verify_envelope, create_receipt_record, verify_receipt_chain
+
+node = KeyPair.generate()
+envelope = create_envelope(omm, "ccsds.omm.json/1", node)
+verify_envelope(envelope)            # {'verified': True, 'signer': 'did:key:z6Mk…', ...}
+
+first = create_receipt_record(record=record, issuer=node)
+second = create_receipt_record(record=next_record, previous_hash=first["receipt_hash"], issuer=node)
+verify_receipt_chain([first, second], require_genesis=True)
+```
+
+Objects produced here verify in the JavaScript implementation and vice versa; the vectors pin the signing inputs, hashes and encodings on both sides, and 26 rejection vectors pin what both verifiers must refuse. Verifiers never raise on malformed input; every problem is an entry in `errors`.
+
+## Where the traps were
+
+Four places decide whether a second implementation matches the bytes, and all four are covered by vectors:
+
+1. **Numbers.** RFC 8785 uses the ECMAScript Number-to-string algorithm (`1e+21`, `1e-7`, `123456789012345680000`, `-0` as `0`), and every JSON number is a double, so an integer literal at or above 2**53 rounds the way JavaScript rounds it. `format_number` implements both from the shortest round-trip digits.
+2. **Strings.** Only `"`, `\`, control characters below U+0020 and lone surrogates are escaped; `/` and non-ASCII are not.
+3. **Key order.** Object members sort by UTF-16 code units, not code points. The vector with a supplementary-plane key exists for this.
+4. **Signing inputs.** Domain tag plus canonical JSON of the header (envelopes) or the core fields (receipts), nothing else.
+
+## Credentials
+
+```python
+from frontier_shared import KeyPair, issue_authorization_credential, verify_credential, verify_authorization_credential
+
+regulator = KeyPair.generate()
+credential = issue_authorization_credential(
+    {"subject_id": "station_vu2abc", "capability": "transmit", "jurisdiction": "IN",
+     "bands": [{"lower_hz": 144_000_000, "upper_hz": 146_000_000, "service": "amateur"}],
+     "max_eirp_dbw": 20, "valid_from": "2026-01-01T00:00:00.000Z", "valid_until": "2031-01-01T00:00:00.000Z"},
+    regulator,
+)
+verify_credential(credential, at="2027-01-01T00:00:00Z")["verified"]        # True
+```
+
+A credential issued here verifies in the JavaScript reference and the reverse; the `credential` suite of vectors version 3 pins the proof values byte for byte. `verify_authorization_credential(record, at=...)` binds a `regulator_issued` authorization record to the credential it carries. This package verifies and issues credentials; building the authorization record itself (its derived `authorization_id`) is done with the JavaScript constructors or by the registry.
+
+## Development
+
+```
+pip install -e .[test]
+pytest
+python -m frontier_shared.conformance
+```
+
+Vectors are vendored under `src/frontier_shared/vectors/v3/` with the lock file from the JavaScript repository; a test fails if the copy drifts from the lock. A new vectors version is a new directory.
+
+## License
+
+Apache-2.0.

iricity_frontier_shared-0.5.0/README.md

@@ -0,0 +1,90 @@
+# frontier-shared (Python)
+
+Python implementation of the Frontier State Protocol primitives, byte-for-byte compatible with the JavaScript reference `@iricity/frontier-shared`. Its purpose is to prove that the specification is portable: it passes the published conformance vectors with no suite skipped.
+
+| Module | Provides | Standard |
+| --- | --- | --- |
+| `frontier_shared.canonical` | `canonical_json`, `format_number` | RFC 8785, ECMAScript number formatting |
+| `frontier_shared.hashing` | `hash_payload`, `hash_record`, `hash_text`, `hash_bytes`, `sha256_hex` | SHA-256 over canonical JSON, `sha256:` prefixed hex |
+| `frontier_shared.base58` | `base58_encode`, `base58_decode` | base58btc, multibase `z` |
+| `frontier_shared.keys` | `KeyPair`, `did_from_public_key_bytes`, `sign_bytes`, `verify_bytes` | W3C did:key, RFC 8032 Ed25519 |
+| `frontier_shared.envelope` | `create_envelope`, `verify_envelope` | `state-envelope/1` |
+| `frontier_shared.receipt` | `create_receipt_record`, `verify_receipt_record`, `verify_receipt_chain` | `state-receipt/1` |
+| `frontier_shared.credential` | `issue_authorization_credential`, `verify_credential`, `verify_authorization_credential`, `credential_hash_data` | regulator-issued authorizations: W3C Verifiable Credentials with an `eddsa-jcs-2022` Data Integrity proof |
+| `frontier_shared.conformance` | `run_conformance`, console script `frontier-shared-conformance` | vectors version 3, nine suites |
+
+Only runtime dependency: `cryptography`.
+
+## Install and verify
+
+```
+pip install iricity-frontier-shared
+frontier-shared-conformance
+```
+
+```
+conformance vectors 2: 60 passed, 0 failed, 0 skipped
+RESULT: conformant
+```
+
+Pass a path to run against a different vectors file, for example the one in the JavaScript repository:
+
+```
+frontier-shared-conformance ../iricity-frontier-shared/conformance/vectors.json
+```
+
+## Use
+
+```python
+from frontier_shared import KeyPair, create_envelope, verify_envelope, create_receipt_record, verify_receipt_chain
+
+node = KeyPair.generate()
+envelope = create_envelope(omm, "ccsds.omm.json/1", node)
+verify_envelope(envelope)            # {'verified': True, 'signer': 'did:key:z6Mk…', ...}
+
+first = create_receipt_record(record=record, issuer=node)
+second = create_receipt_record(record=next_record, previous_hash=first["receipt_hash"], issuer=node)
+verify_receipt_chain([first, second], require_genesis=True)
+```
+
+Objects produced here verify in the JavaScript implementation and vice versa; the vectors pin the signing inputs, hashes and encodings on both sides, and 26 rejection vectors pin what both verifiers must refuse. Verifiers never raise on malformed input; every problem is an entry in `errors`.
+
+## Where the traps were
+
+Four places decide whether a second implementation matches the bytes, and all four are covered by vectors:
+
+1. **Numbers.** RFC 8785 uses the ECMAScript Number-to-string algorithm (`1e+21`, `1e-7`, `123456789012345680000`, `-0` as `0`), and every JSON number is a double, so an integer literal at or above 2**53 rounds the way JavaScript rounds it. `format_number` implements both from the shortest round-trip digits.
+2. **Strings.** Only `"`, `\`, control characters below U+0020 and lone surrogates are escaped; `/` and non-ASCII are not.
+3. **Key order.** Object members sort by UTF-16 code units, not code points. The vector with a supplementary-plane key exists for this.
+4. **Signing inputs.** Domain tag plus canonical JSON of the header (envelopes) or the core fields (receipts), nothing else.
+
+## Credentials
+
+```python
+from frontier_shared import KeyPair, issue_authorization_credential, verify_credential, verify_authorization_credential
+
+regulator = KeyPair.generate()
+credential = issue_authorization_credential(
+    {"subject_id": "station_vu2abc", "capability": "transmit", "jurisdiction": "IN",
+     "bands": [{"lower_hz": 144_000_000, "upper_hz": 146_000_000, "service": "amateur"}],
+     "max_eirp_dbw": 20, "valid_from": "2026-01-01T00:00:00.000Z", "valid_until": "2031-01-01T00:00:00.000Z"},
+    regulator,
+)
+verify_credential(credential, at="2027-01-01T00:00:00Z")["verified"]        # True
+```
+
+A credential issued here verifies in the JavaScript reference and the reverse; the `credential` suite of vectors version 3 pins the proof values byte for byte. `verify_authorization_credential(record, at=...)` binds a `regulator_issued` authorization record to the credential it carries. This package verifies and issues credentials; building the authorization record itself (its derived `authorization_id`) is done with the JavaScript constructors or by the registry.
+
+## Development
+
+```
+pip install -e .[test]
+pytest
+python -m frontier_shared.conformance
+```
+
+Vectors are vendored under `src/frontier_shared/vectors/v3/` with the lock file from the JavaScript repository; a test fails if the copy drifts from the lock. A new vectors version is a new directory.
+
+## License
+
+Apache-2.0.

iricity_frontier_shared-0.5.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "iricity-frontier-shared"
+version = "0.5.0"
+description = "Python implementation of the Frontier State Protocol primitives: RFC 8785 canonical JSON, SHA-256 hashing, ed25519 identity as did:key, signed envelopes, signed receipt chains and regulator-issued authorization credentials (eddsa-jcs-2022), verified against the published conformance vectors."
+readme = "README.md"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+authors = [{ name = "Iricity Leadership Private Limited" }]
+keywords = ["canonical-json", "rfc8785", "ed25519", "did-key", "receipts", "provenance", "space"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Topic :: Security :: Cryptography",
+  "Topic :: Scientific/Engineering",
+]
+dependencies = ["cryptography>=42"]
+
+[project.optional-dependencies]
+test = ["pytest>=8"]
+
+[project.scripts]
+frontier-shared-conformance = "frontier_shared.conformance:main"
+
+[project.urls]
+Homepage = "https://github.com/iricity/iricity-frontier-shared-py"
+Vectors = "https://github.com/iricity/iricity-frontier-shared"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+frontier_shared = ["vectors/v3/*.json"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

iricity_frontier_shared-0.5.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

iricity_frontier_shared-0.5.0/src/frontier_shared/__init__.py

@@ -0,0 +1,128 @@
+"""Frontier State Protocol primitives, Python implementation.
+
+Byte-for-byte compatible with the JavaScript reference (`@iricity/frontier-shared`),
+proven by the shared conformance vectors in ``frontier_shared/vectors``.
+"""
+
+from .base58 import base58_decode, base58_encode, multibase_decode_base58btc, multibase_encode_base58btc
+from .canonical import MAX_DEPTH, canonical_json, format_number
+from .credential import (
+    AUTHORIZATION_CREDENTIAL_TYPE,
+    AUTHORIZATION_VOCAB,
+    CREDENTIAL_CONTEXT_V2,
+    CREDENTIAL_SUBJECT_FIELDS,
+    CRYPTOSUITE,
+    DATA_INTEGRITY_PROOF,
+    PROOF_PURPOSE,
+    credential_hash_data,
+    credential_subject_from_authorization,
+    issue_authorization_credential,
+    verify_authorization_credential,
+    verify_credential,
+)
+from .envelope import (
+    ENVELOPE_DOMAIN_TAG,
+    ENVELOPE_VERSION,
+    TIMESTAMP_PATTERN,
+    create_envelope,
+    envelope_hash,
+    envelope_header,
+    envelope_id_from_hash,
+    envelope_signing_input,
+    is_timestamp,
+    verify_envelope,
+)
+from .hashing import HASH_PREFIX, hash_bytes, hash_payload, hash_record, hash_text, is_hash_ref, sha256_hex, sha256_hex_bytes
+from .keys import (
+    ED25519_MULTICODEC_PREFIX,
+    KeyPair,
+    decode_signature,
+    did_from_public_key_bytes,
+    encode_signature,
+    fingerprint_did,
+    is_did_key,
+    is_valid_signature_text,
+    public_key_bytes_from_did,
+    public_key_multibase_from_did,
+    resolve_signer,
+    sign_bytes,
+    verify_bytes,
+)
+from .receipt import (
+    RECEIPT_DOMAIN_TAG,
+    RECEIPT_SIGNATURE_ALGORITHMS,
+    RECEIPT_VERSION,
+    compute_receipt_hash,
+    create_receipt_record,
+    derive_receipt_id,
+    receipt_core,
+    receipt_signing_input,
+    verify_receipt_chain,
+    verify_receipt_record,
+)
+
+__version__ = "0.5.0"
+
+__all__ = [
+    "__version__",
+    "issue_authorization_credential",
+    "verify_credential",
+    "verify_authorization_credential",
+    "credential_hash_data",
+    "credential_subject_from_authorization",
+    "CREDENTIAL_CONTEXT_V2",
+    "AUTHORIZATION_VOCAB",
+    "AUTHORIZATION_CREDENTIAL_TYPE",
+    "CREDENTIAL_SUBJECT_FIELDS",
+    "CRYPTOSUITE",
+    "DATA_INTEGRITY_PROOF",
+    "PROOF_PURPOSE",
+    "canonical_json",
+    "format_number",
+    "MAX_DEPTH",
+    "hash_text",
+    "is_valid_signature_text",
+    "is_timestamp",
+    "TIMESTAMP_PATTERN",
+    "envelope_id_from_hash",
+    "derive_receipt_id",
+    "HASH_PREFIX",
+    "sha256_hex",
+    "sha256_hex_bytes",
+    "hash_payload",
+    "hash_bytes",
+    "hash_record",
+    "is_hash_ref",
+    "base58_encode",
+    "base58_decode",
+    "multibase_encode_base58btc",
+    "multibase_decode_base58btc",
+    "ED25519_MULTICODEC_PREFIX",
+    "KeyPair",
+    "resolve_signer",
+    "did_from_public_key_bytes",
+    "public_key_bytes_from_did",
+    "public_key_multibase_from_did",
+    "is_did_key",
+    "fingerprint_did",
+    "sign_bytes",
+    "verify_bytes",
+    "encode_signature",
+    "decode_signature",
+    "ENVELOPE_VERSION",
+    "ENVELOPE_DOMAIN_TAG",
+    "create_envelope",
+    "verify_envelope",
+    "envelope_header",
+    "envelope_hash",
+    "envelope_signing_input",
+    "RECEIPT_VERSION",
+    "RECEIPT_DOMAIN_TAG",
+    "RECEIPT_SIGNATURE_ALGORITHMS",
+    "create_receipt_record",
+    "verify_receipt_record",
+    "verify_receipt_chain",
+    "receipt_core",
+    "receipt_signing_input",
+    "compute_receipt_hash",
+]

iricity_frontier_shared-0.5.0/src/frontier_shared/base58.py

@@ -0,0 +1,47 @@
+"""Base58btc (Bitcoin alphabet), as used by multibase prefix 'z'."""
+
+from __future__ import annotations
+
+__all__ = ["base58_encode", "base58_decode", "multibase_encode_base58btc", "multibase_decode_base58btc"]
+
+ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+_INDEX = {char: index for index, char in enumerate(ALPHABET)}
+
+
+def base58_encode(data: bytes) -> str:
+    data = bytes(data)
+    if not data:
+        return ""
+    value = int.from_bytes(data, "big")
+    encoded = ""
+    while value > 0:
+        value, remainder = divmod(value, 58)
+        encoded = ALPHABET[remainder] + encoded
+    leading = len(data) - len(data.lstrip(b"\x00"))
+    return "1" * leading + encoded
+
+
+def base58_decode(text: str) -> bytes:
+    if not isinstance(text, str):
+        raise TypeError("base58_decode expects a string")
+    if text == "":
+        return b""
+    value = 0
+    for char in text:
+        digit = _INDEX.get(char)
+        if digit is None:
+            raise ValueError(f"base58_decode: invalid character {char!r}")
+        value = value * 58 + digit
+    body = b"" if value == 0 else value.to_bytes((value.bit_length() + 7) // 8, "big")
+    leading = len(text) - len(text.lstrip("1"))
+    return b"\x00" * leading + body
+
+
+def multibase_encode_base58btc(data: bytes) -> str:
+    return "z" + base58_encode(data)
+
+
+def multibase_decode_base58btc(text: str) -> bytes:
+    if not isinstance(text, str) or not text.startswith("z"):
+        raise ValueError('expected a multibase base58btc string starting with "z"')
+    return base58_decode(text[1:])