def validate_same_registry(left: str, right: str) -> None:
left_uri = parse_registry_uri(left)
right_uri = parse_registry_uri(right)
if (not is_same_address(left_uri.address, right_uri.address)
or left_uri.chain_id != right_uri.chain_id # noqa: W503
):
raise ValidationError(
f"Registry URI: {left} does not match the registry found on URI: {right}."
)
def test_parse_registry_uri(uri, expected):
address, chain_id, pkg_name, pkg_version, namespaced_asset, ens = parse_registry_uri(uri)
assert address == expected[0]
assert chain_id == expected[1]
assert pkg_name == expected[2]
assert pkg_version == expected[3]
assert namespaced_asset == expected[4]
def generate_registry_store_data(registry_uri: URI,
alias: Optional[str],
activate: bool = False) -> Dict[str, Any]:
parsed_uri = parse_registry_uri(registry_uri)
# todo: support ens in registry uri
return {
"ens": None,
"address": parsed_uri.address,
"alias": alias,
"active": activate,
}
def test_registry_uri_supports_ens_domains(backend):
valid_uri = "erc1319://defi.snakecharmers.eth:1/[email protected]"
parsed = parse_registry_uri(valid_uri)
expected_uri = 'ipfs://QmYvsyuxjj9mKmCvn3jrdfnaHYwFsyHXUu7kETrN4dBhE6'
assert backend.can_translate_uri(valid_uri) is True
assert backend.can_resolve_uri(valid_uri) is False
assert backend.fetch_uri_contents(valid_uri) == expected_uri
assert parsed.address == "0xA635F17288187daE5b424D343E21FF44a79ce922"
assert parsed.ens == "defi.snakecharmers.eth"
assert parsed.chain_id == '1'
assert parsed.name == "compound"
assert parsed.version == "1.0.0"
def resolve_install_uri(args: Namespace) -> ResolvedInstallURI:
registry_backend = RegistryURIBackend()
etherscan_backend = EtherscanURIBackend()
if etherscan_backend.can_translate_uri(args.uri):
manifest_uri = etherscan_backend.fetch_uri_contents(
args.uri, args.package_name, args.package_version)
registry_address = None
elif registry_backend.can_translate_uri(args.uri):
registry_address, _, _, _, _, _ = parse_registry_uri(args.uri)
manifest_uri = registry_backend.fetch_uri_contents(args.uri)
else:
manifest_uri = args.uri
registry_address = None
return ResolvedInstallURI(manifest_uri, registry_address)
def release_package(package_name: str, version: str, manifest_uri: URI,
config: Config) -> bytes:
if not config.private_key:
raise AuthorizationError(
"To release a package you must provide the password for your local keyfile."
)
registry_store_path = config.xdg_ethpmcli_root / REGISTRY_STORE
active_registry = get_active_registry(registry_store_path)
parsed_uri = parse_registry_uri(active_registry.uri)
if config.w3.net.version != parsed_uri.chain_id:
w3 = setup_w3(to_int(text=parsed_uri.chain_id), config.private_key)
else:
w3 = config.w3
w3.pm.set_registry(parsed_uri.address)
release_id = w3.pm.release_package(package_name, version, manifest_uri)
return release_id
def test_parse_registry_uri(uri, expected):
address, pkg_name, pkg_version = parse_registry_uri(uri)
assert address == expected[0]
assert pkg_name == expected[1]
assert pkg_version == expected[2]
def test_invalid_registry_uris(uri):
with pytest.raises(EthPMValidationError):
parse_registry_uri(uri)
def update_package(args: Namespace, config: Config) -> None:
if not is_package_installed(args.package, config):
check_for_aliased_package(args.package, config)
return
installed_package = resolve_installed_package_by_id(args.package, config)
active_registry = get_active_registry(config.xdg_ethpmcli_root /
REGISTRY_STORE)
if is_valid_registry_uri(installed_package.install_uri):
validate_same_registry(installed_package.install_uri,
active_registry.uri)
connected_chain_id = config.w3.eth.chainId
active_registry_uri = parse_registry_uri(active_registry.uri)
if not to_int(text=active_registry_uri.chain_id) == connected_chain_id:
raise InstallError(
f"Registry URI chain: {active_registry_uri.chain_id} doesn't match "
f"connected web3: {connected_chain_id}.")
config.w3.pm.set_registry(active_registry_uri.address)
all_package_names = config.w3.pm.get_all_package_names()
if installed_package.resolved_package_name not in all_package_names:
raise InstallError(
f"{installed_package.resolved_package_name} is not available on the active registry "
f"{active_registry.uri}. Available packages include: {all_package_names}."
)
all_release_data = config.w3.pm.get_all_package_releases(
installed_package.resolved_package_name)
all_versions = [version for version, _ in all_release_data]
if installed_package.resolved_version not in all_versions:
raise InstallError(
f"{installed_package.resolved_package_name}@{installed_package.resolved_version} not "
f"found on the active registry {active_registry.uri}.")
on_chain_install_uri = pluck_release_data(
all_release_data, installed_package.resolved_version)
if on_chain_install_uri != installed_package.resolved_uri:
raise InstallError(
f"Install URI found on active registry for {installed_package.resolved_package_name}@"
f"{installed_package.resolved_version}: {on_chain_install_uri} does not match the "
f"install URI found in local lockfile: {installed_package.resolved_uri}."
)
cli_logger.info(
f"{len(all_versions)} versions of {installed_package.resolved_package_name} "
f"found: {all_versions} \n"
f"On the active registry: {active_registry.uri}")
count = 0
while True:
count += 1
target_version = input(
"Please enter the version you want to install. ")
if count > 5:
raise InstallError("Max attempts (5) reached. ")
elif target_version == installed_package.resolved_version:
cli_logger.info(f"Version already installed: {target_version}. ")
elif target_version not in all_versions:
cli_logger.info(f"Version unavailable: {target_version}. ")
else:
break
# Create an updated args/Package for new install
updated_args = copy.deepcopy(args)
if installed_package.resolved_package_name != args.package:
updated_args.alias = args.package
updated_args.uri = pluck_release_data(all_release_data, target_version)
updated_args.package_version = target_version
updated_package = Package(updated_args, config.ipfs_backend)
# atomic replace
with tempfile.TemporaryDirectory() as tmpdir:
tmp_ethpm_dir = Path(tmpdir) / ETHPM_PACKAGES_DIR
shutil.copytree(config.ethpm_dir, tmp_ethpm_dir)
tmp_config = copy.copy(config)
tmp_config.ethpm_dir = tmp_ethpm_dir
uninstall_package(args.package, tmp_config)
install_package(updated_package, tmp_config)
shutil.rmtree(config.ethpm_dir)
tmp_ethpm_dir.replace(config.ethpm_dir)
cli_logger.info(f"{updated_args.package} successfully updated to version "
f"{updated_args.package_version}.")
