serializeMediaMetadata function

Uint8List serializeMediaMetadata(MediaMetadata m)

Implementation

Uint8List serializeMediaMetadata(
  MediaMetadata m,
  /* List<KeyPairEd25519> keyPairs = const [],
  required CryptoImplementation crypto, */
) {
  final c = Packer();
  c.packInt(metadataTypeMedia);

  c.packListLength(6);

  c.packString(m.name);
  c.pack(m.details.data);

  c.packListLength(m.parents.length);
  for (final parent in m.parents) {
    c.pack({
      0: parent.type,
      1: parent.cid.toBytes(),
    });
  }
  // }

  c.packMapLength(m.mediaTypes.length);
  for (final e in m.mediaTypes.entries) {
    c.packString(e.key);
    c.pack(e.value);
  }

  if (m.links == null) {
    c.packMapLength(0);
  } else {
    c.pack(m.links!.encode());
  }

  c.pack(m.extraMetadata.data);

  final bodyBytes = c.takeBytes();

  return Uint8List.fromList([metadataMagicByte] + bodyBytes);
/*
  if (keyPairs.isEmpty) {
    return Uint8List.fromList([metadataMagicByte] + bodyBytes);
  }

  final b3hash = Uint8List.fromList(
    [mhashBlake3Default] + (await crypto.hashBlake3(bodyBytes)),
  );

  final proofPacker = Packer();

  proofPacker.packListLength(keyPairs.length);

  for (final kp in keyPairs) {
    final signature = await crypto.signEd25519(
      kp: kp,
      message: b3hash,
    );
    proofPacker.pack([
      metadataProofTypeSignature,
      mhashBlake3Default,
      kp.publicKey,
      signature,
    ]);
  }
  final proofBytes = proofPacker.takeBytes();

  final header = [
        metadataMagicByte,
        metadataTypeProofs,
      ] +
      encodeEndian(proofBytes.length, 2);

  return Uint8List.fromList(header + proofBytes + bodyBytes); */
}