Not if you just do leading zeroes or just lowest value when interpreting as a very large integer.
To make things easier, let's just assume that you use compact signatures which are just the signature's
s values concatenated with each other instead of other signature formats which have additional surrounding formatting bytes that would interfere with a direct comparison.
The compact signature format just concatenates the
R and the
s values. However this would be a trivially broken PoW scheme as soon as one person found a valid PoW, and that person would always be the winner. This is because the
R value is just the X coordinate of a nonce which is multiplied by the curve's generator point. If someone finds a
R value that works with the PoW, they can just keep reusing that nonce and always have the same valid R value. So this is obviously broken.
But if you were smarter about what is compared for the PoW by instead checking that the
s value is lower than the target. The
s value is computed using a formula which includes the nonce, the message hash, and the private key. In Schnorr, there are also multiple hashes and EC Curve point multiplications, which help to make it more random. So
s should be pseudorandom.
But there are some other issues with a signature based PoW, although these are more directed at ECDSA specifically rather than signatures in general.
The public key to verify against must be known, and must be known to be "correct". This means that you can't just have each person participating in the PoW provide their own public key, it needs to be some fixed public key, and everyone has to know the private key.
This is because, given an ECDSA signature and a message, you can compute a public key that would validate that signature and message combo. This is why it is important that the public key is known before validating the signature. Note that this is not possible for the proposed Schnorr signature scheme as it is not possible to do public key recovery with it.
The message that is verified must be published and hash. That's pretty obvious as it's a crucial part of any PoW algorithm. But specifically with ECDSA, given a signature and a public key, you can compute a message hash that would would result in a valid signature. This is why it is important that the message is something that is hashed and not just the value that gets put into the signature algorithm. This shouldn't be possible with the Schnor signatures.
So you could use signatures as a PoW so long as you are checking
s and not
R for the actual PoW check. And I would suggest that you use Schnorr signatures rather than ECDSA.