def METHOD_NAME(cls,
                       target_ursula: Ursula,
                       substitute_verifying_key: bool = False,
                       sign_metadata: bool = False,
                       ) -> 'Vladimir':
    """
    Sometimes Vladimir seeks to attack or imitate a *specific* target Ursula.
    TODO: This is probably a more instructive method if it takes a bytes representation instead of the entire Ursula.
    """
    try:
        from tests.utils.middleware import EvilMiddleWare
    except ImportError:
        raise DevelopmentInstallationRequired(importable_name='tests.utils.middleware.EvilMiddleWare')
    cls.network_middleware = EvilMiddleWare(eth_provider_uri=TEST_ETH_PROVIDER_URI)
    crypto_power = CryptoPower(power_ups=target_ursula._default_crypto_powerups)
    blockchain = target_ursula.application_agent.blockchain
    cls.attach_transacting_key(blockchain=blockchain)
    # Vladimir does not care about payment.
    bogus_payment_method = FreeReencryptions()
    bogus_payment_method.provider = Mock()
    bogus_payment_method.agent = Mock()
    bogus_payment_method.network = TEMPORARY_DOMAIN
    bogus_payment_method.agent.blockchain.client.chain_id = TESTERCHAIN_CHAIN_ID
    mock.patch(
        "mock.interfaces.MockBlockchain.client.chain_id",
        new_callable=mock.PropertyMock(return_value=TESTERCHAIN_CHAIN_ID),
    )
    vladimir = cls(is_me=True,
                   crypto_power=crypto_power,
                   domain=TEMPORARY_DOMAIN,
                   rest_host=target_ursula.rest_interface.host,
                   rest_port=target_ursula.rest_interface.port,
                   certificate=target_ursula.certificate,
                   network_middleware=cls.network_middleware,
                   checksum_address=cls.fraud_address,
                   operator_address=cls.fraud_address,
                   signer=Web3Signer(blockchain.client),
                   eth_provider_uri=blockchain.eth_provider_uri,
                   payment_method=bogus_payment_method,
                   )
    # Let's use the target's public info, and try to make some changes.
    metadata = target_ursula.metadata()
    metadata_bytes = bytes(metadata)
    # Since it is an object from a Rust extension, we cannot directly modify it,
    # so we have to replace stuff in the byte representation and then deserialize.
    # We are replacing objects with constant size,
    # so it should work regardless of the binary format.
    # Our basic replacement. We want to impersonate the target Ursula.
    metadata_bytes = metadata_bytes.replace(bytes(metadata.payload.staking_provider_address),
                                            vladimir.canonical_address)
    # Use our own verifying key
    if substitute_verifying_key:
        metadata_bytes = metadata_bytes.replace(
            metadata.payload.verifying_key.to_compressed_bytes(),
            vladimir.stamp.as_umbral_pubkey().to_compressed_bytes(),
        )
    fake_metadata = NodeMetadata.from_bytes(metadata_bytes)
    # Re-generate metadata signature using our signing key
    if sign_metadata:
        fake_metadata = NodeMetadata(vladimir.stamp.as_umbral_signer(), fake_metadata.payload)
    # Put metadata back
    vladimir._metadata = fake_metadata
    return vladimir