/* 前略 */

/* for all of these, the first element will come from the database,
   the second from the request */

typedef struct _merge_state
{
  /* statistics */
  int new_sigs;
  int repl_sigs;
  int new_userids;
  int changed_primary_userids;
  int new_revocations;
  int new_pubkeys;
  int not_changed_revocation_sig;
  /* added stuff */
  int save_add;
  llist add_keys;
  llist add_userids;
  llist add_sigs;
  xbuffer *add_xb;
  /* verbose printing state */
  int verbose;
  keys_elem *this_ke;
  unsigned char *this_userid;
  int this_userid_len;
}
merge_state;

/* 中略 */

/* this function has the potential problem that if there are two keys
   out there with the same keyid, if both of them have signatures,
   they are indistinguishable without access to the public keys.  Even
   then, the only way to tell is to attempt to verify the signature
   with each public key to see if that is, in fact, the correct public
   key.  And even then, you can't ever decide that a signature is
   invalid, because you could just be missing the public key.  This
   seems to be a fundamental flaw in the keyring packet formats. */

int
kd_sigs_elem_merge (llist * lout, void *e1, void *e2, void *c)
{
/* 中略 */
}

/* 中略 */

int
kd_userids_elem_merge (llist * lout, void *e1, void *e2, void *c)
{
/* 中略 */

  o = sigs_elem_order (e1, e2);

  /* if the sig keyids are different, move the smaller keyid
     to the output list */

/* 中略 */

  /* if the sig keyids are the same, move the more recent signature
     to the output list and delete the less recent.  If they are
     the same, take the database sig so the stats work out right */

  if (se1->sig_time >= se2->sig_time)
    {
      if (!llist_add (lout, e1))
        {
          dabort ();
          return (LLIST_MERGE_FAIL);
        }
      sigs_elem_free (se2, NULL);
    }
  else
    {
/* 中略 */

}

/* 後略 */

            verifications = await doip.claims.verify(keyData, fingerprint, doipOpts)

const process = (publicKey) => {
  return new Promise(async (resolve, reject) => {
    if (!publicKey) {
      reject('Invalid public key')
    }
    const fingerprint = await publicKey.primaryKey.getFingerprint()
    const primaryUser = await publicKey.getPrimaryUser()
    const users = publicKey.users
    let primaryUserIndex,
      usersOutput = []

    users.forEach((user, i) => {
      usersOutput[i] = {
        userData: {
          id: user.userId ? user.userId.userid : null,
          name: user.userId ? user.userId.name : null,
          email: user.userId ? user.userId.email : null,
          comment: user.userId ? user.userId.comment : null,
          isPrimary: primaryUser.index === i,
        },
      }

      if ('selfCertifications' in user && user.selfCertifications.length > 0) {
        const notations = user.selfCertifications[0].rawNotations 
        // このuser.selfCertificationsには無効になったものも含まれるが、そのうち最初のもののみを取り上げている
        usersOutput[i].notations = notations.map(
          ({ name, value, humanReadable }) => {
            if (humanReadable && name === 'proof@metacode.biz') {
              return openpgp.util.decode_utf8(value)
            }
          }
        )
      } else {
        usersOutput[i].notations = []
      }
    })

    resolve({
      fingerprint: fingerprint,
      users: usersOutput,
      primaryUserIndex: primaryUser.index,
    })
  })
}

  for (let i = 0; i < packetlist.length; i++) {
    switch (packetlist[i].tag) {
  :
      case enums.packet.signature:
        switch (packetlist[i].signatureType) {
          case enums.signature.cert_generic:
          case enums.signature.cert_persona:
          case enums.signature.cert_casual:
          case enums.signature.cert_positive:
            if (!user) {
              util.print_debug('Dropping certification signatures without preceding user packet');
              continue;
            }
            if (packetlist[i].issuerKeyId.equals(primaryKeyId)) {
              user.selfCertifications.push(packetlist[i]);
            } else {
              user.otherCertifications.push(packetlist[i]);
            }
            break;
  :