web3 7.0.0b1__py3-none-any.whl → 7.7.0__py3-none-any.whl

ethpm/tools/checker.py

@@ -1,312 +0,0 @@
-import re
-from typing import (
-    Any,
-    Dict,
-)
-
-from eth_typing import (
-    Manifest,
-)
-from eth_utils.toolz import (
-    assoc,
-    assoc_in,
-    curry,
-)
-
-from ethpm.constants import (
-    PACKAGE_NAME_REGEX,
-)
-from ethpm.tools.builder import (
-    build,
-)
-
-# todo: validate no duplicate blockchain uris in deployments, if web3 is available
-
-WARNINGS = {
-    "manifest_missing": "Manifest missing a required 'manifest' field.",
-    "manifest_invalid": """'manifest' is invalid. The only supported"""
-    """ version is 'ethpm/3'.""",
-    "name_missing": "Manifest missing a suggested 'name' field",
-    "name_invalid": "'name' is invalid. "
-    f"Doesn't match the regex: {PACKAGE_NAME_REGEX}",
-    "version_missing": "Manifest missing a suggested 'version' field.",
-    "meta_missing": "Manifest missing a suggested 'meta' field.",
-    "authors_missing": "'meta' field missing suggested 'authors' field.",
-    "description_missing": "'meta' field missing suggested 'description' field.",
-    "links_missing": "'meta' field missing suggested 'links' field.",
-    "license_missing": "'meta' field missing suggested 'license' field.",
-    "keywords_missing": "'meta' field missing suggested 'keywords' field.",
-    "sources_missing": """Manifest is missing a sources field, """
-    """which defines a source tree that should comprise the full source tree """
-    """necessary to recompile the contracts contained in this release.""",
-    "contract_type_missing": """Manifest does not contain any 'contractTypes'. """
-    """Packages should only include contract types that can be found in the """
-    """source files for this package. Packages should not include contract types """
-    """from dependencies. Packages should not include abstract contracts in the """
-    """contract types section of a release.""",
-    "abi_missing": """Contract type: {0} is missing an abi field, which is """
-    """essential for using this package.""",
-    "deployment_bytecode_missing": """Contract type: {0} is missing a """
-    """`deploymentBytecode` field, which is essential for using this package.""",
-    "contract_type_subfield_missing": """Contract type: {0} is missing a"""
-    """ `contractType` field, which is essential if an alias is being used """
-    """to namespace this contract type.""",
-    "runtime_bytecode_missing": """Contract type: {0} is missing a """
-    """`runtimeBytecode` field.""",
-    "bytecode_subfield_missing": """Contract type: {0} is missing a required  """
-    """bytecode subfield in its {1} bytecode object.""",
-    "devdoc_missing": "Contract type: {0} is missing a devdoc field.",
-    "userdoc_missing": "Contract type: {0} is missing a userdoc field.",
-    "compilers_missing": "Manifest is missing a suggested `compilers` field.",
-}
-
-
-#
-# Validation
-#
-
-
-def check_manifest(manifest: Manifest) -> Dict[str, str]:
-    generate_warnings = (
-        check_manifest_version(manifest),
-        check_package_name(manifest),
-        check_version(manifest),
-        check_meta(manifest),
-        check_sources(manifest),
-        check_contract_types(manifest),
-        check_compilers(manifest),
-    )
-    return build({}, *generate_warnings)
-
-
-#
-# Required fields
-#
-
-
-@curry
-def check_manifest_version(
-    manifest: Manifest, warnings: Dict[str, str]
-) -> Dict[str, str]:
-    if "manifest" not in manifest or not manifest["manifest"]:
-        return assoc(warnings, "manifest", WARNINGS["manifest_missing"])
-    if manifest["manifest"] != "ethpm/3":
-        return assoc(warnings, "manifest", WARNINGS["manifest_invalid"])
-    return warnings
-
-
-@curry
-def check_package_name(manifest: Manifest, warnings: Dict[str, str]) -> Dict[str, str]:
-    if "name" not in manifest or not manifest["name"]:
-        return assoc(warnings, "name", WARNINGS["name_missing"])
-    if not bool(re.match(PACKAGE_NAME_REGEX, manifest["name"])):
-        return assoc(warnings, "name", WARNINGS["name_invalid"])
-    return warnings
-
-
-@curry
-def check_version(manifest: Manifest, warnings: Dict[str, str]) -> Dict[str, str]:
-    if "version" not in manifest or not manifest["version"]:
-        return assoc(warnings, "version", WARNINGS["version_missing"])
-    return warnings
-
-
-#
-# Meta fields
-#
-
-
-@curry
-def check_meta(manifest: Manifest, warnings: Dict[str, str]) -> Dict[str, str]:
-    if "meta" not in manifest or not manifest["meta"]:
-        return assoc(warnings, "meta", WARNINGS["meta_missing"])
-    meta_validation = (
-        check_authors(manifest["meta"]),
-        check_license(manifest["meta"]),
-        check_description(manifest["meta"]),
-        check_keywords(manifest["meta"]),
-        check_links(manifest["meta"]),
-    )
-    return build(warnings, *meta_validation)
-
-
-@curry
-def check_authors(meta: Dict[str, Any], warnings: Dict[str, str]) -> Dict[str, str]:
-    if "authors" not in meta:
-        return assoc(warnings, "meta.authors", WARNINGS["authors_missing"])
-    return warnings
-
-
-@curry
-def check_license(meta: Dict[str, Any], warnings: Dict[str, str]) -> Dict[str, str]:
-    if "license" not in meta or not meta["license"]:
-        return assoc(warnings, "meta.license", WARNINGS["license_missing"])
-    return warnings
-
-
-@curry
-def check_description(meta: Dict[str, Any], warnings: Dict[str, str]) -> Dict[str, str]:
-    if "description" not in meta or not meta["description"]:
-        return assoc(warnings, "meta.description", WARNINGS["description_missing"])
-    return warnings
-
-
-@curry
-def check_keywords(meta: Dict[str, Any], warnings: Dict[str, str]) -> Dict[str, str]:
-    if "keywords" not in meta or not meta["keywords"]:
-        return assoc(warnings, "meta.keywords", WARNINGS["keywords_missing"])
-    return warnings
-
-
-@curry
-def check_links(meta: Dict[str, Any], warnings: Dict[str, str]) -> Dict[str, str]:
-    if "links" not in meta or not meta["links"]:
-        return assoc(warnings, "meta.links", WARNINGS["links_missing"])
-    return warnings
-
-
-#
-# Sources
-#
-
-
-@curry
-def check_sources(manifest: Manifest, warnings: Dict[str, str]) -> Dict[str, str]:
-    if "sources" not in manifest or not manifest["sources"]:
-        return assoc(warnings, "sources", WARNINGS["sources_missing"])
-    return warnings
-
-
-#
-# Contract Types
-#
-
-
-# todo: validate a contract type matches source
-@curry
-def check_contract_types(
-    manifest: Manifest, warnings: Dict[str, str]
-) -> Dict[str, str]:
-    if "contractTypes" not in manifest or not manifest["contractTypes"]:
-        return assoc(warnings, "contractTypes", WARNINGS["contract_type_missing"])
-
-    all_contract_type_validations = (
-        (
-            check_abi(contract_name, data),
-            check_contract_type(contract_name, data),
-            check_deployment_bytecode(contract_name, data),
-            check_runtime_bytecode(contract_name, data),
-            check_devdoc(contract_name, data),
-            check_userdoc(contract_name, data),
-        )
-        for contract_name, data in manifest["contractTypes"].items()
-    )
-    return build(warnings, *sum(all_contract_type_validations, ()))
-
-
-@curry
-def check_abi(
-    contract_name: str, data: Dict[str, Any], warnings: Dict[str, str]
-) -> Dict[str, str]:
-    if "abi" not in data or not data["abi"]:
-        return assoc_in(
-            warnings,
-            ["contractTypes", contract_name, "abi"],
-            WARNINGS["abi_missing"].format(contract_name),
-        )
-    return warnings
-
-
-@curry
-def check_contract_type(
-    contract_name: str, data: Dict[str, Any], warnings: Dict[str, str]
-) -> Dict[str, str]:
-    if "contractType" not in data or not data["contractType"]:
-        return assoc_in(
-            warnings,
-            ["contractTypes", contract_name, "contractType"],
-            WARNINGS["contract_type_subfield_missing"].format(contract_name),
-        )
-    return warnings
-
-
-@curry
-def check_deployment_bytecode(
-    contract_name: str, data: Dict[str, Any], warnings: Dict[str, str]
-) -> Dict[str, str]:
-    if "deploymentBytecode" not in data or not data["deploymentBytecode"]:
-        return assoc_in(
-            warnings,
-            ["contractTypes", contract_name, "deploymentBytecode"],
-            WARNINGS["deployment_bytecode_missing"].format(contract_name),
-        )
-    return build(
-        warnings,
-        check_bytecode_object(contract_name, "deployment", data["deploymentBytecode"]),
-    )
-
-
-@curry
-def check_runtime_bytecode(
-    contract_name: str, data: Dict[str, Any], warnings: Dict[str, str]
-) -> Dict[str, str]:
-    if "runtimeBytecode" not in data or not data["runtimeBytecode"]:
-        return assoc_in(
-            warnings,
-            ["contractTypes", contract_name, "runtimeBytecode"],
-            WARNINGS["runtime_bytecode_missing"].format(contract_name),
-        )
-    return build(
-        warnings,
-        check_bytecode_object(contract_name, "runtime", data["runtimeBytecode"]),
-    )
-
-
-@curry
-def check_bytecode_object(
-    contract_name: str,
-    bytecode_type: str,
-    bytecode_data: Dict[str, Any],
-    warnings: Dict[str, str],
-) -> Dict[str, str]:
-    # todo: check if bytecode has link_refs & validate link_refs present in object
-    if "bytecode" not in bytecode_data or not bytecode_data["bytecode"]:
-        return assoc_in(
-            warnings,
-            ["contractTypes", contract_name, f"{bytecode_type}Bytecode"],
-            WARNINGS["bytecode_subfield_missing"].format(contract_name, bytecode_type),
-        )
-    return warnings
-
-
-@curry
-def check_devdoc(
-    contract_name: str, data: Dict[str, Any], warnings: Dict[str, str]
-) -> Dict[str, str]:
-    if "devdoc" not in data or not data["devdoc"]:
-        return assoc_in(
-            warnings,
-            ["contractTypes", contract_name, "devdoc"],
-            WARNINGS["devdoc_missing"].format(contract_name),
-        )
-    return warnings
-
-
-@curry
-def check_userdoc(
-    contract_name: str, data: Dict[str, Any], warnings: Dict[str, str]
-) -> Dict[str, str]:
-    if "userdoc" not in data or not data["userdoc"]:
-        return assoc_in(
-            warnings,
-            ["contractTypes", contract_name, "userdoc"],
-            WARNINGS["userdoc_missing"].format(contract_name),
-        )
-    return warnings
-
-
-@curry
-def check_compilers(manifest: Manifest, warnings: Dict[str, str]) -> Dict[str, str]:
-    if "compilers" not in manifest or not manifest["compilers"]:
-        return assoc(warnings, "compilers", WARNINGS["compilers_missing"])
-    return warnings

