docs: def _verify_multi(self, token, verifying_keys, num_required=None):
          """
          Verify a JSON-formatted JWT signed by multiple keys is authentic.
          Optionally set a threshold of required valid signatures with num_required.
          Return True if valid
          Return False if not
  
          TODO: support multiple types of keys
          """
          headers, payload, raw_signatures, signing_inputs = _unpack_token_json(token)
          if num_required is None:
              num_required = len(raw_signatures)
  
          if num_required > len(verifying_keys):
              # not possible
              return False
  
          if len(headers) != len(raw_signatures):
              # invalid 
              raise DecodeError('Header/signature mismatch')
  
          verifying_keys = [load_verifying_key(vk, self.crypto_backend) for vk in verifying_keys]
  
          # sanity check: only support one type of key :(
          for vk in verifying_keys:
              if vk.curve.name != verifying_keys[0].curve.name:
                  raise DecodeError("TODO: only support using keys from one curve per JWT")
                  
          der_signatures = [raw_to_der_signature(rs, verifying_keys[0].curve) for rs in raw_signatures]
  
          # verify until threshold is met
          num_verified = 0
          for (signing_input, der_sig) in zip(signing_inputs, der_signatures):
              for vk in verifying_keys:
                  verifier = self._get_verifier(vk, der_sig)
                  verifier.update(signing_input)
                  try:
                      verifier.verify()
                      num_verified += 1
                      verifying_keys.remove(vk)
                      break
                  except InvalidSignature:
                      pass
  
              if num_verified >= num_required:
                  break
  
          return (num_verified >= num_required)