How to use the multihashes.encode function in multihashes

const payloadToHash = (payload) => {
  const encodedPayload = encodeJson(payload);
  const encodedOperationPayloadBuffer = Buffer.from(encodedPayload);
  const hash = crypto
    .createHash('sha256')
    .update(encodedOperationPayloadBuffer)
    .digest();
  const hashAlgorithmName = multihashes.codes[18]; // 18 is code for sha256
  const multihash = multihashes.encode(hash, hashAlgorithmName);
  const encodedMultihash = base64url.encode(multihash);
  return encodedMultihash;
};

const payloadToHash = (payload) => {
  const encodedPayload = encodeJson(payload);
  const encodedOperationPayloadBuffer = Buffer.from(encodedPayload);
  const hash = crypto
    .createHash('sha256')
    .update(encodedOperationPayloadBuffer)
    .digest();
  const hashAlgorithmName = multihashes.codes[18]; // 18 is code for sha256
  const multihash = multihashes.encode(hash, hashAlgorithmName);
  const encodedMultihash = base64url.encode(multihash);
  return encodedMultihash;
};

function cidFromHash (codec, rawhash, options) {
  // `CID` expects a string for the multicodec
  const codecName = multicodec.print[codec]
  options = options || {}
  const hashAlg = options.hashAlg || 'keccak-256'
  const version = typeof options.version === 'undefined' ? 1 : options.version
  const multihash = multihashes.encode(rawhash, hashAlg)
  return new CID(version, codecName, multihash)
}

MetadataService.prototype.pathToCID = (path: string): Object => {
  const parts = path.split('/')
  const data = Buffer.from(parts.shift(), 'hex')
  const mh = multihash.encode(data, 'sha3-256')
  const cid = new CID(version, codec, mh)
  const remPath = parts.join('/')
  return { cid, remPath }
}

MetadataService.prototype.pathToCID = (path) => {
    const parts = path.split('/')
    const data = Buffer.from(parts.shift(), 'hex')
    const mh = multihash.encode(data, 'sha3-256')
    const cid = new CID(version, codec, mh)
    const remPath = parts.join('/')
    return {
        cid,
        remPath
    }
}

crypto.subtle.digest("SHA-256", evt.raw).then((digest) => {
      let mh = multihash.encode(Buffer.from(digest), "sha2-256")
      cb({multihash: mh, links: evt.links, data: evt.data})
    }).catch((err) => { cb(null, err) })
  }

cid: (tx: Object, tasks: Object, t: number, i?: number) => {
    try {
      const mh = multihash.encode(hashTx(tx), 'sha3-256')
      const cid = new CID(version, codec, mh)
      tasks.run(t, cid, i)
    } catch(err) {
      tasks.error(err)
    }
  },

cid: (tx, tasks, t, i) => {
        try {
            const mh = multihash.encode(hashTx(tx), 'sha3-256')
            const cid = new CID(version, codec, mh)
            tasks.run(t, cid, i)
        } catch (err) {
            tasks.error(err)
        }
    },

const t1 = tasks.add(data => {
            try {
                const mh = multihash.encode(sha2_256(data), 'sha2-256')
                const cid = new CID(version, codec, mh)
                tasks.run(t, cid, data, i)
            } catch (err) {
                tasks.error(err)
            }
        })
        serialize(elem, tasks, t1)

exports.serialize(obj, (err, data) => {
    if (err) {
      return cb(err)
    }
    try {
      const mh = multihash.encode(sha2_256(data), 'sha2-256')
      const cid = new CID(exports.version, exports.codec, mh)
      cb(null, cid, data)
    } catch (err) {
      cb(err)
    }
  })
}