ethpm/tools/get_manifest.py

@@ -1,19 +0,0 @@
-import json
-from typing import (
-    Any,
-    Dict,
-)
-
-from ethpm import (
-    ASSETS_DIR,
-    get_ethpm_spec_dir,
-)
-
-
-def get_ethpm_spec_manifest(use_case: str, filename: str) -> Dict[str, Any]:
-    ethpm_spec_dir = get_ethpm_spec_dir()
-    return json.loads((ethpm_spec_dir / "examples" / use_case / filename).read_text())
-
-
-def get_ethpm_local_manifest(use_case: str, filename: str) -> Dict[str, Any]:
-    return json.loads((ASSETS_DIR / use_case / filename).read_text())

ethpm/uri.py

@@ -1,141 +0,0 @@
-import json
-from typing import (
-    TYPE_CHECKING,
-)
-
-from eth_typing import (
-    URI,
-)
-from eth_utils import (
-    encode_hex,
-    to_hex,
-)
-from eth_utils.toolz import (
-    curry,
-)
-import requests
-
-from ethpm._utils.backend import (
-    get_resolvable_backends_for_uri,
-    get_translatable_backends_for_uri,
-)
-from ethpm._utils.chains import (
-    BLOCK,
-    create_block_uri,
-    get_genesis_block_hash,
-    parse_BIP122_uri,
-)
-from ethpm._utils.ipfs import (
-    is_ipfs_uri,
-)
-from ethpm.backends.http import (
-    is_valid_api_github_uri,
-    is_valid_content_addressed_github_uri,
-)
-from ethpm.backends.registry import (
-    RegistryURIBackend,
-)
-from ethpm.exceptions import (
-    CannotHandleURI,
-)
-from web3.types import (
-    BlockNumber,
-)
-
-if TYPE_CHECKING:
-    from web3 import Web3  # noqa F401
-
-
-def resolve_uri_contents(uri: URI, fingerprint: bool = None) -> bytes:
-    resolvable_backends = get_resolvable_backends_for_uri(uri)
-    if resolvable_backends:
-        for backend in resolvable_backends:
-            try:
-                # type ignored to handle case if URI is returned
-                contents: bytes = backend().fetch_uri_contents(uri)  # type: ignore
-            except CannotHandleURI:
-                continue
-            return contents
-
-    translatable_backends = get_translatable_backends_for_uri(uri)
-    if translatable_backends:
-        if fingerprint:
-            raise CannotHandleURI(
-                "Registry URIs must point to a resolvable content-addressed URI."
-            )
-        package_id = RegistryURIBackend().fetch_uri_contents(uri)
-        return resolve_uri_contents(package_id, True)
-
-    raise CannotHandleURI(
-        f"URI: {uri} cannot be resolved by any of the available backends."
-    )
-
-
-def create_content_addressed_github_uri(uri: URI) -> URI:
-    """
-    Returns a content-addressed Github "git_url" that conforms to this scheme.
-    https://api.github.com/repos/:owner/:repo/git/blobs/:file_sha
-
-    Accepts Github-defined "url" that conforms to this scheme
-    https://api.github.com/repos/:owner/:repo/contents/:path/:to/manifest.json
-    """
-    if not is_valid_api_github_uri(uri):
-        raise CannotHandleURI(f"{uri} does not conform to Github's API 'url' scheme.")
-    response = requests.get(uri)
-    response.raise_for_status()
-    contents = json.loads(response.content)
-    if contents["type"] != "file":
-        raise CannotHandleURI(
-            "Expected url to point to a 'file' type, "
-            f"instead received {contents['type']}."
-        )
-    return contents["git_url"]
-
-
-def is_supported_content_addressed_uri(uri: URI) -> bool:
-    """
-    Returns a bool indicating whether provided uri is currently supported.
-    Currently Py-EthPM only supports IPFS and Github blob content-addressed uris.
-    """
-    if not is_ipfs_uri(uri) and not is_valid_content_addressed_github_uri(uri):
-        return False
-    return True
-
-
-def create_latest_block_uri(w3: "Web3", from_blocks_ago: int = 3) -> URI:
-    """
-    Creates a block uri for the given w3 instance.
-    Defaults to 3 blocks prior to the "latest" block to accommodate for block reorgs.
-    If using a testnet with less than 3 mined blocks, adjust :from_blocks_ago:.
-    """
-    chain_id = to_hex(get_genesis_block_hash(w3))
-    latest_block_tx_receipt = w3.eth.get_block("latest")
-    target_block_number = BlockNumber(
-        latest_block_tx_receipt["number"] - from_blocks_ago
-    )
-    if target_block_number < 0:
-        raise Exception(
-            f"Only {latest_block_tx_receipt['number']} blocks avaible on provided w3, "
-            f"cannot create latest block uri for {from_blocks_ago} blocks ago."
-        )
-    recent_block = to_hex(w3.eth.get_block(target_block_number)["hash"])
-    return create_block_uri(chain_id, recent_block)
-
-
-@curry
-def check_if_chain_matches_chain_uri(w3: "Web3", blockchain_uri: URI) -> bool:
-    chain_id, resource_type, resource_hash = parse_BIP122_uri(blockchain_uri)
-    genesis_block = w3.eth.get_block("earliest")
-
-    if encode_hex(genesis_block["hash"]) != chain_id:
-        return False
-
-    if resource_type == BLOCK:
-        resource = w3.eth.get_block(resource_hash)
-    else:
-        raise ValueError(f"Unsupported resource type: {resource_type}")
-
-    if encode_hex(resource["hash"]) == resource_hash:
-        return True
-    else:
-        return False

