public bool TryRead(out AuditTrailRecord token)
 {
     token = default !;
        public async Task StoreAsync(AuditTrailRecord record, CancellationToken cancellationToken)
        {
            var hash = new byte[Sha256.Sha256HashSize];

            Sha256.Shared.ComputeHash(record.Raw.Span, hash);
            SignedTreeHead?signedTreeHead = null;

            if (_tree != null)
            {
                signedTreeHead = await _tree.AppendAsync(hash);
            }

            var payload = record.Token.Payload !;

            // Is it posible to fail here ?
            MemoryMarshal.TryGetArray(record.Raw, out var segment);
            var block = new AuditTrailBlock
                        (
                iss: payload[JwtClaimNames.Iss.EncodedUtf8Bytes].GetString() !,
                jti: payload[JwtClaimNames.Jti.EncodedUtf8Bytes].GetString() !,
                iat: payload[JwtClaimNames.Iat.EncodedUtf8Bytes].GetInt64(),
                aud: payload[JwtClaimNames.Aud.EncodedUtf8Bytes].GetStringArray() !,
                txn: payload[SecEventClaimNames.Txn].GetString(),
                toe: payload[SecEventClaimNames.Toe].GetInt64(),
                events: payload[SecEventClaimNames.Events.EncodedUtf8Bytes].GetJsonDocument(),
                raw: segment.Array !,
                hash: hash,
                rootHash: signedTreeHead?.Hash
                        );

            using var session = await _client.StartSessionAsync(cancellationToken : cancellationToken);

            try
            {
                session.StartTransaction();
                await _auditTrails.InsertOneAsync(block, cancellationToken : cancellationToken);

                //var kid = record.Token.Header[JwtHeaderParameterNames.Kid.EncodedUtf8Bytes].GetString()!;
                //if (!_keyringInMemory.HasKey(kid))
                //{
                //    var filter = Builders<Keyring>.Filter.Eq("keys.kid", kid);
                //    var storedKey = await _keyring.Find(filter).FirstOrDefaultAsync(cancellationToken);
                //    if (storedKey is null)
                //    {
                //        var key = SerializeKey(record.Token.SigningKey!);
                //        var jwksFilter = Builders<Keyring>.Filter.Eq("iss", record.Issuer);
                //        var push = Builders<Keyring>.Update.Push("keys", key)
                //            .SetOnInsert("iss", record.Issuer);
                //        await _keyring.UpdateOneAsync(jwksFilter, push, new UpdateOptions { IsUpsert = true }, cancellationToken);
                //    }
                //}

                await session.CommitTransactionAsync(cancellationToken);
            }
            catch (MongoWriteException e) when(e.WriteError.Category == ServerErrorCategory.DuplicateKey)
            {
                _logger.LogWarning("Duplicate document. The document will be ignored.");
                await session.AbortTransactionAsync();
            }
            catch (Exception e)
            {
                _logger.LogError(e, "Failed to store the document.");
                await session.AbortTransactionAsync();
            }

            _logger.LogInformation("'{Jti}' has been recorded.", block.Jti);
        }