kord-network / kord.js Goto Github PK

/**
 * Get the sub-property of a META Identity Profile Claim from the claim's property
 *
 * @example getProfileClaimSubPropertyFromProperty('profile.name') // => 'name'
 *
 * @param  {String} property Profile claim property
 * @return {String}          Profile claim sub-property
 */
export const getProfileClaimSubPropertyFromProperty = property => {
  return property.replace(new RegExp(`${PROFILE_CLAIM_PREFIX}.`, 'i'), '')
}

/**
 * Utility function to create a valid META Claim object to verify a new claim
 *
 * @param  {Object} account            Ethereum account object
 * @param  {String} account.address    Account Ethereum address
 * @param  {String} account.privateKey Account private key
 * @param  {Object} claimMessage       Raw claim message
 * @param  {String} subject            META-ID `id` of subject (hash of `username`)
 * @param  {Object} extraData          Any extra properties to add to claim object
 * @return {Object}                    META Claim object
 */
export const createVerifiableIdentityClaimObject = (
  account,
  claimMessage,
  subject,
  extraData = {}
) => {
  return {
    address: account.address,
    claimHash: bufferToHex(sha3(claimMessage)),
    claimMessage: claimMessage,
    subject: subject,
    signature: accounts.signMessage(claimMessage, account.privateKey),
    ...extraData,
  }
}

ClaimInput: {
  claim, // raw claim value
  issuer, // META-ID `id` of issuer
  property, // claim key
  signature, // claim signed by issuer
  subject, // META-ID `id` of subject
}

export const createVerifiedIdentityClaimObject = (claimMessage, subject) => {
  // META Claims Service config
  const metaClaimsService = {
    ... // from somewhere
  }

  // set the claim value being verified
  const verifiedClaimValue = claimMessage // raw claim value

  // generate verified claim buffer
  const verifiedClaimBuffer = sha3(Buffer.concat([
    toBuffer(metaClaimsService.id), // issuer ID
    toBuffer(subject), // subject ID
    toBuffer(metaClaimsService.property), // claim key
    toBuffer(verifiedClaimValue), // claim value
  ]))

  // generate ECDSA signature of verified claim buffer using the MCS private key
  const verifiedClaimSignatureObject = ecsign(
    verifiedClaimBuffer,
    Buffer.from(metaClaimsService.privateKey, 'hex')
  )

  // convert ECDSA signature buffer to hex value
  const verifiedClaimSignature = toRpcSig(
    verifiedClaimSignatureObject.v,
    verifiedClaimSignatureObject.r,
    verifiedClaimSignatureObject.s
  )

  // return response body
  return {
    claim: verifiedClaimValue,
    issuer: metaClaimsService.id,
    property: metaClaimsService.property,
    signature: verifiedClaimSignature,
    subject: subject,
  }
}

import replace from 'rollup-plugin-replace'

const pkg = require('./package.json')

plugins: [
  replace({
    values: {
      RPC: JSON.stringify(process.env.RPC),
      VERSION: JSON.stringify(pkg.version),
    },
  }),
  ...
]

export {
  ...,
  version: VERSION,
}

/**
 * Create a valid META Identity Claim object for a profile claim
 * This is a self-issued claim, usually referencing a Swarm hash of profile data
 *
 * @param  {String} claimMessage      Raw identity claim message
 * @param  {Object} issuer            Claim issuer data object
 * @param  {String} issuer.id         META Identity `id` of claim issuer
 * @param  {String} issuer.privateKey Private key of claim issuer
 * @param  {String} subProperty       Type of profile claim contained in `claimMessage`
 * @return {Object}                   Verified META Identity Claim object
 */
export const createProfileMetaIdentityClaim = (
  claimMessage,
  issuer,
  subProperty
) => {
  return createVerifiedIdentityClaimObject(
    claimMessage,
    {
      id: issuer.id,
      privateKey: issuer.privateKey,
      property: `profile.${subProperty}`,
    },
    issuer.id
  )
}

/**
 * Check if a META Identity claim is a profile claim
 *
 * @param  {Object}  claim META Identity Claim object
 * @return {Boolean}       Profile claim boolean
 */
export const isProfileClaim = claim => {
  return claim.property.startsWith(`${PROFILE_CLAIM_PREFIX}.`)
}

export const createProfileMetaIdentityClaim = (account, claim, subProperty) => {
  return {
    claim: claim, // Swarm hash
    issuer: account.address, // self-issued claim
    property: `profile.${subProperty}`, // eg. `profile.image`
    signature: signMessage(claim, account.privateKey),
    subject: account.address,
  }
}