ethpm/validation/manifest.py

@@ -1,146 +0,0 @@
-from abc import (
-    ABCMeta,
-)
-import json
-from typing import (
-    Any,
-    Dict,
-    List,
-    Set,
-    cast,
-)
-
-from jsonschema import (
-    ValidationError as jsonValidationError,
-    validate,
-)
-from jsonschema.validators import (
-    Draft7Validator,
-    validator_for,
-)
-
-from ethpm import (
-    get_ethpm_spec_dir,
-)
-from ethpm.exceptions import (
-    EthPMValidationError,
-)
-
-META_FIELDS = {
-    "license": str,
-    "authors": list,
-    "description": str,
-    "keywords": list,
-    "links": dict,
-}
-
-
-def validate_meta_object(meta: Dict[str, Any], allow_extra_meta_fields: bool) -> None:
-    """
-    Validates that every key is one of `META_FIELDS`
-    and has a value of the expected type.
-    """
-    for key, value in meta.items():
-        if key in META_FIELDS:
-            if cast(ABCMeta, type(value)) is not META_FIELDS[key]:
-                raise EthPMValidationError(
-                    f"Values for {key} are expected to have the type "
-                    f"{META_FIELDS[key]}, instead got {type(value)}."
-                )
-        elif allow_extra_meta_fields:
-            if key[:2] != "x-":
-                raise EthPMValidationError(
-                    "Undefined meta fields need to begin with 'x-', "
-                    f"{key} is not a valid undefined meta field."
-                )
-        else:
-            raise EthPMValidationError(
-                f"{key} is not a permitted meta field. To allow undefined fields, "
-                "set `allow_extra_meta_fields` to True."
-            )
-
-
-def _load_schema_data() -> Dict[str, Any]:
-    ethpm_spec_dir = get_ethpm_spec_dir()
-    v3_schema_path = ethpm_spec_dir / "spec" / "v3.spec.json"
-    return json.loads(v3_schema_path.read_text())
-
-
-def extract_contract_types_from_deployments(deployment_data: List[Any]) -> Set[str]:
-    contract_types = {
-        deployment["contractType"]
-        for chain_deployments in deployment_data
-        for deployment in chain_deployments.values()
-    }
-    return contract_types
-
-
-def validate_manifest_against_schema(manifest: Dict[str, Any]) -> None:
-    """
-    Load and validate manifest against schema
-    located at v3_schema_path.
-    """
-    schema_data = _load_schema_data()
-    try:
-        validate(manifest, schema_data, cls=validator_for(schema_data, Draft7Validator))
-    except jsonValidationError as e:
-        raise EthPMValidationError(
-            f"Manifest invalid for schema version {schema_data['version']}. "
-            f"Reason: {e.message}"
-            f"{e}"
-        )
-
-
-def check_for_deployments(manifest: Dict[str, Any]) -> bool:
-    if "deployments" not in manifest or not manifest["deployments"]:
-        return False
-    return True
-
-
-def validate_build_dependencies_are_present(manifest: Dict[str, Any]) -> None:
-    if "buildDependencies" not in manifest:
-        raise EthPMValidationError("Manifest doesn't have any build dependencies.")
-
-    if not manifest["buildDependencies"]:
-        raise EthPMValidationError("Manifest's build dependencies key is empty.")
-
-
-def validate_manifest_deployments(manifest: Dict[str, Any]) -> None:
-    """
-    Validate that a manifest's deployments contracts reference existing contractTypes.
-    """
-    if {"contractTypes", "deployments"}.issubset(manifest):
-        all_contract_types = manifest["contractTypes"].keys()
-        all_deployments = manifest["deployments"].values()
-        all_deployment_names = extract_contract_types_from_deployments(all_deployments)
-        missing_contract_types = all_deployment_names.difference(all_contract_types)
-        if missing_contract_types:
-            raise EthPMValidationError(
-                f"Manifest missing references to contracts: {missing_contract_types}."
-            )
-
-
-def validate_raw_manifest_format(raw_manifest: str) -> None:
-    """
-    Raise a EthPMValidationError if a manifest ...
-    - is not tightly packed (i.e. no linebreaks or extra whitespace)
-    - does not have alphabetically sorted keys
-    - has duplicate keys
-    - is not UTF-8 encoded
-    - has a trailing newline
-    """
-    try:
-        manifest_dict = json.loads(raw_manifest)
-    except json.JSONDecodeError as err:
-        raise json.JSONDecodeError(
-            "Failed to load package data. File is not a valid JSON document.",
-            err.doc,
-            err.pos,
-        )
-    compact_manifest = json.dumps(manifest_dict, sort_keys=True, separators=(",", ":"))
-    if raw_manifest != compact_manifest:
-        raise EthPMValidationError(
-            "The manifest appears to be malformed. Please ensure that it conforms to "
-            "the EthPM-Spec for document format. "
-            "http://ethpm.github.io/ethpm-spec/package-spec.html#document-format "
-        )

ethpm/validation/misc.py

@@ -1,39 +0,0 @@
-from urllib import (
-    parse,
-)
-
-from ethpm.exceptions import (
-    EthPMValidationError,
-)
-from web3 import (
-    Web3,
-)
-
-
-def validate_w3_instance(w3: "Web3") -> None:
-    if w3 is None or not isinstance(w3, Web3):
-        raise ValueError("Package does not have valid web3 instance.")
-
-
-def validate_empty_bytes(offset: int, length: int, bytecode: bytes) -> None:
-    """
-    Validates that segment [`offset`:`offset`+`length`] of
-    `bytecode` is comprised of empty bytes (b'\00').
-    """
-    slot_length = offset + length
-    slot = bytecode[offset:slot_length]
-    if slot != bytearray(length):
-        raise EthPMValidationError(
-            f"Bytecode segment: [{offset}:{slot_length}] "
-            f"is not comprised of empty bytes, rather: {slot!r}."
-        )
-
-
-def validate_escaped_string(string: str) -> None:
-    unsafe = parse.unquote(string)
-    safe = parse.quote(unsafe)
-    if string != safe:
-        raise EthPMValidationError(
-            f"String: {string} is not properly escaped, and contains url "
-            "unsafe characters."
-        )