qweb3 1.1.0__tar.gz

qweb3-1.1.0/LICENSE

@@ -0,0 +1,110 @@
+# Quantova Licensing Overview
+
+**Repository:** `qweb3.py` — Quantova Post-Quantum Web3 Client SDK (Python)
+
+This repository contains software and documentation developed and maintained by Quantova Inc. This file serves as the authoritative licensing index for the contents of this repository and applies to all contents of this repository unless explicitly stated otherwise. It is published in alignment with the licensing standard of the wider Quantova technology stack.
+
+## Copyright and Ownership
+
+© 2026 Quantova Inc. All rights reserved.
+
+Quantova Inc is a company registered in Singapore and is the legal owner and steward of:
+
+- The Quantova protocol
+- The QRC20 network standards
+- The Quantova Virtual Machine (QVM)
+- The Provenance and Quantization Registry (PQR)
+- Associated research, specifications, client libraries, and reference implementations
+
+`qweb3.py` is the official Python client SDK for the Quantova network and forms part of this stack.
+
+## Primary License: Business Source License (BUSL-1.1)
+
+Unless otherwise stated, all contents of this repository — including the SDK source code, reference implementations, examples, and documentation — are licensed under the Business Source License, version 1.1 (BUSL-1.1).
+
+The full license text is included in this repository at:
+
+```
+/LICENSE-BUSL-1.1
+```
+
+The authoritative BUSL-1.1 license text may also be obtained from: https://mariadb.com/bsl11/
+
+Key parameters for this repository:
+
+- **Licensor:** Quantova Inc.
+- **Licensed Work:** `qweb3.py` — Quantova Post-Quantum Web3 Client SDK, © 2026 Quantova Inc.
+- **Change Date:** 2029-06-01 (or the fourth anniversary of the first public distribution of a given version, whichever comes first).
+- **Change License:** Apache License, Version 2.0.
+
+On the Change Date, each version of the Licensed Work converts automatically to the Change License.
+
+## What This Repository Contains
+
+This repository provides the client-side developer SDK used to interact with the canonical Quantova network: post-quantum key generation and signing (Falcon, Dilithium, SPHINCS+), the `q_*` JSON-RPC client, the QVM contract layer (Solidity ABI encoding/decoding and event-log decoding), QNS `.q` name resolution, fee and gas estimation, batch requests, event hooks, a REST gateway client, and the `qweb3-cli` toolbelt. It does not contain Quantova consensus, runtime, or node implementation code.
+
+## Application and Integration Clarification
+
+Building applications, wallets, services, dashboards, integrations, and developer tooling on top of this SDK that interact with the canonical Quantova network is explicitly permitted under the BUSL-1.1 license and does not constitute restricted "Production Use." Using this SDK to submit transactions, query state, manage keys, and operate infrastructure on the Quantova network does not create additional licensing obligations.
+
+## Validator and Node Operator Clarification
+
+Running a validator node or full node on the canonical Quantova network, and using this SDK to support such operation, is explicitly permitted under the BUSL-1.1 license and does not constitute restricted "Production Use."
+
+A formal clarification for validators, node operators, exchanges, custodians, and infrastructure providers is provided at:
+
+```
+/docs/validators/licensing.md
+```
+
+Participation in staking, consensus, block production, and transaction processing on the Quantova network does not create additional licensing obligations.
+
+## Restricted Use Under BUSL-1.1
+
+The BUSL-1.1 license restricts use of the Licensed Work, together with Quantova consensus, runtime, and QVM code, to launch, operate, or market a competing blockchain network or distributed ledger that is not the canonical Quantova network. It further restricts offering the Licensed Work to third parties as a hosted or managed service, or otherwise using the Licensed Work to provide a commercial product or service that competes with the products or services of the Licensor.
+
+This restriction applies to, but is not limited to:
+
+- Independent or derivative mainnets
+- Forks marketed as separate networks
+- Networks intended to replace or compete with Quantova
+- SDK distributions repackaged or offered as a competing managed service
+
+Forking, modifying, or analyzing the code for testing, auditing, research, or contribution purposes is permitted.
+
+## Canonical Network Definition
+
+For licensing and authorization purposes, the canonical Quantova network is defined by all of the following:
+
+- Official signed source releases published by Quantova Inc
+- A unique post-quantum genesis hash
+- Signed runtime and protocol artifacts
+- Post-quantum cryptographic signatures, including CRYSTALS-Dilithium and Falcon
+
+Any network deployment that does not match these identifiers is not the Quantova network and is not authorized under the Quantova BUSL license.
+
+## Documentation and Specifications
+
+Documentation, research materials, and protocol specifications included in this repository are licensed under BUSL-1.1 unless explicitly stated otherwise within the relevant file or directory. Documentation is provided for informational and technical reference purposes and reflects protocol behavior enforced by code.
+
+## Third-Party Software
+
+This repository depends on third-party open-source software. Such components remain subject to their original licenses. This includes `requests` (Apache-2.0). Post-quantum signing additionally relies on Quantova's native post-quantum crypto backend, which is distributed separately under its own Quantova license terms. Where applicable, third-party license notices are provided in:
+
+```
+/THIRD_PARTY_LICENSES.md
+```
+
+or within dependency manifests (for example, `pyproject.toml`).
+
+## No Legal, Financial, or Regulatory Advice
+
+Nothing in this repository, including documentation and specifications, constitutes legal, financial, or regulatory advice. Operators, validators, and users are responsible for ensuring compliance with applicable laws and regulations in their respective jurisdictions.
+
+## Institutional and Licensing Inquiries
+
+Licensing, institutional, and regulatory inquiries relating to the Quantova technology stack should be directed through official Quantova channels published by Quantova Inc.
+
+Protocol identity and licensing intent are cryptographically anchored at genesis via an immutable on-chain commitment.
+
+© 2026 Quantova Inc

qweb3-1.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: qweb3
+Version: 1.1.0
+Summary: Quantova Post-Quantum Web3 Client SDK (Python)
+Author: Quantova
+License: Apache-2.0
+Project-URL: Homepage, https://quantova.org
+Keywords: quantova,web3,post-quantum,blockchain,qvm,dilithium,falcon,sphincs-plus,sdk
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25
+Requires-Dist: mnemonic>=0.20
+Dynamic: license-file
+
+# Qweb3.py
+
+**Quantova Post-Quantum Web3 Client — Python SDK.** Connect to a
+[Quantova](https://quantova.org) node, manage post-quantum accounts, sign and
+broadcast transactions, and interact with QVM smart contracts from Python. The Python
+counterpart of [qweb3.js](https://github.com/Quantova/Qweb3.js) and
+[qweb3.rs](https://github.com/Quantova/qweb3.rs).
+
+## Quantum security
+Quantova is a post-quantum Layer-1. Accounts use **NIST post-quantum signatures**
+(**Falcon-512**, **SPHINCS+ SHAKE-128s**, **CRYSTALS-Dilithium2/ML-DSA-44**) with
+**SHA3-256** — no ECDSA/secp256k1 — so they resist quantum attacks. Addresses are
+**Bech32m `Q1...`**; the chain speaks **`q_*` JSON-RPC**.
+
+## Cross-SDK compatibility (byte-for-byte)
+Accounts derive identically to qweb3.js and qweb3.rs, so **the same mnemonic yields the
+same `Q1...` address** in all three SDKs:
+
+- mnemonic -> 32-byte seed = substrate mini-secret
+  `PBKDF2-HMAC-SHA512(BIP-39 entropy, "mnemonic", 2048)[:32]` — *verified* equal to
+  qweb3.js (`"test test ... junk"` -> `4ca479f5...3b4709c`).
+- address = `SHA3-256(public_key)[:20]` with byte 0 = `0x40`, Bech32m-encoded `Q1...`.
+- keypairs use the **same post-quantum cores** as the node and qweb3.js: Falcon-512
+  (`ChaCha20Rng(seed)`), Dilithium2/ML-DSA-44 (`keygen_from_seed`), SPHINCS+ SHAKE-128s
+  (`blake2_256`-derived components).
+
+## Install
+```bash
+pip install qweb3
+```
+
+## Post-quantum backend
+The pure-Python package ships the full client (accounts, addresses, ABI, QNS, RPC,
+fees, contracts) and the mnemonic/address derivation above. **Key generation and
+signing require a post-quantum backend** exposing the falcon-wasm-style interface
+(`<scheme>_pair_from_seed` / `_sign` / `_verify`). Register it once at startup:
+
+```python
+import qweb3.crypto_backend as cb
+cb.set_backend(my_pq_backend)   # adapter over the Quantova PQ cores
+```
+
+Any backend that produces the **same Falcon-512 / ML-DSA-44 / SLH-DSA-SHAKE-128s keys
+from a seed** as qweb3.js keeps addresses and signatures cross-compatible. (The
+recommended adapter wraps the same `fn-dsa` / `fips204` / `fips205` cores used by
+qweb3.rs, so derivation stays byte-identical.)
+
+## Quick start
+```python
+from qweb3 import QWeb3
+q = QWeb3("https://rpc.quantova.org")
+acct = q.wallet.import_mnemonic("test test ... junk")   # -> same Q1... as qweb3.js/rs
+print(q.rpc.get_balance(acct.address))
+```
+
+## Resources
+- 🌐 https://quantova.org · 🔎 https://qvmscan.io · 💻 https://github.com/Quantova/Qweb3.py
+
+## License
+BUSL-1.1 - (c) 2026 Quantova Inc. See LICENSE.

qweb3-1.1.0/README.md

@@ -0,0 +1,60 @@
+# Qweb3.py
+
+**Quantova Post-Quantum Web3 Client — Python SDK.** Connect to a
+[Quantova](https://quantova.org) node, manage post-quantum accounts, sign and
+broadcast transactions, and interact with QVM smart contracts from Python. The Python
+counterpart of [qweb3.js](https://github.com/Quantova/Qweb3.js) and
+[qweb3.rs](https://github.com/Quantova/qweb3.rs).
+
+## Quantum security
+Quantova is a post-quantum Layer-1. Accounts use **NIST post-quantum signatures**
+(**Falcon-512**, **SPHINCS+ SHAKE-128s**, **CRYSTALS-Dilithium2/ML-DSA-44**) with
+**SHA3-256** — no ECDSA/secp256k1 — so they resist quantum attacks. Addresses are
+**Bech32m `Q1...`**; the chain speaks **`q_*` JSON-RPC**.
+
+## Cross-SDK compatibility (byte-for-byte)
+Accounts derive identically to qweb3.js and qweb3.rs, so **the same mnemonic yields the
+same `Q1...` address** in all three SDKs:
+
+- mnemonic -> 32-byte seed = substrate mini-secret
+  `PBKDF2-HMAC-SHA512(BIP-39 entropy, "mnemonic", 2048)[:32]` — *verified* equal to
+  qweb3.js (`"test test ... junk"` -> `4ca479f5...3b4709c`).
+- address = `SHA3-256(public_key)[:20]` with byte 0 = `0x40`, Bech32m-encoded `Q1...`.
+- keypairs use the **same post-quantum cores** as the node and qweb3.js: Falcon-512
+  (`ChaCha20Rng(seed)`), Dilithium2/ML-DSA-44 (`keygen_from_seed`), SPHINCS+ SHAKE-128s
+  (`blake2_256`-derived components).
+
+## Install
+```bash
+pip install qweb3
+```
+
+## Post-quantum backend
+The pure-Python package ships the full client (accounts, addresses, ABI, QNS, RPC,
+fees, contracts) and the mnemonic/address derivation above. **Key generation and
+signing require a post-quantum backend** exposing the falcon-wasm-style interface
+(`<scheme>_pair_from_seed` / `_sign` / `_verify`). Register it once at startup:
+
+```python
+import qweb3.crypto_backend as cb
+cb.set_backend(my_pq_backend)   # adapter over the Quantova PQ cores
+```
+
+Any backend that produces the **same Falcon-512 / ML-DSA-44 / SLH-DSA-SHAKE-128s keys
+from a seed** as qweb3.js keeps addresses and signatures cross-compatible. (The
+recommended adapter wraps the same `fn-dsa` / `fips204` / `fips205` cores used by
+qweb3.rs, so derivation stays byte-identical.)
+
+## Quick start
+```python
+from qweb3 import QWeb3
+q = QWeb3("https://rpc.quantova.org")
+acct = q.wallet.import_mnemonic("test test ... junk")   # -> same Q1... as qweb3.js/rs
+print(q.rpc.get_balance(acct.address))
+```
+
+## Resources
+- 🌐 https://quantova.org · 🔎 https://qvmscan.io · 💻 https://github.com/Quantova/Qweb3.py
+
+## License
+BUSL-1.1 - (c) 2026 Quantova Inc. See LICENSE.

qweb3-1.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "qweb3"
+version = "1.1.0"
+description = "Quantova Post-Quantum Web3 Client SDK (Python)"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "Apache-2.0" }
+keywords = ["quantova", "web3", "post-quantum", "blockchain", "qvm", "dilithium", "falcon", "sphincs-plus", "sdk"]
+authors = [{ name = "Quantova" }]
+dependencies = [
+    "requests>=2.25",
+    "mnemonic>=0.20",
+]
+
+[project.urls]
+Homepage = "https://quantova.org"
+
+[project.scripts]
+qweb3-cli = "qweb3.cli:main"
+
+[tool.setuptools]
+packages = ["qweb3"]

qweb3-1.1.0/qweb3/__init__.py

@@ -0,0 +1,107 @@
+"""qweb3 — Quantova Post-Quantum Web3 Client SDK (Python).
+
+A synchronous client for the Quantova Layer-1 blockchain: post-quantum wallets
+and signing (Falcon, Dilithium, SPHINCS+), the full ``q_*`` JSON-RPC namespace,
+a QVM contract layer with ABI codec and event-log decoding, QNS ``.q`` name
+resolution, dynamic fee/gas estimation, batch requests, real-time event hooks,
+and REST-gateway access.
+
+Quick start::
+
+    from qweb3 import QWeb3
+    q = QWeb3("http://127.0.0.1:9944", rest_url="http://127.0.0.1:8080")
+    block = q.rpc.block_number()
+    fees = q.fees.estimate()
+
+Post-quantum signing requires Quantova's crypto backend; install it and call
+``qweb3.crypto_backend.set_backend(...)`` (see that module's docstring).
+"""
+
+from . import abi, crypto_backend
+from .abi import (
+    decode_function_result,
+    decode_parameters,
+    encode_function_call,
+    encode_parameters,
+    event_topic,
+    function_selector,
+)
+from .batch import BatchRequest, BatchResult
+from .contract import QContract
+from .errors import (
+    ConnectionErrorQ,
+    InvalidArgumentError,
+    QWeb3Error,
+    RpcError,
+    TransactionError,
+)
+from .fee import FeeOracle
+from .hooks import EventHooks, TxTracker
+from .qns import QNS
+from .rest import QRestClient
+from .rpc import QRpcClient
+from .signer import QuantumSigner
+from .utils import AddressUtils, FormatUtils, HexUtils, ValidationUtils
+from .wallet import Account, QuantumWallet
+
+__version__ = "1.1.0"
+
+
+class QWeb3:
+    """High-level facade wiring the RPC client, wallet, fees, hooks, and helpers."""
+
+    def __init__(self, url: str = "http://127.0.0.1:9944", *,
+                 rest_url: str = None, session=None) -> None:
+        self.url = url
+        self.rpc = QRpcClient(url, session=session)
+        self.rest = QRestClient(rest_url, session=session) if rest_url else None
+        self.wallet = QuantumWallet()
+        self.signer = QuantumSigner
+        self.abi = abi
+        self.fees = FeeOracle(rpc=self.rpc, rest_client=self.rest)
+        self.hooks = EventHooks(rpc=self.rpc, rest_client=self.rest)
+
+    def contract(self, abi_list, address: str) -> QContract:
+        return QContract(abi_list, address, rpc=self.rpc, wallet=self.wallet, rest_client=self.rest)
+
+    def qns(self, registry_address: str, **kwargs) -> QNS:
+        return QNS(registry_address, rpc=self.rpc, wallet=self.wallet,
+                   rest_client=self.rest, **kwargs)
+
+    def batch(self) -> BatchRequest:
+        return BatchRequest(self.url)
+
+
+__all__ = [
+    "QWeb3",
+    "QRpcClient",
+    "QRestClient",
+    "QuantumWallet",
+    "Account",
+    "QuantumSigner",
+    "QContract",
+    "QNS",
+    "BatchRequest",
+    "BatchResult",
+    "FeeOracle",
+    "EventHooks",
+    "TxTracker",
+    "AddressUtils",
+    "HexUtils",
+    "FormatUtils",
+    "ValidationUtils",
+    "QWeb3Error",
+    "ConnectionErrorQ",
+    "InvalidArgumentError",
+    "RpcError",
+    "TransactionError",
+    "abi",
+    "crypto_backend",
+    "function_selector",
+    "event_topic",
+    "encode_parameters",
+    "decode_parameters",
+    "encode_function_call",
+    "decode_function_result",
+    "__version__",
+]

qweb3-1.1.0/qweb3/_keccak.py

@@ -0,0 +1,73 @@
+"""Pure-Python keccak-256 (Ethereum/Solidity padding, 0x01).
+
+This is the default selector/topic hash used by the QVM ABI codec, which speaks
+the standard Solidity ABI. It is dependency-free so the codec works out of the
+box; it can be overridden via ``qweb3.abi.set_keccak`` (for example to use a
+faster C implementation, or the hash provided by Quantova's crypto backend).
+
+Note: this is keccak-256, not SHA3-256. They differ only in the padding byte.
+Quantova hashes *transactions/state* with SHA3-256 (handled in the signing
+layer); contract-call *selectors* use keccak-256, which is what this provides.
+"""
+
+from typing import List
+
+_RC = [
+    0x0000000000000001, 0x0000000000008082, 0x800000000000808A, 0x8000000080008000,
+    0x000000000000808B, 0x0000000080000001, 0x8000000080008081, 0x8000000000008009,
+    0x000000000000008A, 0x0000000000000088, 0x0000000080008009, 0x000000008000000A,
+    0x000000008000808B, 0x800000000000008B, 0x8000000000008089, 0x8000000000008003,
+    0x8000000000008002, 0x8000000000000080, 0x000000000000800A, 0x800000008000000A,
+    0x8000000080008081, 0x8000000000008080, 0x0000000080000001, 0x8000000080008008,
+]
+_ROT = [
+    [0, 36, 3, 41, 18],
+    [1, 44, 10, 45, 2],
+    [62, 6, 43, 15, 61],
+    [28, 55, 25, 21, 56],
+    [27, 20, 39, 8, 14],
+]
+_MASK = (1 << 64) - 1
+
+
+def _rotl(x: int, n: int) -> int:
+    return ((x << n) | (x >> (64 - n))) & _MASK
+
+
+def _keccak_f(s: List[List[int]]) -> None:
+    for rnd in range(24):
+        c = [s[x][0] ^ s[x][1] ^ s[x][2] ^ s[x][3] ^ s[x][4] for x in range(5)]
+        d = [c[(x + 4) % 5] ^ _rotl(c[(x + 1) % 5], 1) for x in range(5)]
+        for x in range(5):
+            for y in range(5):
+                s[x][y] ^= d[x]
+        b = [[0] * 5 for _ in range(5)]
+        for x in range(5):
+            for y in range(5):
+                b[y][(2 * x + 3 * y) % 5] = _rotl(s[x][y], _ROT[x][y])
+        for x in range(5):
+            for y in range(5):
+                s[x][y] = (b[x][y] ^ ((~b[(x + 1) % 5][y]) & b[(x + 2) % 5][y])) & _MASK
+        s[0][0] ^= _RC[rnd]
+
+
+def keccak256(data: bytes) -> bytes:
+    """Return the 32-byte keccak-256 digest of ``data``."""
+    rate = 136  # bytes for keccak-256
+    msg = bytearray(data)
+    pad_len = rate - (len(msg) % rate)
+    msg += bytearray(pad_len)
+    msg[len(data)] ^= 0x01          # keccak padding (Ethereum/Solidity)
+    msg[-1] ^= 0x80
+
+    s = [[0] * 5 for _ in range(5)]
+    for off in range(0, len(msg), rate):
+        for i in range(rate // 8):
+            lane = int.from_bytes(msg[off + i * 8: off + i * 8 + 8], "little")
+            s[i % 5][i // 5] ^= lane
+        _keccak_f(s)
+
+    out = bytearray()
+    for i in range(4):  # 4 lanes * 8 bytes = 32 bytes
+        out += (s[i % 5][i // 5]).to_bytes(8, "little")
+    return bytes(out)