NeuroFeaturesProcessor.cs

using SkiaSharp;
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Html;
using Waher.Content.Markdown;
using Waher.Content.Markdown.Contracts;
using Waher.Content.Markdown.Wpf;
using Waher.Content.Markdown.Xamarin;
using Waher.Content.Xml;
using Waher.Events;
using Waher.IoTGateway;
using Waher.IoTGateway.Setup;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP.Server;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Cache;
using Waher.Runtime.Counters;
using Waher.Runtime.Threading;
using Waher.Script;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Security;
using Waher.Service.IoTBroker.EDaler;
using Waher.Service.IoTBroker.Legal;
using Waher.Service.IoTBroker.Legal.Attachments;
using Waher.Service.IoTBroker.Legal.Contracts;
using Waher.Service.IoTBroker.Marketplace;
using Waher.Service.IoTBroker.NeuroFeatures.Events;
using Waher.Service.IoTBroker.NeuroFeatures.TagReferences;
using Waher.Service.IoTBroker.NeuroFeatures.Tags;
using Waher.Service.IoTBroker.Paiwise;
using Waher.Service.IoTBroker.StateMachines;
using Waher.Service.IoTBroker.Synchronization;
 
namespace Waher.Service.IoTBroker.NeuroFeatures
{
    public static class NeuroFeaturesProcessor
    {
        public const string NeuroFeaturesNamespace = "https://paiwise.tagroot.io/Schema/NeuroFeatures.xsd";
 
        private static readonly Cache<CaseInsensitiveString, Token> tokenCache =
            new Cache<CaseInsensitiveString, Token>(int.MaxValue, TimeSpan.MaxValue, TimeSpan.FromHours(1));
 
        #region Smart Contract interface
 
        #region General
 
        internal static async Task ContractSigned(Contract Contract, bool ContractIsLocked,
            Dictionary<CaseInsensitiveString, Parameter> TransientParameters,
            LegalComponent Legal, EDalerComponent EDaler)
        {
            if (Contract?.ForMachines is null || Contract.ForMachinesNamespace != NeuroFeaturesNamespace)
                return;
 
            if ((TransientParameters?.Count ?? 0) > 0)
            {
                await RejectContract(Contract, ContractIsLocked,
                    "Transient parameters not permitted for transparency reasons.",
                    true, Legal, EDaler);
                return;
            }
 
            switch (Contract.ForMachinesLocalName)
            {
                case "Create":
                    if (!OnlyMissingTrustProvider(Contract, out string TrustProviderRole, out XmlDocument ForMachines))
                        return;
 
                    await CreateTokens(ForMachines.DocumentElement, Contract, ContractIsLocked, TrustProviderRole, Legal, EDaler);
                    break;
 
                case "Destroy":
                    if (!OnlyMissingTrustProvider(Contract, out TrustProviderRole, out ForMachines))
                        return;
 
                    await DestroyTokens(ForMachines.DocumentElement, Contract, ContractIsLocked, TrustProviderRole, Legal, EDaler);
                    break;
 
                case "Transfer":
                    if (!OnlyMissingTrustProvider(Contract, out TrustProviderRole, out ForMachines))
                        return;
 
                    await TransferTokens(ForMachines.DocumentElement, Contract, ContractIsLocked, TrustProviderRole, Legal, EDaler);
                    break;
 
                case "Donate":
                    if (!OnlyMissingTrustProvider(Contract, out TrustProviderRole, out ForMachines))
                        return;
 
                    await DonateTokens(ForMachines.DocumentElement, Contract, ContractIsLocked, TrustProviderRole, Legal, EDaler);
                    break;
 
                default:
                    await RejectContract(Contract, ContractIsLocked, "Rejected Neuro-Feature contract: Unrecognized element: " + Contract.ForMachinesLocalName, true, Legal, EDaler);
                    break;
            }
        }
 
        internal static Task RejectContract(Contract Contract, bool ContractIsLocked, Exception ex, bool FailContract, LegalComponent Legal, EDalerComponent EDaler)
        {
            ex = Log.UnnestException(ex);
            return RejectContract(Contract, ContractIsLocked, ex.Message, FailContract, Legal, EDaler, string.Empty);
        }
 
        internal static Task RejectContract(Contract Contract, bool ContractIsLocked, string Reason, bool FailContract, LegalComponent Legal, EDalerComponent EDaler)
        {
            return RejectContract(Contract, ContractIsLocked, Reason, FailContract, Legal, EDaler, string.Empty);
        }
 
        internal static async Task RejectContract(Contract Contract, bool ContractIsLocked, string Reason, bool FailContract,
            LegalComponent Legal, EDalerComponent EDaler, string EventId, params KeyValuePair<string, object>[] Tags)
        {
            Log.Error(Reason, Contract.ContractId.Value, string.Empty, EventId, Tags);
 
            if (FailContract)
            {
                Semaphore Semaphore;
 
                if (ContractIsLocked)
                    Semaphore = null;
                else
                    Semaphore = await Semaphores.BeginWrite("iotsc:" + Contract.ContractId.LowerCase);
 
                try
                {
                    Contract.State = ContractState.Failed;
                    await Contract.Sign(Legal);
 
                    await Database.Update(Contract);
 
                    if (Contract.CanActAsTemplate)
                        await RuntimeCounters.IncrementCounter("Legal.Template." + Contract.State.ToString());
                    else
                        await RuntimeCounters.IncrementCounter("Legal.Contract." + Contract.State.ToString());
 
                    await Legal.SendContractUpdatedEvent(Contract, false);
 
                    if (!(Legal.Geo is null))
                        await Legal.Geo.Delete(Contract);
                }
                finally
                {
                    if (!(Semaphore is null))
                        await Semaphore.DisposeAsync();
                }
 
                if (IsNeuroFeaturesCreationContract(Contract, out string LocalName, out string Namespace))
                {
                    bool HasStateMachine = LocalName == StateMachineProcessor.StateMachineDefinition &&
                        Namespace == StateMachineProcessor.StateMachineNamespace;
 
                    IEnumerable<Token> Deleted = await Database.FindDelete<Token>(
                        new FilterFieldEqualTo("CreationContract", Contract.ContractId));
 
                    await TokensDeleted(EDaler, Deleted, true, true, true, HasStateMachine, true);
                }
            }
 
            Dictionary<CaseInsensitiveString, bool> SendTo = new Dictionary<CaseInsensitiveString, bool>();
 
            foreach (ClientSignature Signature in Contract.ClientSignatures)
                SendTo[Signature.BareJid] = true;
 
            foreach (CaseInsensitiveString Jid in SendTo.Keys)
            {
                await EDaler.Server.SendMessage("chat", string.Empty, EDaler.MainDomain.Address, Jid, "en",
                    "<body>" + XML.Encode(Reason) + "</body>");
            }
        }
 
        internal static bool IsNeuroFeaturesCreationContract(Contract Contract,
            out string LocalName, out string Namespace)
        {
            return LegalComponent.HasSecondaryName(Contract, out LocalName, out Namespace,
                out SecondaryNameType NameType) && NameType == SecondaryNameType.TokenCreation;
        }
 
        private static bool OnlyMissingTrustProvider(Contract Contract, out string TrustProviderRole, out XmlDocument ForMachines)
        {
            TrustProviderRole = null;
            ForMachines = null;
 
            if (Contract.State != ContractState.BeingSigned || Contract.ClientSignatures is null)
                return false;
 
            if ((Contract.Roles?.Length ?? 0) < 2)
                return false;
 
            string CreatorRole = null;
            string OwnerRole = null;
            CaseInsensitiveString TrustProviderLegalId = null;
 
            ForMachines = Contract.ForMachinesParsed;
            foreach (XmlElement E in Contract.ForMachinesParsed.DocumentElement.ChildNodes)
            {
                if (E.NamespaceURI != Contract.ForMachinesNamespace)
                    continue;
 
                switch (E.LocalName)
                {
                    case "TrustProvider":
                        TrustProviderLegalId = PaiwiseProcessor.GetLegalId(E, Contract, out TrustProviderRole);
                        break;
 
                    case "Creator":
                        if (CaseInsensitiveString.IsNullOrEmpty(PaiwiseProcessor.GetLegalId(E, Contract, out CreatorRole)))
                            return false;
 
                        break;
 
                    case "Owner":
                        PaiwiseProcessor.GetLegalId(E, Contract, out OwnerRole);
                        break;
                }
            }
 
            if (string.IsNullOrEmpty(TrustProviderRole) || !string.IsNullOrEmpty(TrustProviderLegalId))
                return false;
 
            if (string.IsNullOrEmpty(OwnerRole))
                OwnerRole = CreatorRole;
 
            Dictionary<string, SignatureStat> Signatures = new Dictionary<string, SignatureStat>();
 
            foreach (Role Role in Contract.Roles)
            {
                if (Role.CanRevoke)
                    return false;
 
                if (Role.Name == TrustProviderRole)
                {
                    if (Role.MinCount != 1 || Role.MaxCount != 1)
                        return false;
                }
                else
                {
                    if (Role.Name == CreatorRole || Role.Name == OwnerRole)
                    {
                        if (Role.MinCount != 1 || Role.MaxCount != 1)
                            return false;
                    }
 
                    Signatures[Role.Name] = new SignatureStat()
                    {
                        Min = Role.MinCount,
                        Max = Role.MaxCount,
                        Count = 0
                    };
                }
            }
 
            foreach (ClientSignature Signature in Contract.ClientSignatures)
            {
                if (Signature.Role == TrustProviderRole)
                    return false;
 
                if (Signatures.TryGetValue(Signature.Role, out SignatureStat Stat))
                    Stat.Count++;
                else
                    return false;
            }
 
            foreach (SignatureStat Stat in Signatures.Values)
            {
                if (Stat.Count < Stat.Min || Stat.Count > Stat.Max)
                    return false;
            }
 
            if (!(Contract.Parts is null))
            {
                foreach (Part Part in Contract.Parts)
                {
                    if (Part.Role == TrustProviderRole && !LegalIdentityConfiguration.IsMeApproved(Part.LegalId))
                    {
                        // TODO: Forward contract in message to intended auctioneer
                        return false;
                    }
                }
            }
 
            return true;
        }
 
        private class SignatureStat
        {
            public int Min;
            public int Max;
            public int Count;
        }
 
        private class TokenIDReference
        {
            public Guid TokenId;
            public TokenIdMethod Method;
            public Token Token;
            public StateMachine Machine;
            public int ShortIdLength;
            public string ShortIdAlphabet;
        }
 
        private static async Task<TokenIDReference> GetTokenId(XmlElement Value, Contract Contract, bool ContractIsLocked, LegalComponent Legal, EDalerComponent EDaler)
        {
            int ShortIdLength = XML.Attribute(Value, "shortIdLength", 0);
            string ShortIdAlphabet = XML.Attribute(Value, "shortIdAlphabet", "0123456789");
 
            foreach (XmlNode N in Value.ChildNodes)
            {
                if (!(N is XmlElement E))
                    continue;
 
                switch (E.LocalName)
                {
                    case "Random":
                        return new TokenIDReference()
                        {
                            TokenId = Guid.NewGuid(),
                            Method = TokenIdMethod.ByTrustProvider,
                            ShortIdLength = ShortIdLength,
                            ShortIdAlphabet = ShortIdAlphabet
                        };
 
                    case "Unique":
                        return new TokenIDReference()
                        {
                            TokenId = Guid.Empty,
                            Method = TokenIdMethod.Unique,
                            ShortIdLength = ShortIdLength,
                            ShortIdAlphabet = ShortIdAlphabet
                        };
 
                    default:
                        if (!(await PaiwiseProcessor.GetParameterValue(Value, Contract) is string s))
                        {
                            await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid Token ID.", true, Legal, EDaler);
                            return null;
                        }
 
                        if (s != s.ToLower())
                        {
                            await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Token IDs must be lower-case.", true, Legal, EDaler);
                            return null;
                        }
 
                        if (!Guid.TryParse(s, out Guid TokenGuid))
                        {
                            await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Token IDs must be GUIDs.", true, Legal, EDaler);
                            return null;
                        }
 
                        return new TokenIDReference()
                        {
                            TokenId = TokenGuid,
                            Method = TokenIdMethod.ByCreator,
                            ShortIdLength = ShortIdLength,
                            ShortIdAlphabet = ShortIdAlphabet
                        };
                }
            }
 
            await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Undefined Token ID.", true, Legal, EDaler);
            return null;
        }
 
        internal static async Task<Token> GetToken(CaseInsensitiveString TokenId, bool OnlyIfLocal)
        {
            if (CaseInsensitiveString.IsNullOrEmpty(TokenId))
                return null;
 
            if (tokenCache.TryGetValue(TokenId, out Token Result))
                return Result;
 
            int i = TokenId.IndexOf('@');
            if (i < 0)
                Result = await Database.FindFirstIgnoreRest<Token>(new FilterFieldEqualTo("ShortId", TokenId));
            else
            {
                CaseInsensitiveString Domain = TokenId.Substring(i + 1);
 
                if (eDaler.IsComponentDomain(Domain, true))
                    Result = await Database.FindFirstIgnoreRest<Token>(new FilterFieldEqualTo("TokenId", TokenId));
                else
                {
                    if (OnlyIfLocal)
                        return null;
 
                    StringBuilder Xml = new StringBuilder();
 
                    Xml.Append("<token id='");
                    Xml.Append(XML.Encode(TokenId.Value));
                    Xml.Append("' xmlns='");
                    Xml.Append(NeuroFeaturesNamespace);
                    Xml.Append("'/>");
 
                    IqResultEventArgs e = await eDaler.Server.IqRequest("get", legal.MainDomain.Address, Domain, string.Empty, Xml.ToString(), true);
                    if (!e.Ok || e.FirstElement is null || !Token.TryParse(e.FirstElement, out Result))
                        Result = null;
                }
            }
 
            if (!(Result is null))
                tokenCache[TokenId] = Result;
 
            return Result;
        }
 
        internal static async Task<(int, int, int)> DeleteExpiredTokens(EDalerComponent EDaler)
        {
            IEnumerable<Token> Deleted = await Database.FindDelete<Token>(
                new FilterFieldLesserThan("Expires", DateTime.Today.AddDays(-1)));
 
            (int NrTokens, int NrEvents, int NrTags) = await TokensDeleted(EDaler, Deleted, true, true, true, true, true);
 
            return (NrTokens, NrEvents, NrTags);
        }
 
        private static async Task<(int, int, int)> TokensDeleted(EDalerComponent EDaler,
            IEnumerable<Token> Deleted, bool RemoveCache, bool DeleteEvents, bool DeleteTags,
            bool StopMachines, bool SendNotifications)
        {
            int NrTokens = 0;
            int NrEvents = 0;
            int NrTags = 0;
 
            foreach (Token Token in Deleted)
            {
                if (RemoveCache)
                {
                    tokenCache.Remove(Token.TokenId);
                    if (CaseInsensitiveString.IsNullOrEmpty(Token.ShortId))
                        tokenCache.Remove(Token.ShortId);
                }
 
                NrTokens++;
 
                if (DeleteEvents)
                {
                    NrEvents = await Database.Delete<TokenEvent>(
                        new FilterFieldEqualTo("TokenId", Token.TokenId));
                }
 
                if (DeleteTags)
                {
                    NrTags = await Database.Delete<TokenTag>(
                        new FilterFieldEqualTo("TokenId", Token.TokenId));
                }
 
                if (StopMachines && !string.IsNullOrEmpty(Token.MachineId))
                    await StateMachineProcessor.EventGenerated(Token.MachineId, new Destroyed());
 
                if (SendNotifications && !string.IsNullOrEmpty(Token.OwnerJid))
                {
                    StringBuilder Xml = new StringBuilder();
 
                    Xml.Append("<tokenRemoved xmlns='");
                    Xml.Append(NeuroFeaturesNamespace);
                    Xml.Append("'>");
                    await Token.Serialize(Xml, false, true);
                    Xml.Append("</tokenRemoved>");
 
                    await SendTokenMessage(EDaler, Xml.ToString(), Token.OwnerJid, true, true);
                }
 
                await TokenRemoved(Token, Token.OwnerJid);
            }
 
            return (NrTokens, NrEvents, NrTags);
        }
 
        #endregion
 
        #region Create Contract
 
        private enum CommissionPaidBy
        {
            Creator,
 
            Owner
        }
 
        private static async Task<bool> CreateTokens(XmlElement Create, Contract Contract, bool ContractIsLocked, string TrustProviderRole, LegalComponent Legal,
            EDalerComponent EDaler)
        {
            Dictionary<Guid, TokenIDReference> ProposedTokenIDs = new Dictionary<Guid, TokenIDReference>();
            List<TokenIDReference> AllTokenIDs = new List<TokenIDReference>();
            SortedDictionary<CaseInsensitiveString, TokenTagReference> TagReferences = null;
            CaseInsensitiveString[] ValuatorIds = null;
            CaseInsensitiveString[] AssessorIds = null;
            CaseInsensitiveString[] CertifierIds = null;
            CaseInsensitiveString[] WitnessIds = null;
            CaseInsensitiveString CreatorId = null;
            CaseInsensitiveString OwnerId = null;
            CaseInsensitiveString TrustProviderLegalId = null;
            string Currency = null;
            string Reference = null;
            string FriendlyName = null;
            string Category = null;
            string Description = null;
            string GlyphContentType = null;
            byte[] Glyph = null;
            XmlElement Definition = null;
            decimal? Value = null;
            decimal? CommissionPercent = null;
            CommissionPaidBy CommissionPaidBy = CommissionPaidBy.Owner;
            int? GlyphWidth = null;
            int? GlyphHeight = null;
            DateTime Expires = DateTime.MaxValue;
            bool CreatorCanDestroy = false;
            bool OwnerCanDestroyBatch = false;
            bool OwnerCanDestroyIndividual = false;
            bool CertifierCanDestroy = false;
 
            foreach (XmlElement E in Create.ChildNodes)
            {
                if (E.NamespaceURI == Contract.ForMachinesNamespace)
                {
                    switch (E.LocalName)
                    {
                        case "TokenID":
                            TokenIDReference TokenRef = await GetTokenId(E, Contract, ContractIsLocked, Legal, EDaler);
                            if (TokenRef is null)
                                return false;
 
                            AllTokenIDs.Add(TokenRef);
 
                            if (TokenRef.Method != TokenIdMethod.Unique)
                            {
                                if (ProposedTokenIDs.ContainsKey(TokenRef.TokenId))
                                {
                                    await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Duplicate Token IDs used.", true, Legal, EDaler);
                                    return false;
                                }
                                else
                                    ProposedTokenIDs[TokenRef.TokenId] = TokenRef;
                            }
                            break;
 
                        case "Creator":
                            CreatorId = PaiwiseProcessor.GetLegalId(E, Contract);
                            break;
 
                        case "Owner":
                            OwnerId = PaiwiseProcessor.GetLegalId(E, Contract);
                            break;
 
                        case "Valuator":
                            ValuatorIds = PaiwiseProcessor.GetLegalIds(E, Contract);
                            break;
 
                        case "Assessor":
                            AssessorIds = PaiwiseProcessor.GetLegalIds(E, Contract);
                            break;
 
                        case "Certifier":
                            CertifierIds = PaiwiseProcessor.GetLegalIds(E, Contract);
                            break;
 
                        case "Witness":
                            WitnessIds = PaiwiseProcessor.GetLegalIds(E, Contract);
                            break;
 
                        case "TrustProvider":
                            TrustProviderLegalId = PaiwiseProcessor.GetLegalId(E, Contract, out TrustProviderRole);
                            break;
 
                        case "Value":
                            if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is decimal d))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid value.", true, Legal, EDaler);
                                return false;
                            }
 
                            Value = d;
                            break;
 
                        case "Currency":
                            if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is string s2))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid currency.", true, Legal, EDaler);
                                return false;
                            }
 
                            Currency = s2;
                            break;
 
                        case "CommissionPercent":
                            if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is decimal d2) || d2 < 0 || d2 > 100)
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid commission (%).", true, Legal, EDaler);
                                return false;
                            }
 
                            CommissionPercent = d2;
                            break;
 
                        case "CommissionPaidBy":
                            if (!Enum.TryParse(E.InnerText, out CommissionPaidBy CommissionPaidBy2))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid commission payer.", true, Legal, EDaler);
                                return false;
                            }
 
                            CommissionPaidBy = CommissionPaidBy2;
                            break;
 
                        case "Expires":
                            if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is DateTime TP) ||
                                (Expires = TP.Date) <= DateTime.UtcNow.Date)
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid expiry date.", true, Legal, EDaler);
                                return false;
                            }
                            break;
 
                        case "CreatorCanDestroy":
                            if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is bool b))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid CreatorCanDestroy property value.", true, Legal, EDaler);
                                return false;
                            }
 
                            CreatorCanDestroy = b;
                            break;
 
                        case "OwnerCanDestroyBatch":
                            if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is bool b2))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid OwnerCanDestroyBatch property value.", true, Legal, EDaler);
                                return false;
                            }
 
                            OwnerCanDestroyBatch = b2;
                            break;
 
                        case "OwnerCanDestroyIndividual":
                            if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is bool b4))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid OwnerCanDestroyIndividual property value.", true, Legal, EDaler);
                                return false;
                            }
 
                            OwnerCanDestroyIndividual = b4;
                            break;
 
                        case "CertifierCanDestroy":
                            if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is bool b3))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid CertifierCanDestroy property value.", true, Legal, EDaler);
                                return false;
                            }
 
                            CertifierCanDestroy = b3;
                            break;
 
                        case "Reference":
                            object Ref = await PaiwiseProcessor.GetParameterValue(E, Contract);
 
                            if (Ref is string s3)
                                Reference = s3;
                            else if (Ref is CaseInsensitiveString cis)
                                Reference = cis;
                            else
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid reference.", true, Legal, EDaler);
                                return false;
                            }
                            break;
 
                        case "Definition":
                            foreach (XmlNode N in E.ChildNodes)
                            {
                                if (N is XmlElement E2)
                                {
                                    if (Definition is null)
                                        Definition = E2;
                                    else
                                    {
                                        await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Definition can only be one element.", true, Legal, EDaler);
                                        return false;
                                    }
                                }
                            }
                            break;
 
                        case "Tag":
                            TagReferences ??= new SortedDictionary<CaseInsensitiveString, TokenTagReference>();
 
                            string TagName = XML.Attribute(E, "name");
 
                            if (TagReferences.ContainsKey(TagName))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Duplicated tag name.", true, Legal, EDaler);
                                return false;
                            }
 
                            object TagValue = await PaiwiseProcessor.GetParameterValue(E, Contract, false);
 
                            if (TagValue is decimal d3)
                                TagReferences[TagName] = new NumberTokenTagReference(TagName, d3);
                            else if (TagValue is string s)
                                TagReferences[TagName] = new StringTokenTagReference(TagName, s);
                            else if (TagValue is CaseInsensitiveString cis2)
                                TagReferences[TagName] = new StringTokenTagReference(TagName, cis2.Value);
                            else if (TagValue is bool b5)
                                TagReferences[TagName] = new BooleanTokenTagReference(TagName, b5);
                            else if (TagValue is DateTime TP2)
                                TagReferences[TagName] = new DateTimeTokenTagReference(TagName, TP2);
                            else if (TagValue is TimeSpan TS)
                                TagReferences[TagName] = new TimeSpanTokenTagReference(TagName, TS);
                            else if (TagValue is Duration Dr)
                                TagReferences[TagName] = new DurationTokenTagReference(TagName, Dr);
                            else if (TagValue is byte[] Bin)
                                TagReferences[TagName] = new BinaryTokenTagReference(TagName, Bin);
                            else if (TagValue is AttachmentReferenceWithUrl Attachment)
                            {
                                try
                                {
                                    DateTime AttachmentExpires = Expires;
                                    if (Contract.Expires > AttachmentExpires)
                                        AttachmentExpires = Contract.Expires;
 
                                    await Legal.GetAttachment(Attachment.Id, Attachment.Url,
                                        AttachmentExpires.ToUniversalTime());
                                }
                                catch (Exception ex)
                                {
                                    Log.Exception(ex);
 
                                    await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Unable to get attachment when evaluating tag " + TagName + ".", true, Legal, EDaler);
                                    return false;
                                }
 
                                TagReferences[TagName] = new AttachmentTokenTagReference(TagName, Attachment.Id,
                                    Attachment.LegalId, Attachment.ContentType, Attachment.FileName,
                                    Attachment.Signature, Attachment.Timestamp);
                            }
                            else if (TagValue is null)
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Unable to evaluate tag " + TagName + ".", true, Legal, EDaler);
                                return false;
                            }
                            else
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Unrecognized value for tag " + TagName + ".", true, Legal, EDaler);
                                return false;
                            }
                            break;
 
                        case "FriendlyName":
                            if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is string s4))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid friendly name.", true, Legal, EDaler);
                                return false;
                            }
 
                            FriendlyName = Category = Description = s4;
                            break;
 
                        case "Category":
                            if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is string s5))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid category.", true, Legal, EDaler);
                                return false;
                            }
 
                            Category = s5;
                            break;
 
                        case "Description":
                            if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is string s6))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid description.", true, Legal, EDaler);
                                return false;
                            }
 
                            Description = s6;
                            break;
 
                        case "Glyph":
                            try
                            {
                                GlyphContentType = XML.Attribute(E, "contentType");
                                if (!GlyphContentType.StartsWith("image/"))
                                {
                                    await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid glyph content type.", true, Legal, EDaler);
                                    return false;
                                }
 
                                Glyph = Convert.FromBase64String(E.InnerText);
 
                                ContentResponse Decoded = await InternetContent.DecodeAsync(GlyphContentType, Glyph, null);
                                if (Decoded.HasError)
                                {
                                    await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid glyph.", true, Legal, EDaler);
                                    return false;
                                }
 
                                if (!(Decoded.Decoded is SKImage Image))
                                {
                                    await Decoded.DisposeAsync();
 
                                    await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Glyph not an image.", true, Legal, EDaler);
                                    return false;
                                }
 
                                GlyphWidth = Image.Width;
                                GlyphHeight = Image.Height;
 
                                Image.Dispose();
                            }
                            catch (Exception)
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid glyph.", true, Legal, EDaler);
                                return false;
                            }
                            break;
                    }
                }
            }
 
            if (AllTokenIDs.Count == 0)
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: No Token IDs.", true, Legal, EDaler);
                return false;
            }
 
            if (Definition is null)
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Definition missing.", true, Legal, EDaler);
                return false;
            }
 
            if (!Contract.TryGetSchemaReference(Definition.NamespaceURI, out SchemaReference DefinitionSchema))
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Definition schema not found.", true, Legal, EDaler);
                return false;
            }
 
            if (string.IsNullOrEmpty(CreatorId))
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Missing Creator ID.", true, Legal, EDaler);
                return false;
            }
 
            if (!Value.HasValue || Value.Value <= 0)
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Value must be positive.", true, Legal, EDaler);
                return false;
            }
 
            if (string.IsNullOrEmpty(Currency) || Currency.Length != 3)
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid currency.", true, Legal, EDaler);
                return false;
            }
 
            if (string.IsNullOrEmpty(TrustProviderRole))
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Trust Provider role not defined.", true, Legal, EDaler);
                return false;
            }
 
            if (!string.IsNullOrEmpty(TrustProviderLegalId) &&
                !LegalIdentityConfiguration.IsMeApproved(TrustProviderLegalId))
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Trust Provider ID does not represent the current server.", true, Legal, EDaler);
                return false;
            }
 
            if (!CommissionPercent.HasValue)
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Commission missing.", true, Legal, EDaler);
                return false;
            }
 
            if (CommissionPercent.Value < await MarketplaceProcessor.GetMinCommission())
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Commission too low.", true, Legal, EDaler);
                return false;
            }
 
            if (Expires <= DateTime.UtcNow.Date)
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Must expire on a future date, if to expire.", true, Legal, EDaler);
                return false;
            }
 
            if (!Contract.Duration.HasValue ||
                DateTime.UtcNow.Date + Contract.Duration.Value < Expires.AddDays(1))
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Duration must cover expiry date.", true, Legal, EDaler);
                return false;
            }
 
            if (string.IsNullOrEmpty(FriendlyName))
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: No friendly name provided.", true, Legal, EDaler);
                return false;
            }
 
            if (string.IsNullOrEmpty(Category))
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: No category provided.", true, Legal, EDaler);
                return false;
            }
 
            if (string.IsNullOrEmpty(Description))
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: No description provided.", true, Legal, EDaler);
                return false;
            }
 
            if (Glyph is null || string.IsNullOrEmpty(GlyphContentType) ||
                !GlyphWidth.HasValue || !GlyphHeight.HasValue || GlyphWidth <= 0 || GlyphHeight <= 0)
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: A valid glyph has not been provided.", true, Legal, EDaler);
                return false;
            }
 
            OwnerId ??= CreatorId;
 
            CaseInsensitiveString OwnerJid = null;
            CaseInsensitiveString CreatorJid = null;
            CaseInsensitiveString[] CertifierJids = CertifierIds is null ? null : new CaseInsensitiveString[CertifierIds.Length];
 
            foreach (ClientSignature Signature in Contract.ClientSignatures)
            {
                if (Signature.LegalId == OwnerId)
                    OwnerJid = Signature.BareJid;
 
                if (Signature.LegalId == CreatorId)
                    CreatorJid = Signature.BareJid;
 
                if (!(CertifierIds is null))
                {
                    int i, c = CertifierIds.Length;
 
                    for (i = 0; i < c; i++)
                    {
                        if (Signature.LegalId == CertifierIds[i])
                            CertifierJids[i] = Signature.BareJid;
                    }
                }
            }
 
            if (CaseInsensitiveString.IsNullOrEmpty(OwnerJid))
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Owner JID not accessible.", true, Legal, EDaler);
                return false;
            }
 
            if (CaseInsensitiveString.IsNullOrEmpty(CreatorJid))
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Creator JID not accessible.", true, Legal, EDaler);
                return false;
            }
 
            if (!(CertifierIds is null))
            {
                int i, c = CertifierIds.Length;
 
                for (i = 0; i < c; i++)
                {
                    if (CaseInsensitiveString.IsNullOrEmpty(CertifierJids[i]))
                    {
                        await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Certifier JID not accessible.", true, Legal, EDaler);
                        return false;
                    }
                }
            }
 
            List<Token> Tokens = new List<Token>();
            Dictionary<StateMachine, Token> StateMachines = null;
 
            DateTime Created = DateTime.UtcNow;
            StringBuilder sb = new StringBuilder();
 
            Contract.NormalizeXml(Definition, sb, NeuroFeaturesNamespace);
 
            string NormalizedDefinition = sb.ToString();
            StateMachine SingletonStateMachine = null;
            Contract SingletonStateMachineContract = null;
            int Ordinal = 0;
 
            foreach (TokenIDReference TokenID in AllTokenIDs)
            {
                TokenTagReference[] TagReferences2;
 
                if (TagReferences is null)
                    TagReferences2 = null;
                else
                {
                    TagReferences2 = new TokenTagReference[TagReferences.Count];
                    TagReferences.Values.CopyTo(TagReferences2, 0);
                }
 
                Token Token = new Token()
                {
                    TokenIdMethod = TokenID.Method,
                    TokenId = TokenID.TokenId.ToString() + "@" + EDaler.MainDomain.Address,
                    Ordinal = ++Ordinal,
                    BatchSize = AllTokenIDs.Count,
                    Visibility = Contract.Visibility,
                    Creator = CreatorId,
                    CreatorJid = CreatorJid,
                    Owner = OwnerId,
                    OwnerJid = OwnerJid,
                    Created = Created,
                    Updated = Created,
                    Definition = NormalizedDefinition,
                    DefinitionNamespace = Definition.NamespaceURI,
                    DefinitionSchemaDigest = DefinitionSchema.Digest,
                    DefinitionSchemaHashFunction = DefinitionSchema.Algorithm,
                    Tags = TagReferences2,
                    Expires = Expires,
                    CreatorCanDestroy = CreatorCanDestroy,
                    OwnerCanDestroyBatch = OwnerCanDestroyBatch,
                    OwnerCanDestroyIndividual = OwnerCanDestroyIndividual,
                    CertifierCanDestroy = CertifierCanDestroy,
                    ArchiveRequired = Contract.ArchiveRequired,
                    ArchiveOptional = Contract.ArchiveOptional,
                    Value = Value.Value,
                    Currency = Currency,
                    CreationContract = Contract.ContractId,
                    CreationContractTemplate = Contract.TemplateId,
                    OwnershipContract = Contract.ContractId,
                    Reference = Reference,
                    Valuator = ValuatorIds,
                    Assessor = AssessorIds,
                    Certifier = CertifierIds,
                    CertifierJids = CertifierJids,
                    Witness = WitnessIds,
                    TrustProvider = await Gateway.ContractsClient.GetLatestApprovedLegalId(),
                    TrustProviderJid = Gateway.ContractsClient.Client.BareJID,
                    FriendlyName = FriendlyName,
                    Category = Category,
                    Description = Description,
                    Glyph = Glyph,
                    GlyphContentType = GlyphContentType,
                    GlyphWidth = GlyphWidth.Value,
                    GlyphHeight = GlyphHeight.Value
                };
 
                TokenID.Token = Token;
 
                if (TokenID.Method == TokenIdMethod.Unique)
                {
                    if (!(TagReferences2 is null))
                    {
                        Dictionary<string, bool> TagNames = new Dictionary<string, bool>();
 
                        foreach (TokenTagReference Ref in TagReferences2)
                            TagNames[Ref.Name] = true;
 
                        LinkedList<XmlElement> ToCheck = new LinkedList<XmlElement>();
 
                        ToCheck.AddLast(Definition);
 
                        while (!(ToCheck.First is null))
                        {
                            XmlElement E = ToCheck.First.Value;
                            ToCheck.RemoveFirst();
 
                            foreach (XmlAttribute Attr in E.Attributes)
                                TagNames.Remove(Attr.Value);
 
                            TagNames.Remove(E.InnerText);
 
                            foreach (XmlNode N in E.ChildNodes)
                            {
                                if (N is XmlElement E2)
                                    ToCheck.AddLast(E2);
                            }
                        }
 
                        if (TagNames.Count > 0)
                        {
                            await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Uniqueness requires all tags to be referenced by the machine-readable XML definition of the token, either in attributes or element values.", true, Legal, EDaler);
                            return false;
                        }
                    }
 
                    Token.TokenId = (await Token.ComputeUniqueGuid()).ToString() + "@" + EDaler.MainDomain.Address;
                }
 
                Token.ShortId = CalcShortId(Token.TokenId, TokenID.ShortIdLength, TokenID.ShortIdAlphabet);
 
                switch (Token.DefinitionNamespace)
                {
                    case StateMachineProcessor.StateMachineNamespace:
                        StateMachine StateMachine;
 
                        try
                        {
                            StateMachine = await StateMachineProcessor.Parse(Token);
                            if (StateMachine is null)
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Not able to parse State-Machine definition.", true, Legal, EDaler);
                                return false;
                            }
                        }
                        catch (ScriptException ex)
                        {
                            await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: " + ex.Message, true, Legal, EDaler);
                            return false;
                        }
                        catch (UnauthorizedAccessException ex)
                        {
                            await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: " + ex.Message, true, Legal, EDaler);
                            return false;
                        }
                        catch (Exception ex)
                        {
                            Log.Exception(ex);
                            await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Exception occurred when parsing state-machine definition: " + ex.Message, true, Legal, EDaler);
                            return false;
                        }
 
                        TokenID.Machine = StateMachine;
 
                        if (string.IsNullOrEmpty(TokenID.Token.MachineId = StateMachine.StateMachineId))
                        {
                            StateMachine Temp = await Database.FindFirstIgnoreRest<StateMachine>(
                                new FilterFieldEqualTo("StateMachineId", Token.TokenId));
 
                            if (Temp is null)
                                StateMachine.StateMachineId = Token.TokenId;
                            else
                            {
                                string Id;
 
                                do
                                {
                                    Id = Guid.NewGuid().ToString();
                                    Id += Token.TokenId.Substring(Id.Length);
 
                                    Temp = await Database.FindFirstIgnoreRest<StateMachine>(
                                        new FilterFieldEqualTo("StateMachineId", Id));
                                }
                                while (!(Temp is null));
 
                                StateMachine.StateMachineId = Id;
                            }
 
                            TokenID.Token.MachineId = StateMachine.StateMachineId;
                        }
                        else    // Singleton machine
                        {
                            SingletonStateMachine ??= await Database.FindFirstIgnoreRest<StateMachine>(
                                new FilterFieldEqualTo("StateMachineId", StateMachine.StateMachineId));
 
                            if (SingletonStateMachine is null)
                                SingletonStateMachine = StateMachine;
                            else
                            {
                                if (SingletonStateMachine.XmlDefinition != Token.Definition)
                                {
                                    await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Attempted to change the definition of a singleton State-Machine.", true, Legal, EDaler);
                                    return false;
                                }
 
                                if (SingletonStateMachine.DefinitionContractId != StateMachine.DefinitionContractId)
                                {
                                    if (SingletonStateMachineContract is null)
                                    {
                                        KeyValuePair<Contract, IqResultEventArgs> P = await legal.GetContract(SingletonStateMachineContract.ContractId);
                                        SingletonStateMachineContract = P.Key;
 
                                        if (SingletonStateMachineContract is null)
                                        {
                                            if (string.IsNullOrEmpty(P.Value?.ErrorText))
                                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Unable to access original creation contract.", true, Legal, EDaler);
                                            else
                                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Unable to access original creation contract: " + P.Value.ErrorText, true, Legal, EDaler);
 
                                            return false;
                                        }
 
                                        if (SingletonStateMachineContract.State != ContractState.Signed)
                                        {
                                            await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Original creation contract not in a signed state.", true, Legal, EDaler);
                                            return false;
                                        }
 
                                        Dictionary<string, string> Parts = new Dictionary<string, string>();
 
                                        if (!(SingletonStateMachineContract.ClientSignatures is null))
                                        {
                                            foreach (ClientSignature Signature in SingletonStateMachineContract.ClientSignatures)
                                                Parts[Signature.LegalId] = Signature.Role;
                                        }
 
                                        if (!(Contract.ClientSignatures is null))
                                        {
                                            foreach (ClientSignature Signature in Contract.ClientSignatures)
                                            {
                                                if (!Parts.TryGetValue(Signature.LegalId, out string Role))
                                                    continue;
 
                                                if (Role != Signature.Role)
                                                {
                                                    await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Role mismatch compared to original creation contract, for part " + Signature.LegalId, true, Legal, EDaler);
                                                    return false;
                                                }
 
                                                Parts.Remove(Signature.LegalId);
                                            }
                                        }
 
                                        if (Parts.Count > 0)
                                        {
                                            await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: All parts of the original creation contract need to sign the new contract.", true, Legal, EDaler);
                                            return false;
                                        }
                                    }
                                }
 
                                break;
                            }
                        }
 
                        StateMachines ??= new Dictionary<StateMachine, Token>();
 
                        StateMachine.Expires = Token.Expires;
                        StateMachine.ArchiveRequired = Token.ArchiveRequired;
                        StateMachine.ArchiveOptional = Token.ArchiveOptional;
                        StateMachines[StateMachine] = Token;
                        break;
                }
 
                await Token.Sign();
                Tokens.Add(Token);
            }
 
            using (Semaphore Lock = await Semaphores.BeginWrite("NeuroFeature.Tokens.IDs"))     // Only for creation and destruction
            {
                await Database.StartBulk();
                try
                {
                    foreach (TokenIDReference TokenID in AllTokenIDs)
                    {
                        Token Prev = await GetToken(TokenID.Token.TokenId, false);
                        Token PrevShort = await GetToken(TokenID.Token.ShortId, false);
 
                        if (!(Prev is null) || !(PrevShort is null))
                        {
                            if (TokenID.Method == TokenIdMethod.ByTrustProvider)
                            {
                                do
                                {
                                    TokenID.TokenId = Guid.NewGuid();
                                    TokenID.Token.TokenId = TokenID.TokenId.ToString() + "@" + EDaler.MainDomain.Address;
                                    TokenID.Token.ShortId = CalcShortId(TokenID.Token.TokenId, TokenID.ShortIdLength, TokenID.ShortIdAlphabet);
 
                                    Prev = await GetToken(TokenID.Token.TokenId, false);
                                    PrevShort = await GetToken(TokenID.Token.ShortId, false);
                                }
                                while (!(Prev is null) || !(PrevShort is null));
                            }
                            else
                            {
                                if (!(Prev is null))
                                    await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Token with same ID already exists.", true, Legal, EDaler);
                                else
                                    await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Token with same short ID already exists.", true, Legal, EDaler);
 
                                return false;
                            }
                        }
                    }
 
                    if (await MarketplaceProcessor.SignContract(Contract, ContractIsLocked, Legal, TrustProviderRole) is null)
                        return false;
 
                    int i = Contract.ContractId.IndexOf('@');
                    if (i <= 0 || !Guid.TryParse(Contract.ContractId.Substring(0, i), out Guid TransactionId))
                        TransactionId = Guid.NewGuid();
 
                    decimal Commission = Value.Value * AllTokenIDs.Count * CommissionPercent.Value * 0.01m;
                    string Ref = "iotsc:" + Contract.ContractId;
 
                    if (Commission > 0)
                    {
                        string PaymentUri = PaiwiseProcessor.GenerateContractualPaymentUri(TransactionId,
                            CommissionPaidBy == CommissionPaidBy.Creator ? CreatorId : OwnerId, true,
                            Gateway.ContractsClient.Client.BareJID, false, Currency, Commission, null, Ref,
                            Contract.ContractId, null, 1, out _, out _);
 
                        if (!string.IsNullOrEmpty(await PaiwiseProcessor.ProcessPayment(PaymentUri, EDaler)))
                        {
                            await RejectContract(Contract, ContractIsLocked, "Unable to process payment for token creation. Tokens not created.",
                                true, Legal, EDaler, "TokenPayment",
                                new KeyValuePair<string, object>("Creator", CreatorId),
                                new KeyValuePair<string, object>("Owner", OwnerId),
                                new KeyValuePair<string, object>("Value", Value),
                                new KeyValuePair<string, object>("Commission", Commission),
                                new KeyValuePair<string, object>("Currency", Currency));
 
                            return false;
                        }
                    }
 
                    await Database.Insert(Tokens);
 
                    if (!(StateMachines is null))
                        await Database.Insert(StateMachines.Keys);
 
                    if (!(TagReferences is null) && TagReferences.Count > 0)
                    {
                        try
                        {
                            List<TokenTag> Tags = new List<TokenTag>();
 
                            foreach (Token Token in Tokens)
                            {
                                foreach (TokenTagReference TagRef in TagReferences.Values)
                                    Tags.Add(TagRef.CreateTag(Token));
                            }
 
                            await Database.Insert(Tags);
                        }
                        catch (Exception ex)
                        {
                            Log.Exception(ex);
                        }
                    }
 
                    try
                    {
                        List<TokenEvent> Events = new List<TokenEvent>();
 
                        foreach (Token Token in Tokens)
                        {
                            Events.Add(new Created()
                            {
                                ArchiveOptional = Token.ArchiveOptional,
                                ArchiveRequired = Token.ArchiveRequired,
                                Expires = Token.Expires,
                                Creator = Token.Creator,
                                Owner = Token.Owner,
                                Currency = Token.Currency,
                                Value = Token.Value,
                                OwnershipContract = Contract.ContractId,
                                TokenId = Token.TokenId,
                                Timestamp = DateTime.UtcNow,
                                Personal = false
                            });
                        }
 
                        await Database.Insert(Events);
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                    }
 
                    // TODO: Protect integrity with transaction, commit, rollback, etc.
                }
                finally
                {
                    await Database.EndBulk();
                }
            }
 
            if (!(StateMachines is null))
            {
                foreach (KeyValuePair<StateMachine, Token> P in StateMachines)
                    await StateMachineProcessor.Start(P.Key, P.Value, Legal, EDaler);
            }
 
            if (!CaseInsensitiveString.IsNullOrEmpty(OwnerJid))
            {
                StringBuilder Xml = new StringBuilder();
 
                foreach (Token Token in Tokens)
                {
                    Xml.Clear();
 
                    Xml.Append("<tokenAdded xmlns='");
                    Xml.Append(NeuroFeaturesNamespace);
                    Xml.Append("'>");
                    await Token.Serialize(Xml, false, true);
                    Xml.Append("</tokenAdded>");
 
                    if (await SendTokenMessage(EDaler, Xml.ToString(), OwnerJid, true, true))
                        await TokenAdded(Token, OwnerJid);
                }
            }
 
            return true;
        }
 
        internal static Task<bool> SendTokenMessage(EDalerComponent EDaler, string Xml, string RecipientJid, bool ToClient, bool ToBroker)
        {
            return SendTokenMessage(EDaler, Xml, new XmppAddress(RecipientJid), ToClient, ToBroker);
        }
 
        internal static async Task<bool> SendTokenMessage(EDalerComponent EDaler, string Xml, XmppAddress Recipient, bool ToClient, bool ToBroker)
        {
            if (ToClient)
            {
                await EDaler.Server.SendMessage(string.Empty, string.Empty, EDaler.MainDomain, Recipient,
                    string.Empty, Xml);
            }
 
            if (EDaler.Server.IsServerDomain(Recipient.Domain, true))
                return true;
            else
            {
                if (ToBroker)
                {
                    CaseInsensitiveString Component = await EDaler.Legal.GetComponent(Recipient.Domain, NeuroFeaturesNamespace);
                    if (!CaseInsensitiveString.IsNullOrEmpty(Component))
                        await ComponentSynchronization.SendMessage(EDaler.MainDomain.Address, Component, Recipient.Domain, Xml);
                }
 
                return false;
            }
        }
 
        private static string CalcShortId(string TokenId, int ShortIdLength, string ShortIdAlphabet)
        {
            if (ShortIdLength <= 0)
                return string.Empty;
 
            byte[] Bin = Hashes.ComputeSHA256Hash(Encoding.UTF8.GetBytes(TokenId));
            int i, j, c = Bin.Length;
 
            for (i = 4, j = 0; i < c; i++, j = (j + 1) & 3)
                Bin[j] ^= Bin[i];
 
            int Seed = BitConverter.ToInt32(Bin, 0);
            Random Rnd = new Random(Seed);
            char[] ch = new char[ShortIdLength];
 
            c = ShortIdAlphabet.Length;
            if (c <= 0)
                return string.Empty;
 
            for (i = 0; i < ShortIdLength; i++)
                ch[i] = ShortIdAlphabet[Rnd.Next(c)];
 
            return new string(ch);
        }
 
        public static async Task<Dictionary<string, object>> ReindexTokenReferences()
        {
            Dictionary<string, object> Counts = new Dictionary<string, object>();
            IEnumerable<Token> Tokens = await Database.Find<Token>();
            StringBuilder Xml = new StringBuilder();
 
            foreach (Token Token in Tokens)
            {
                Xml.Clear();
 
                Xml.Append("<tokenAdded xmlns='");
                Xml.Append(NeuroFeaturesNamespace);
                Xml.Append("'>");
                await Token.Serialize(Xml, false, true);
                Xml.Append("</tokenAdded>");
 
                XmppAddress Owner = new XmppAddress(Token.OwnerJid);
 
                if (await SendTokenMessage(eDaler, Xml.ToString(), Owner, false, true))
                {
                    await TokenAdded(Token, Token.OwnerJid);
                    Inc(Counts, eDaler.Server.Domain);
                }
                else
                    Inc(Counts, Owner.Domain);
            }
 
            return Counts;
        }
 
        public static async Task<Dictionary<string, object>> TokenOwnerStatistics()
        {
            Dictionary<string, object> Counts = new Dictionary<string, object>();
            IEnumerable<Token> Tokens = await Database.Find<Token>();
 
            foreach (Token Token in Tokens)
            {
                XmppAddress Owner = new XmppAddress(Token.OwnerJid);
                Inc(Counts, Owner.Domain);
            }
 
            return Counts;
        }
 
        private static void Inc(Dictionary<string, object> Counts, string Key)
        {
            if (Counts.TryGetValue(Key, out object Obj) && Obj is int Count)
                Counts[Key] = Count + 1;
            else
                Counts[Key] = 1;
        }
 
        #endregion
 
        #region Destroy Contract
 
        private static async Task<bool> DestroyTokens(XmlElement Destroy, Contract Contract, bool ContractIsLocked, string TrustProviderRole, LegalComponent Legal,
            EDalerComponent EDaler)
        {
            List<string> TokenIDs = new List<string>();
 
            foreach (XmlElement E in Destroy.ChildNodes)
            {
                if (E.NamespaceURI == Contract.ForMachinesNamespace)
                {
                    switch (E.LocalName)
                    {
                        case "TokenID":
                            if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is string TokenId))
                                return false;
 
                            TokenIDs.Add(TokenId);
                            break;
                    }
                }
            }
 
            if (TokenIDs.Count == 0)
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token destruction contract: No Token IDs.", true, Legal, EDaler);
                return false;
            }
 
            Dictionary<string, KeyValuePair<string, Token>> AuthorizedBy = new Dictionary<string, KeyValuePair<string, Token>>();
            Dictionary<string, KeyValuePair<string, List<Token>>> TokensPerBatch = new Dictionary<string, KeyValuePair<string, List<Token>>>();
            List<Token> Tokens = new List<Token>();
            int i;
 
            using (Semaphore Lock = await Semaphores.BeginWrite("NeuroFeature.Tokens.IDs"))     // Only for creation and destruction
            {
                foreach (string TokenID in TokenIDs)
                {
                    Token Token = await GetToken(TokenID, false);
 
                    if (Token is null)
                    {
                        await RejectContract(Contract, ContractIsLocked, "Rejected token destruction contract: Token referenced that does not exist.", true, Legal, EDaler);
                        return false;
                    }
                    else if (!Contract.Duration.HasValue ||
                        DateTime.UtcNow.Date + Contract.Duration.Value < Token.Expires.AddDays(1))
                    {
                        await RejectContract(Contract, ContractIsLocked, "Rejected token destruction contract: Duration must cover token expiry date.", true, Legal, EDaler);
                        return false;
                    }
                    else
                    {
                        if (!(Contract.ClientSignatures is null))
                        {
                            foreach (ClientSignature Signature in Contract.ClientSignatures)
                            {
                                if (Signature.LegalId == Token.Creator ||
                                    Signature.BareJid == Token.CreatorJid)
                                {
                                    if (Token.CreatorCanDestroy)
                                    {
                                        AuthorizedBy[TokenID] = new KeyValuePair<string, Token>(Signature.LegalId, Token);
                                        break;
                                    }
                                }
 
                                if (Signature.LegalId == Token.Owner ||
                                    Signature.BareJid == Token.OwnerJid)
                                {
                                    if (Token.OwnerCanDestroyIndividual)
                                    {
                                        AuthorizedBy[TokenID] = new KeyValuePair<string, Token>(Signature.LegalId, Token);
                                        break;
                                    }
                                    else if (Token.OwnerCanDestroyBatch)
                                    {
                                        if (!TokensPerBatch.TryGetValue(Token.CreationContract, out KeyValuePair<string, List<Token>> TokensInBatch))
                                        {
                                            TokensInBatch = new KeyValuePair<string, List<Token>>(Signature.LegalId, new List<Token>());
                                            TokensPerBatch[Token.CreationContract] = TokensInBatch;
                                        }
 
                                        TokensInBatch.Value.Add(Token);
                                    }
                                }
 
                                if (!(Token.Certifier is null))
                                {
                                    int c = Token.Certifier.Length;
 
                                    for (i = 0; i < c; i++)
                                    {
                                        if (Signature.LegalId == Token.Certifier[i] ||
                                            Signature.BareJid == Token.CertifierJids[i])
                                        {
                                            if (Token.CertifierCanDestroy)
                                            {
                                                AuthorizedBy[TokenID] = new KeyValuePair<string, Token>(Signature.LegalId, Token);
                                                break;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
 
                if (TokensPerBatch.Count > 0)
                {
                    foreach (KeyValuePair<string, List<Token>> TokensInBatch in TokensPerBatch.Values)
                    {
                        if (TokensInBatch.Value[0].BatchSize == TokensInBatch.Value.Count)
                        {
                            foreach (Token Token in TokensInBatch.Value)
                                AuthorizedBy[Token.TokenId] = new KeyValuePair<string, Token>(TokensInBatch.Key, Token);
                        }
                    }
                }
 
                if (AuthorizedBy.Count != TokenIDs.Count)
                {
                    await RejectContract(Contract, ContractIsLocked, "Rejected token destruction contract: Not authorized to destroy token referenced in contract.", true, Legal, EDaler);
                    return false;
                }
 
                if (await MarketplaceProcessor.SignContract(Contract, ContractIsLocked, Legal, TrustProviderRole) is null)
                    return false;
 
                List<TokenEvent> Events = new List<TokenEvent>();
 
                foreach (KeyValuePair<string, Token> P in AuthorizedBy.Values)
                {
                    Destroyed Event = new Destroyed()
                    {
                        ArchiveOptional = P.Value.ArchiveOptional,
                        ArchiveRequired = P.Value.ArchiveRequired,
                        Expires = P.Value.Expires,
                        Owner = P.Key,
                        OwnershipContract = Contract.ContractId,
                        TokenId = P.Value.TokenId,
                        Value = 0,
                        Currency = string.Empty,
                        Timestamp = DateTime.UtcNow,
                        Personal = false
                    };
 
                    Tokens.Add(P.Value);
                    Events.Add(Event);
                }
 
                await Database.StartBulk();
                try
                {
                    await DeletePersonalEvents(TokenIDs);
                    await Database.Delete(Tokens);
 
                    try
                    {
                        await Database.Insert(Events);
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                    }
 
                    foreach (Token Token in Tokens)
                    {
                        tokenCache.Remove(Token.TokenId);
                        if (CaseInsensitiveString.IsNullOrEmpty(Token.ShortId))
                            tokenCache.Remove(Token.ShortId);
                    }
 
                    // TODO: Protect integrity with transaction, commit, rollback, etc.
                }
                finally
                {
                    await Database.EndBulk();
                }
 
                i = 0;
                foreach (KeyValuePair<string, Token> P in AuthorizedBy.Values)
                    await StateMachineProcessor.EventGenerated(P.Value, Events[i++]);
            }
 
            StringBuilder Xml = new StringBuilder();
 
            foreach (Token Token in Tokens)
            {
                string PrevOwner = Token.OwnerJid;
 
                if (!string.IsNullOrEmpty(PrevOwner))
                {
                    Token.Owner = string.Empty;
                    Token.OwnerJid = string.Empty;
                    Token.OwnershipContract = Contract.ContractId;
                    await Token.Sign();
 
                    Xml.Clear();
 
                    Xml.Append("<tokenRemoved xmlns='");
                    Xml.Append(NeuroFeaturesNamespace);
                    Xml.Append("'>");
                    await Token.Serialize(Xml, false, true);
                    Xml.Append("</tokenRemoved>");
 
                    if (await SendTokenMessage(EDaler, Xml.ToString(), PrevOwner, true, true))
                        await TokenRemoved(Token, PrevOwner);
                }
            }
 
            return true;
        }
 
        internal static async Task DestroyToken(Token Token, EDalerComponent EDaler)
        {
            await DeletePersonalEvents(new string[] { Token.TokenId });
            await Database.Delete(Token);
 
            Destroyed Event = new Destroyed()
            {
                ArchiveOptional = Token.ArchiveOptional,
                ArchiveRequired = Token.ArchiveRequired,
                Expires = Token.Expires,
                Owner = Token.Owner,
                OwnershipContract = Token.OwnershipContract,
                TokenId = Token.TokenId,
                Value = 0,
                Currency = string.Empty,
                Timestamp = DateTime.UtcNow,
                Personal = false
            };
 
            await Database.Insert(Event);
 
            tokenCache.Remove(Token.TokenId);
            if (CaseInsensitiveString.IsNullOrEmpty(Token.ShortId))
                tokenCache.Remove(Token.ShortId);
 
            // TODO: Protect integrity with transaction, commit, rollback, etc.
 
            await StateMachineProcessor.EventGenerated(Token, Event);
 
            string PrevOwner = Token.OwnerJid;
            if (!string.IsNullOrEmpty(PrevOwner))
            {
                StringBuilder Xml = new StringBuilder();
 
                Token.Owner = string.Empty;
                Token.OwnerJid = string.Empty;
                Token.OwnershipContract = string.Empty;
                await Token.Sign();
 
                Xml.Clear();
 
                Xml.Append("<tokenRemoved xmlns='");
                Xml.Append(NeuroFeaturesNamespace);
                Xml.Append("'>");
                await Token.Serialize(Xml, false, true);
                Xml.Append("</tokenRemoved>");
 
                if (await SendTokenMessage(EDaler, Xml.ToString(), PrevOwner, true, true))
                    await TokenRemoved(Token, PrevOwner);
            }
        }
 
        internal static async Task DeletePersonalEvents(IEnumerable<string> TokenIds)
        {
            foreach (string TokenId in TokenIds)
            {
                try
                {
                    await Database.Delete<TokenEvent>(new FilterAnd(
                        new FilterFieldEqualTo("TokenId", TokenId),
                        new FilterFieldEqualTo("Personal", true)));
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            }
        }
 
        #endregion
 
        #region Transfer Contract
 
        private static async Task<bool> TransferTokens(XmlElement Transfer, Contract Contract, bool ContractIsLocked, string TrustProviderRole, LegalComponent Legal,
            EDalerComponent EDaler)
        {
            List<string> TokenIDs = new List<string>();
            string Currency = null;
            string OwnershipContract = null;
            decimal? Value = null;
            decimal? CommissionPercent = null;
 
            foreach (XmlElement E in Transfer.ChildNodes)
            {
                if (E.NamespaceURI == Contract.ForMachinesNamespace)
                {
                    switch (E.LocalName)
                    {
                        case "TokenID":
                            if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is string TokenId))
                                return false;
 
                            TokenIDs.Add(TokenId);
                            break;
 
                        case "Value":
                            if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is decimal d))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid value.", true, Legal, EDaler);
                                return false;
                            }
 
                            Value = d;
                            break;
 
                        case "Currency":
                            if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is string s))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid currency.", true, Legal, EDaler);
                                return false;
                            }
 
                            Currency = s;
                            break;
 
                        case "CommissionPercent":
                            if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is decimal d2) || d2 < 0 || d2 > 100)
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid commission (%).", true, Legal, EDaler);
                                return false;
                            }
 
                            CommissionPercent = d2;
                            break;
 
                        case "OwnershipContract":
                            if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is string s2))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid Ownership contract reference.", true, Legal, EDaler);
                                return false;
                            }
 
                            OwnershipContract = s2;
                            break;
                    }
                }
            }
 
            if (TokenIDs.Count == 0)
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token transfer contract: No Token IDs.", true, Legal, EDaler);
                return false;
            }
 
            if (!Value.HasValue || Value.Value <= 0)
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token transfer contract: Value must be positive.", true, Legal, EDaler);
                return false;
            }
 
            if (string.IsNullOrEmpty(Currency) || Currency.Length != 3)
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token transfer contract: Invalid currency.", true, Legal, EDaler);
                return false;
            }
 
            if (!CommissionPercent.HasValue)
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token transfer contract: Commission missing.", true, Legal, EDaler);
                return false;
            }
 
            if (CommissionPercent.Value < await MarketplaceProcessor.GetMinCommission())
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token transfer contract: Commission too low.", true, Legal, EDaler);
                return false;
            }
 
            List<Token> Tokens = new List<Token>();
            CaseInsensitiveString SellerId = null;
            CaseInsensitiveString SellerJid = null;
            CaseInsensitiveString BuyerId = null;
            CaseInsensitiveString BuyerJid = null;
            CaseInsensitiveString TrustProviderId = null;
 
            using (Semaphore Lock = await Semaphores.BeginRead("NeuroFeature.Tokens.IDs"))     // Will only read, not change Token IDs in the system
            {
                foreach (string TokenID in TokenIDs)
                {
                    Token Token = await GetToken(TokenID, false);
 
                    if (Token is null)
                    {
                        await RejectContract(Contract, ContractIsLocked, "Rejected token transfer contract: Token referenced that does not exist.", true, Legal, EDaler);
                        return false;
                    }
                    else if (Token.OwnershipContract != OwnershipContract)
                    {
                        await RejectContract(Contract, ContractIsLocked, "Rejected token transfer contract: Incorrect ownership contract reference.", true, Legal, EDaler);
                        return false;
                    }
                    else if (!Contract.Duration.HasValue ||
                        DateTime.UtcNow.Date + Contract.Duration.Value < Token.Expires.AddDays(1))
                    {
                        await RejectContract(Contract, ContractIsLocked, "Rejected token transfer contract: Duration must cover token expiry date.", true, Legal, EDaler);
                        return false;
                    }
                    else
                    {
                        if (!(Contract.ClientSignatures is null))
                        {
                            foreach (ClientSignature Signature in Contract.ClientSignatures)
                            {
                                bool Identified = false;
 
                                if (Signature.LegalId == Token.Owner || Signature.BareJid == Token.OwnerJid)
                                {
                                    if (CaseInsensitiveString.IsNullOrEmpty(SellerId))
                                    {
                                        SellerId = Signature.LegalId;
                                        SellerJid = Signature.BareJid;
                                    }
                                    else if (SellerId != Signature.LegalId)
                                    {
                                        await RejectContract(Contract, ContractIsLocked, "Rejected token transfer contract: Multiple sellers in one contract not permitted.", true, Legal, EDaler);
                                        return false;
                                    }
 
                                    Identified = true;
                                }
 
                                if (Signature.LegalId == Token.TrustProvider || Signature.BareJid == Token.TrustProviderJid)
                                {
                                    if (CaseInsensitiveString.IsNullOrEmpty(TrustProviderId))
                                    {
                                        if (!LegalIdentityConfiguration.IsMeApproved(Signature.LegalId))
                                        {
                                            // TODO: Forward contract in message to intended trust provider, to validate transaction.
                                            await RejectContract(Contract, ContractIsLocked, "Rejected token transfer contract: Token not hosted by this trust provider.", true, Legal, EDaler);
                                            return false;
                                        }
 
                                        TrustProviderId = Signature.LegalId;
                                    }
                                    else if (TrustProviderId != Signature.LegalId)
                                    {
                                        await RejectContract(Contract, ContractIsLocked, "Rejected token transfer contract: Multiple trust providers in one contract not permitted.", true, Legal, EDaler);
                                        return false;
                                    }
 
                                    Identified = true;
                                }
 
                                if (!Identified)
                                {
                                    if (CaseInsensitiveString.IsNullOrEmpty(BuyerId))
                                    {
                                        BuyerId = Signature.LegalId;
                                        BuyerJid = Signature.BareJid;
                                    }
                                    else if (BuyerId != Signature.LegalId)
                                    {
                                        await RejectContract(Contract, ContractIsLocked, "Rejected token transfer contract: Only one buyer allowed (buyer=not current owner or trust provider).", true, Legal, EDaler);
                                        return false;
                                    }
                                }
                            }
 
                            if (CaseInsensitiveString.IsNullOrEmpty(SellerId) || CaseInsensitiveString.IsNullOrEmpty(SellerJid))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token transfer contract: No seller identified for token.", true, Legal, EDaler);
                                return false;
                            }
 
                            if (CaseInsensitiveString.IsNullOrEmpty(BuyerId) || CaseInsensitiveString.IsNullOrEmpty(BuyerJid))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token transfer contract: No buyer identified for token.", true, Legal, EDaler);
                                return false;
                            }
 
                            if (!CaseInsensitiveString.IsNullOrEmpty(TrustProviderId))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token transfer contract: Trust provider already signed.", true, Legal, EDaler);
                                return false;
                            }
 
                            Tokens.Add(Token);
                        }
                    }
                }
 
                if (Tokens.Count != TokenIDs.Count)
                {
                    await RejectContract(Contract, ContractIsLocked, "Rejected token transfer contract: Not authorized to transfer token referenced in contract.", true, Legal, EDaler);
                    return false;
                }
 
                if (SellerJid == BuyerJid)
                {
                    await RejectContract(Contract, ContractIsLocked, "Rejected token transfer contract: Buyer and Seller cannot be the same.", true, Legal, EDaler);
                    return false;
                }
 
                if (await MarketplaceProcessor.SignContract(Contract, ContractIsLocked, Legal, TrustProviderRole) is null)
                    return false;
 
                int i = Contract.ContractId.IndexOf('@');
                if (i <= 0 || !Guid.TryParse(Contract.ContractId.Substring(0, i), out Guid TransactionId))
                    TransactionId = Guid.NewGuid();
 
                decimal Total = Value.Value * TokenIDs.Count;
                decimal Commission = Total * CommissionPercent.Value * 0.01m;
                string Ref = "iotsc:" + Contract.ContractId;
 
                string PaymentUri1 = PaiwiseProcessor.GenerateContractualPaymentUri(TransactionId, BuyerId, true,
                    SellerId, true, Currency, Total, null, Ref, Contract.ContractId, null, 1, out _, out _);
 
                if (!string.IsNullOrEmpty(await PaiwiseProcessor.ProcessPayment(PaymentUri1, EDaler)))
                {
                    await RejectContract(Contract, ContractIsLocked, "Unable to process payment for token transfer. Tokens not created.",
                        true, Legal, EDaler, "TokenPayment",
                        new KeyValuePair<string, object>("Buyer", BuyerId.Value),
                        new KeyValuePair<string, object>("Seller", SellerId.Value),
                        new KeyValuePair<string, object>("Value", Value),
                        new KeyValuePair<string, object>("Commission", Commission),
                        new KeyValuePair<string, object>("Currency", Currency));
 
                    return false;
                }
 
                if (Commission > 0)
                {
                    string PaymentUri2 = PaiwiseProcessor.GenerateContractualPaymentUri(Guid.NewGuid(), SellerId, true,
                        Gateway.ContractsClient.Client.BareJID, false, Currency, Commission, null, Ref,
                        Contract.ContractId, null, 1, out _, out _);
 
                    if (!string.IsNullOrEmpty(await PaiwiseProcessor.ProcessPayment(PaymentUri2, EDaler)))
                    {
                        await RejectContract(Contract, ContractIsLocked, "Unable to process commission payment for token transfer.",
                            false, Legal, EDaler, "TokenPayment",
                            new KeyValuePair<string, object>("Buyer", BuyerId.Value),
                            new KeyValuePair<string, object>("Seller", SellerId.Value),
                            new KeyValuePair<string, object>("Value", Value),
                            new KeyValuePair<string, object>("Commission", Commission),
                            new KeyValuePair<string, object>("Currency", Currency));
                    }
                }
 
                List<TokenEvent> Events = new List<TokenEvent>();
 
                foreach (Token Token in Tokens)
                {
                    Token.Value = Value.Value;
                    Token.Currency = Currency;
                    Token.Owner = BuyerId;
                    Token.OwnerJid = BuyerJid;
                    Token.OwnershipContract = Contract.ContractId;
                    await Token.Sign();
 
                    Events.Add(new Transferred()
                    {
                        ArchiveOptional = Token.ArchiveOptional,
                        ArchiveRequired = Token.ArchiveRequired,
                        Expires = Token.Expires,
                        Seller = SellerId,
                        Owner = BuyerId,
                        OwnershipContract = Contract.ContractId,
                        Value = Value.Value,
                        Commission = Commission,
                        Currency = Currency,
                        TokenId = Token.TokenId,
                        Timestamp = DateTime.UtcNow,
                        Personal = false
                    });
                }
 
                await Database.StartBulk();
                try
                {
                    await DeletePersonalEvents(TokenIDs);
                    await Database.Update(Tokens);
 
                    try
                    {
                        await Database.Insert(Events);
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                    }
 
                    // TODO: Protect integrity with transaction, commit, rollback, etc.
                }
                finally
                {
                    await Database.EndBulk();
                }
 
                int c = Tokens.Count;
 
                for (i = 0; i < c; i++)
                {
                    try
                    {
                        await StateMachineProcessor.EventGenerated(Tokens[i], Events[i]);
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex, Tokens[i].TokenId.Value);
                    }
                }
            }
 
            StringBuilder Xml = new StringBuilder();
 
            foreach (Token Token in Tokens)
            {
                Xml.Clear();
 
                Xml.Append("<tokenRemoved xmlns='");
                Xml.Append(NeuroFeaturesNamespace);
                Xml.Append("'>");
                await Token.Serialize(Xml, false, true);
                Xml.Append("</tokenRemoved>");
 
                if (await SendTokenMessage(EDaler, Xml.ToString(), SellerJid, true, true))
                    await TokenRemoved(Token, SellerJid);
 
                Xml.Clear();
 
                Xml.Append("<tokenAdded xmlns='");
                Xml.Append(NeuroFeaturesNamespace);
                Xml.Append("'>");
                await Token.Serialize(Xml, false, true);
                Xml.Append("</tokenAdded>");
 
                if (await SendTokenMessage(EDaler, Xml.ToString(), BuyerJid, true, true))
                    await TokenAdded(Token, BuyerJid);
            }
 
            return true;
        }
 
        #endregion
 
        #region Donate Contract
 
        private static async Task<bool> DonateTokens(XmlElement Donate, Contract Contract, bool ContractIsLocked, string TrustProviderRole, LegalComponent Legal,
            EDalerComponent EDaler)
        {
            List<string> TokenIDs = new List<string>();
            string OwnershipContract = null;
 
            foreach (XmlElement E in Donate.ChildNodes)
            {
                if (E.NamespaceURI == Contract.ForMachinesNamespace)
                {
                    switch (E.LocalName)
                    {
                        case "TokenID":
                            if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is string TokenId))
                                return false;
 
                            TokenIDs.Add(TokenId);
                            break;
 
                        case "OwnershipContract":
                            if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is string s2))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token creation contract: Invalid Ownership contract reference.", true, Legal, EDaler);
                                return false;
                            }
 
                            OwnershipContract = s2;
                            break;
                    }
                }
            }
 
            if (TokenIDs.Count == 0)
            {
                await RejectContract(Contract, ContractIsLocked, "Rejected token donation contract: No Token IDs.", true, Legal, EDaler);
                return false;
            }
 
            List<Token> Tokens = new List<Token>();
            CaseInsensitiveString DonorId = null;
            CaseInsensitiveString DonorJid = null;
            CaseInsensitiveString RecipientId = null;
            CaseInsensitiveString RecipientJid = null;
            CaseInsensitiveString TrustProviderId = null;
 
            using (Semaphore Lock = await Semaphores.BeginRead("NeuroFeature.Tokens.IDs"))     // Will only read, not change Token IDs in the system
            {
                foreach (string TokenID in TokenIDs)
                {
                    Token Token = await GetToken(TokenID, false);
 
                    if (Token is null)
                    {
                        await RejectContract(Contract, ContractIsLocked, "Rejected token donation contract: Token referenced that does not exist.", true, Legal, EDaler);
                        return false;
                    }
                    else if (Token.OwnershipContract != OwnershipContract)
                    {
                        await RejectContract(Contract, ContractIsLocked, "Rejected token donation contract: Incorrect ownership contract reference.", true, Legal, EDaler);
                        return false;
                    }
                    else if (!Contract.Duration.HasValue ||
                        DateTime.UtcNow.Date + Contract.Duration.Value < Token.Expires.AddDays(1))
                    {
                        await RejectContract(Contract, ContractIsLocked, "Rejected token donation contract: Duration must cover token expiry date.", true, Legal, EDaler);
                        return false;
                    }
                    else
                    {
                        if (!(Contract.ClientSignatures is null))
                        {
                            foreach (ClientSignature Signature in Contract.ClientSignatures)
                            {
                                bool Identified = false;
 
                                if (Signature.LegalId == Token.Owner || Signature.BareJid == Token.OwnerJid)
                                {
                                    if (CaseInsensitiveString.IsNullOrEmpty(DonorId))
                                    {
                                        DonorId = Signature.LegalId;
                                        DonorJid = Signature.BareJid;
                                    }
                                    else if (DonorId != Signature.LegalId)
                                    {
                                        await RejectContract(Contract, ContractIsLocked, "Rejected token donation contract: Multiple donors in one contract not permitted.", true, Legal, EDaler);
                                        return false;
                                    }
 
                                    Identified = true;
                                }
 
                                if (Signature.LegalId == Token.TrustProvider || Signature.BareJid == Token.TrustProviderJid)
                                {
                                    if (CaseInsensitiveString.IsNullOrEmpty(TrustProviderId))
                                    {
                                        if (!LegalIdentityConfiguration.IsMeApproved(Signature.LegalId))
                                        {
                                            // TODO: Forward contract in message to intended trust provider, to validate transaction.
                                            await RejectContract(Contract, ContractIsLocked, "Rejected token donation contract: Token not hosted by this trust provider.", true, Legal, EDaler);
                                            return false;
                                        }
 
                                        TrustProviderId = Signature.LegalId;
                                    }
                                    else if (TrustProviderId != Signature.LegalId)
                                    {
                                        await RejectContract(Contract, ContractIsLocked, "Rejected token donation contract: Multiple trust providers in one contract not permitted.", true, Legal, EDaler);
                                        return false;
                                    }
 
                                    Identified = true;
                                }
 
                                if (!Identified)
                                {
                                    if (CaseInsensitiveString.IsNullOrEmpty(RecipientId))
                                    {
                                        RecipientId = Signature.LegalId;
                                        RecipientJid = Signature.BareJid;
                                    }
                                    else if (RecipientId != Signature.LegalId)
                                    {
                                        await RejectContract(Contract, ContractIsLocked, "Rejected token donation contract: Only one recipient allowed (recipient=not current owner or trust provider).", true, Legal, EDaler);
                                        return false;
                                    }
                                }
                            }
 
                            if (CaseInsensitiveString.IsNullOrEmpty(DonorId) || CaseInsensitiveString.IsNullOrEmpty(DonorJid))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token donation contract: No donor identified for token.", true, Legal, EDaler);
                                return false;
                            }
 
                            if (CaseInsensitiveString.IsNullOrEmpty(RecipientId) || CaseInsensitiveString.IsNullOrEmpty(RecipientJid))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token donation contract: No recipient identified for token.", true, Legal, EDaler);
                                return false;
                            }
 
                            if (!CaseInsensitiveString.IsNullOrEmpty(TrustProviderId))
                            {
                                await RejectContract(Contract, ContractIsLocked, "Rejected token donation contract: Trust provider already signed.", true, Legal, EDaler);
                                return false;
                            }
 
                            Tokens.Add(Token);
                        }
                    }
                }
 
                if (Tokens.Count != TokenIDs.Count)
                {
                    await RejectContract(Contract, ContractIsLocked, "Rejected token donation contract: Not authorized to donate token referenced in contract.", true, Legal, EDaler);
                    return false;
                }
 
                if (DonorJid == RecipientJid)
                {
                    await RejectContract(Contract, ContractIsLocked, "Rejected token donation contract: Donor and Recipient cannot be the same.", true, Legal, EDaler);
                    return false;
                }
 
                if (await MarketplaceProcessor.SignContract(Contract, ContractIsLocked, Legal, TrustProviderRole) is null)
                    return false;
 
                int i = Contract.ContractId.IndexOf('@');
                if (i <= 0 || !Guid.TryParse(Contract.ContractId.Substring(0, i), out Guid TransactionId))
                    TransactionId = Guid.NewGuid();
 
                List<TokenEvent> Events = new List<TokenEvent>();
 
                foreach (Token Token in Tokens)
                {
                    Token.Owner = RecipientId;
                    Token.OwnerJid = RecipientJid;
                    Token.OwnershipContract = Contract.ContractId;
                    await Token.Sign();
 
                    Events.Add(new Donated()
                    {
                        ArchiveOptional = Token.ArchiveOptional,
                        ArchiveRequired = Token.ArchiveRequired,
                        Expires = Token.Expires,
                        Donor = DonorId,
                        Owner = RecipientId,
                        OwnershipContract = Contract.ContractId,
                        Value = Token.Value,
                        Currency = Token.Currency,
                        TokenId = Token.TokenId,
                        Timestamp = DateTime.UtcNow,
                        Personal = false
                    });
                }
 
                await Database.StartBulk();
                try
                {
                    await DeletePersonalEvents(TokenIDs);
                    await Database.Update(Tokens);
 
                    try
                    {
                        await Database.Insert(Events);
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                    }
 
                    // TODO: Protect integrity with transaction, commit, rollback, etc.
                }
                finally
                {
                    await Database.EndBulk();
                }
 
                int c = Tokens.Count;
 
                for (i = 0; i < c; i++)
                {
                    try
                    {
                        await StateMachineProcessor.EventGenerated(Tokens[i], Events[i]);
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex, Tokens[i].TokenId.Value);
                    }
                }
            }
 
            StringBuilder Xml = new StringBuilder();
 
            foreach (Token Token in Tokens)
            {
                Xml.Clear();
 
                Xml.Append("<tokenRemoved xmlns='");
                Xml.Append(NeuroFeaturesNamespace);
                Xml.Append("'>");
                await Token.Serialize(Xml, false, true);
                Xml.Append("</tokenRemoved>");
 
                if (await SendTokenMessage(EDaler, Xml.ToString(), DonorJid, true, true))
                    await TokenRemoved(Token, DonorJid);
 
                Xml.Clear();
 
                Xml.Append("<tokenAdded xmlns='");
                Xml.Append(NeuroFeaturesNamespace);
                Xml.Append("'>");
                await Token.Serialize(Xml, false, true);
                Xml.Append("</tokenAdded>");
 
                if (await SendTokenMessage(EDaler, Xml.ToString(), RecipientJid, true, true))
                    await TokenAdded(Token, RecipientJid);
            }
 
            return true;
        }
 
        #endregion
 
 
        #endregion
 
        #region XMPP interface
 
        private static EDalerComponent eDaler = null;
        private static LegalComponent legal = null;
 
        #region Handlers
 
        internal static void RegisterHandlers(EDalerComponent EDaler)
        {
            eDaler = EDaler;
 
            EDaler.RegisterIqGetHandler("token", NeuroFeaturesNamespace, GetTokenHandler, true);
            EDaler.RegisterIqGetHandler("tokens", NeuroFeaturesNamespace, GetTokensHandler, false);
            EDaler.RegisterIqGetHandler("totals", NeuroFeaturesNamespace, GetTotalsHandler, false);
            EDaler.RegisterIqSetHandler("noteText", NeuroFeaturesNamespace, SetNoteTextHandler, false);
            EDaler.RegisterIqSetHandler("noteXml", NeuroFeaturesNamespace, SetNoteXmlHandler, false);
            EDaler.RegisterIqGetHandler("events", NeuroFeaturesNamespace, GetEventsHandler, false);
            EDaler.RegisterIqGetHandler("creationAttributes", NeuroFeaturesNamespace, GetCreationAttributesHandler, false);
            EDaler.RegisterIqGetHandler("description", NeuroFeaturesNamespace, GetDescriptionHandler, false);
 
            EDaler.RegisterIqSetHandler("tokenAdded", NeuroFeaturesNamespace, TokenAddedIqHandler, false);
            EDaler.RegisterMessageHandler("tokenAdded", NeuroFeaturesNamespace, TokenAddedMessageHandler, false);
            EDaler.RegisterIqSetHandler("tokenRemoved", NeuroFeaturesNamespace, TokenRemovedIqHandler, false);
            EDaler.RegisterMessageHandler("tokenRemoved", NeuroFeaturesNamespace, TokenRemovedMessageHandler, false);
        }
 
        internal static void UnregisterHandlers(EDalerComponent EDaler)
        {
            eDaler = null;
 
            EDaler.UnregisterIqGetHandler("token", NeuroFeaturesNamespace, GetTokenHandler, true);
            EDaler.UnregisterIqGetHandler("tokens", NeuroFeaturesNamespace, GetTokensHandler, false);
            EDaler.UnregisterIqGetHandler("totals", NeuroFeaturesNamespace, GetTotalsHandler, false);
            EDaler.UnregisterIqSetHandler("noteText", NeuroFeaturesNamespace, SetNoteTextHandler, false);
            EDaler.UnregisterIqSetHandler("noteXml", NeuroFeaturesNamespace, SetNoteXmlHandler, false);
            EDaler.UnregisterIqGetHandler("events", NeuroFeaturesNamespace, GetEventsHandler, false);
            EDaler.UnregisterIqGetHandler("creationAttributes", NeuroFeaturesNamespace, GetCreationAttributesHandler, false);
            EDaler.UnregisterIqGetHandler("description", NeuroFeaturesNamespace, GetDescriptionHandler, false);
 
            EDaler.UnregisterIqSetHandler("tokenAdded", NeuroFeaturesNamespace, TokenAddedIqHandler, false);
            EDaler.UnregisterMessageHandler("tokenAdded", NeuroFeaturesNamespace, TokenAddedMessageHandler, false);
            EDaler.UnregisterIqSetHandler("tokenRemoved", NeuroFeaturesNamespace, TokenRemovedIqHandler, false);
            EDaler.UnregisterMessageHandler("tokenRemoved", NeuroFeaturesNamespace, TokenRemovedMessageHandler, false);
        }
 
        internal static void RegisterHandlers(LegalComponent Legal)
        {
            legal = Legal;
 
            Legal.RegisterIqGetHandler("contractTokens", NeuroFeaturesNamespace, GetContractTokensHandler, false);
        }
 
        internal static void UnregisterHandlers(LegalComponent Legal)
        {
            legal = Legal;
 
            Legal.UnregisterIqGetHandler("contractTokens", NeuroFeaturesNamespace, GetContractTokensHandler, false);
        }
 
        #endregion
 
        #region GetToken
 
        private static async Task GetTokenHandler(object Sender, IqEventArgs e)
        {
            Token Token = await GetToken(e);
            if (Token is null)
                return;
 
            StringBuilder Xml = new StringBuilder();
            await Token.Serialize(Xml, true, true);
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        private static async Task<Token> GetToken(IqEventArgs e)
        {
            string TokenId = XML.Attribute(e.Query, "id");
 
            Token Token = await GetToken(TokenId, false);
            if (Token is null)
            {
                await e.IqErrorItemNotFound(e.To, "Token not found.", "en");
                return null;
            }
 
            if (!await IsAuthorizedAccess(Token, e))
                return null;
 
            return Token;
        }
 
        internal static async Task<bool> IsAuthorizedAccess(Token Token, IqEventArgs e)
        {
            switch (Token.Visibility)
            {
                case ContractVisibility.Public:
                case ContractVisibility.PublicSearchable:
                    return true;
 
                case ContractVisibility.DomainAndParts:
                    if (eDaler.Server.IsServerDomain(e.From.Domain, true))
                        return true;
                    break;
            }
 
            if (Token.OwnerJid == e.From.BareJid)
                return true;
 
            if (Token.IsExternalPart(e.From.BareJid))
                return true;
 
            KeyValuePair<Contract, IqResultEventArgs> P = await legal.GetContract(Token.OwnershipContract);
            Contract Contract = P.Key;
 
            if (Contract is null)
            {
                if (string.IsNullOrEmpty(P.Value?.ErrorText))
                    await e.IqErrorServiceUnavailable(e.To, "Ownership contract of token not accessible at this time.", "en");
                else
                    await e.IqErrorServiceUnavailable(e.To, "Ownership contract of token not accessible at this time: " + P.Value.ErrorText, "en");
 
                return false;
            }
 
            if (!await Contract.CanRead(e.From, eDaler.Server, legal))
            {
                await e.IqErrorForbidden(e.To, "You do not have access to this token.", "en");
                return false;
            }
 
            return true;
        }
 
        #endregion
 
        #region GetTokens
 
        private static async Task GetTokensHandler(object Sender, IqEventArgs e)
        {
            int Offset = XML.Attribute(e.Query, "offset", 0);
            int MaxCount = XML.Attribute(e.Query, "maxCount", int.MaxValue);
            bool References = XML.Attribute(e.Query, "references", true);
 
            IEnumerable<TokenReference> TokenReferences = await Database.Find<TokenReference>(Offset, MaxCount,
                new FilterFieldEqualTo("OwnerJid", e.From.BareJid), "-Updated");
            string Xml;
 
            if (References)
                Xml = SerializeTokenReferences(TokenReferences);
            else
            {
                List<Token> Tokens = new List<Token>();
 
                foreach (TokenReference Ref in TokenReferences)
                {
                    Token Token = await GetToken(Ref.TokenId, false);
                    if (!(Token is null))
                        Tokens.Add(Token);
                }
 
                Xml = await SerializeTokenReferences(Tokens);
            }
 
            await e.IqResult(Xml, e.To);
        }
 
        private static async Task GetContractTokensHandler(object Sender, IqEventArgs e)
        {
            CaseInsensitiveString ContractId = XML.Attribute(e.Query, "contractId");
            int Offset = XML.Attribute(e.Query, "offset", 0);
            int MaxCount = XML.Attribute(e.Query, "maxCount", int.MaxValue);
            bool References = XML.Attribute(e.Query, "references", true);
 
            XmppAddress ContractAddr = new XmppAddress(ContractId);
            if (!legal.IsComponentDomain(ContractAddr.Domain, true))
            {
                await e.IqErrorBadRequest(e.To, "Contract not hosted on this server.", "en");
                return;
            }
 
            KeyValuePair<Contract, IqResultEventArgs> P = await legal.GetContract(ContractId);
            Contract Contract = P.Key;
 
            if (Contract is null)
            {
                if (string.IsNullOrEmpty(P.Value?.ErrorText))
                    await e.IqErrorItemNotFound(e.To, "Contract not found.", "en");
                else
                    await e.IqErrorItemNotFound(e.To, "Unable to get contract: " + P.Value.ErrorText, "en");
 
                return;
            }
 
            if (!await Contract.CanRead(e.From, eDaler.Server, legal))
            {
                await e.IqErrorForbidden(e.To, "Access to contract denied.", "en");
                return;
            }
 
            string Xml;
            IEnumerable<Token> Tokens = await Database.Find<Token>(Offset, MaxCount,
                new FilterFieldEqualTo("CreationContract", ContractId), "-Created");
 
            if (References)
            {
                List<TokenReference> TokenReferences = new List<TokenReference>();
 
                foreach (Token Token in Tokens)
                {
                    TokenReferences.Add(new TokenReference()
                    {
                        TokenId = Token.TokenId
                    });
                }
 
                Xml = SerializeTokenReferences(TokenReferences);
            }
            else
                Xml = await SerializeTokenReferences(Tokens);
 
            await e.IqResult(Xml, e.To);
        }
 
        internal static string SerializeTokenReferences(IEnumerable<TokenReference> Tokens)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<tokenReferences xmlns='");
            Xml.Append(NeuroFeaturesNamespace);
            Xml.Append("'>");
 
            foreach (TokenReference Token in Tokens)
            {
                Xml.Append("<ref id='");
                Xml.Append(XML.Encode(Token.TokenId));
                Xml.Append("'/>");
            }
 
            Xml.Append("</tokenReferences>");
 
            return Xml.ToString();
        }
 
        internal static async Task<string> SerializeTokenReferences(IEnumerable<Token> Tokens)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<tokens xmlns='");
            Xml.Append(NeuroFeaturesNamespace);
            Xml.Append("'>");
 
            foreach (Token Token in Tokens)
                await Token.Serialize(Xml, false, true);
 
            Xml.Append("</tokens>");
 
            return Xml.ToString();
        }
 
        #endregion
 
        #region GetTotals
 
        private static async Task GetTotalsHandler(object Sender, IqEventArgs e)
        {
            StringBuilder Xml = new StringBuilder();
            string Currency = null;
            decimal Total = 0;
            int Nr = 0;
 
            Xml.Append("<totals xmlns='");
            Xml.Append(NeuroFeaturesNamespace);
            Xml.Append("'>");
 
            foreach (TokenReference TokenRef in await Database.Find<TokenReference>(new FilterFieldEqualTo("OwnerJid", e.From.BareJid), "Currency"))
            {
                if (Currency is null || Currency != TokenRef.Currency)
                {
                    if (Nr > 0)
                    {
                        Xml.Append("<total nr='");
                        Xml.Append(Nr.ToString());
                        Xml.Append("' total='");
                        Xml.Append(CommonTypes.Encode(Total));
                        Xml.Append("' currency='");
                        Xml.Append(XML.Encode(Currency));
                        Xml.Append("'/>");
                    }
 
                    Nr = 1;
                    Total = TokenRef.Value;
                    Currency = TokenRef.Currency;
                }
                else
                {
                    Nr++;
                    Total += TokenRef.Value;
                }
            }
 
            if (Nr > 0)
            {
                Xml.Append("<total nr='");
                Xml.Append(Nr.ToString());
                Xml.Append("' total='");
                Xml.Append(CommonTypes.Encode(Total));
                Xml.Append("' currency='");
                Xml.Append(XML.Encode(Currency));
                Xml.Append("'/>");
            }
 
            Xml.Append("</totals>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        #endregion
 
        #region SetNoteText
 
        private static async Task SetNoteTextHandler(object Sender, IqEventArgs e)
        {
            string TokenId = XML.Attribute(e.Query, "id");
            bool Personal = XML.Attribute(e.Query, "personal", false);
 
            Token Token = await GetToken(TokenId, false);
            if (Token is null)
            {
                await e.IqErrorItemNotFound(e.To, "Token not found.", "en");
                return;
            }
 
            TokenNoteEvent Event;
 
            if (Token.OwnerJid == e.From.BareJid)
            {
                Event = new NoteText()
                {
                    ArchiveOptional = Token.ArchiveOptional,
                    ArchiveRequired = Token.ArchiveRequired,
                    Expires = Token.Expires,
                    Note = e.Query.InnerText,
                    Personal = Personal,
                    Timestamp = DateTime.UtcNow,
                    TokenId = Token.TokenId
                };
            }
            else
            {
                if (!await IsApprovedExternalSource(Token, e))
                    return;
 
                Event = new ExternalNoteText()
                {
                    ArchiveOptional = Token.ArchiveOptional,
                    ArchiveRequired = Token.ArchiveRequired,
                    Expires = Token.Expires,
                    Note = e.Query.InnerText,
                    Personal = Personal,
                    Timestamp = DateTime.UtcNow,
                    TokenId = Token.TokenId,
                    Source = e.From.BareJid
                };
            }
 
            await Database.Insert(Event);
            await e.IqResult(string.Empty, e.To);
 
            await Task.Run(async () =>
            {
                try
                {
                    await StateMachineProcessor.EventGenerated(Token, Event);
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            });
        }
 
        private static async Task<bool> IsApprovedExternalSource(Token Token, IqEventArgs e)
        {
            if (Token.IsExternalPart(e.From.BareJid))
                return true;
 
            if (Token.HasStateMachine)
            {
                StateMachineProcessor.CacheRecord Machine = await StateMachineProcessor.GetStateMachine(Token, false);
                if (Machine is null)
                {
                    await e.IqErrorItemNotFound(e.To, "State-machine not found.", "en");
                    return false;
                }
 
                if (Machine.CurrentState is null)
                {
                    await e.IqErrorServiceUnavailable(e.To, "Current state of State-machine not available.", "en");
                    return false;
                }
 
                if (Machine.CurrentState.HasEnded)
                {
                    await e.IqErrorServiceUnavailable(e.To, "State-machine has ended.", "en");
                    return false;
                }
 
                if (!Machine.CurrentState.ContainsSource(e.From.BareJid))
                {
                    await e.IqErrorForbidden(e.To, "You are not an approved external part for this token.", "en");
                    return false;
                }
            }
            else
            {
                await e.IqErrorForbidden(e.To, "You are not an approved external part for this token.", "en");
                return false;
            }
 
            return true;
        }
 
        #endregion
 
        #region SetNoteXml
 
        private static async Task SetNoteXmlHandler(object Sender, IqEventArgs e)
        {
            string TokenId = XML.Attribute(e.Query, "id");
            bool Personal = XML.Attribute(e.Query, "personal", false);
 
            Token Token = await GetToken(TokenId, false);
            if (Token is null)
            {
                await e.IqErrorItemNotFound(e.To, "Token not found.", "en");
                return;
            }
 
            TokenNoteEvent Event;
            bool Found = false;
            string NoteXml = null;
            string LocalName = null;
            string Namespace = null;
 
            foreach (XmlNode N in e.Query.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    NoteXml = E.OuterXml;
                    LocalName = E.LocalName;
                    Namespace = E.NamespaceURI;
 
                    Found = true;
                    break;
                }
            }
 
            if (!Found)
            {
                await e.IqErrorBadRequest(e.To, "Empty XML Note.", "en");
                return;
            }
 
            if (!(legal is null))
            {
                XmlDocument Doc = XML.ParseXml(NoteXml, true);
 
                (string, Dictionary<string, ValidationSchema>) P = await legal.ValidateContent(Doc, null);
                if (!string.IsNullOrEmpty(P.Item1))
                {
                    await e.IqErrorBadRequest(e.To, "XML Note invalid: " + P.Item1, "en");
                    return;
                }
            }
 
            if (Token.OwnerJid == e.From.BareJid)
            {
                Event = new NoteXml()
                {
                    ArchiveOptional = Token.ArchiveOptional,
                    ArchiveRequired = Token.ArchiveRequired,
                    Expires = Token.Expires,
                    Personal = Personal,
                    Timestamp = DateTime.UtcNow,
                    TokenId = Token.TokenId,
                    Note = NoteXml,
                    LocalName = LocalName,
                    Namespace = Namespace
                };
            }
            else
            {
                if (!await IsApprovedExternalSource(Token, e))
                    return;
 
                Event = new ExternalNoteXml()
                {
                    ArchiveOptional = Token.ArchiveOptional,
                    ArchiveRequired = Token.ArchiveRequired,
                    Expires = Token.Expires,
                    Personal = Personal,
                    Timestamp = DateTime.UtcNow,
                    TokenId = Token.TokenId,
                    Note = NoteXml,
                    LocalName = LocalName,
                    Namespace = Namespace,
                    Source = e.From.BareJid
                };
            }
 
            await Database.Insert(Event);
            await e.IqResult(string.Empty, e.To);
 
            await Task.Run(async () =>
            {
                try
                {
                    await StateMachineProcessor.EventGenerated(Token, Event);
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            });
        }
 
        #endregion
 
        #region GetEvents
 
        private static async Task GetEventsHandler(object Sender, IqEventArgs e)
        {
            string TokenId = XML.Attribute(e.Query, "id");
 
            Token Token = await GetToken(TokenId, false);
            if (Token is null)
            {
                await e.IqErrorItemNotFound(e.To, "Token not found.", "en");
                return;
            }
 
            if (!await IsAuthorizedAccess(Token, e))
                return;
 
            int Offset = XML.Attribute(e.Query, "offset", 0);
            int MaxCount = XML.Attribute(e.Query, "maxCount", int.MaxValue);
 
            IEnumerable<TokenEvent> Events = await GetTokenEvents(Token, Offset, MaxCount);
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<events xmlns='");
            Xml.Append(NeuroFeaturesNamespace);
            Xml.Append("'>");
 
            foreach (TokenEvent Event in Events)
                Event.Serialize(Xml);
 
            Xml.Append("</events>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        internal static async Task<IEnumerable<TokenEvent>> GetTokenEvents(Token Token, int Offset, int MaxCount)
        {
 
            IEnumerable<TokenEvent> Events = await Database.Find<TokenEvent>(Offset, MaxCount,
                new FilterFieldEqualTo("TokenId", Token.TokenId), "-Timestamp");
 
            if (Token.HasStateMachine && Token.MachineId != Token.TokenId)
            {
                IEnumerable<TokenEvent> Events2 = await Database.Find<TokenEvent>(Offset, MaxCount,
                    new FilterFieldEqualTo("TokenId", Token.MachineId), "-Timestamp");
 
                using IEnumerator<TokenEvent> e1 = Events.GetEnumerator();
                using IEnumerator<TokenEvent> e2 = Events2.GetEnumerator();
 
                LinkedList<TokenEvent> Merged = new LinkedList<TokenEvent>();
                bool Has1 = e1.MoveNext();
                bool Has2 = e2.MoveNext();
 
                while (Has1 && Has2)
                {
                    if (e1.Current.Timestamp > e2.Current.Timestamp)
                    {
                        Merged.AddLast(e1.Current);
                        Has1 = e1.MoveNext();
                    }
                    else
                    {
                        Merged.AddLast(e2.Current);
                        Has2 = e2.MoveNext();
                    }
                }
 
                while (Has1)
                {
                    Merged.AddLast(e1.Current);
                    Has1 = e1.MoveNext();
                }
 
                while (Has2)
                {
                    Merged.AddLast(e2.Current);
                    Has2 = e2.MoveNext();
                }
 
                Events = Merged;
            }
 
            return Events;
        }
 
        #endregion
 
        #region GetCreationAttributes
 
        private static async Task GetCreationAttributesHandler(object Sender, IqEventArgs e)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<creationAttributes xmlns='");
            Xml.Append(NeuroFeaturesNamespace);
            Xml.Append("' currency='");
 
            if (!(eDaler is null))
                Xml.Append(XML.Encode(await eDaler.GetDefaultCurrency()));
 
            Xml.Append("' commission='");
            Xml.Append(CommonTypes.Encode(await MarketplaceProcessor.GetMinCommission()));
            Xml.Append("' trustProvider='");
 
            if (LegalIdentityConfiguration.HasApprovedLegalIdentities)
                Xml.Append(XML.Encode(LegalIdentityConfiguration.LatestApprovedLegalIdentityId));
 
            Xml.Append("'/>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        #endregion
 
        #region GetDescription
 
        private static async Task GetDescriptionHandler(object Sender, IqEventArgs e)
        {
            Token Token = await GetToken(e);
            if (Token is null)
                return;
 
            ReportFormat ReportFormat = XML.Attribute(e.Query, "format", ReportFormat.Markdown);
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<report xmlns='");
            Xml.Append(NeuroFeaturesNamespace);
            Xml.Append("'>");
            Xml.Append(XML.Encode(await GetDescription(Token, ReportFormat)));
            Xml.Append("</report>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        internal static async Task<string> GetDescription(Token Token, ReportFormat Format)
        {
            Variables Variables = HttpServer.CreateSessionVariables();
 
            if (!(Token.Tags is null))
            {
                foreach (TokenTagReference Tag in Token.Tags)
                    Variables[Tag.Name] = Tag.Value;
            }
 
            return await FormatReport(Token.Description, Format, Variables);
        }
 
        internal static async Task<string> FormatReport(string Markdown,
            ReportFormat Format, Variables Variables)
        {
            MarkdownSettings Settings = new MarkdownSettings()
            {
                AllowScriptTag = false,
                AudioAutoplay = false,
                AudioControls = false,
                RootFolder = Gateway.RootFolder,
                ParseMetaData = false,
                Variables = Variables,
                VideoAutoplay = false,
                VideoControls = false,
                EmbedEmojis = false,
                EmojiSource = null,
                ScriptContext = typeof(NeuroFeaturesProcessor),
                AuthorizeExpression = (Exp) =>
                {
                    XmppServer.CheckExpressionSafe(Exp, true, true, true, out ScriptNode Prohibited);
                    return Task.FromResult(Prohibited);
                }
            };
 
            MarkdownDocument Doc = await MarkdownDocument.CreateAsync(Markdown, Settings);
 
            switch (Format)
            {
                case ReportFormat.Markdown:
                    return FixLocalFileLinks(await Doc.GenerateMarkdown(true));
 
                case ReportFormat.Html:
                    string Html = await Doc.GenerateHTML();
                    return FixLocalFileLinks(HtmlDocument.GetBody(Html));
 
                case ReportFormat.Text:
                    return FixLocalFileLinks(await Doc.GeneratePlainText());
 
                case ReportFormat.Xaml:
                    return FixLocalFileLinks(await Doc.GenerateXAML());
 
                case ReportFormat.XamarinXaml:
                    return FixLocalFileLinks(await Doc.GenerateXamarinForms());
 
                case ReportFormat.SmartContract:
                    return FixLocalFileLinks(await Doc.GenerateSmartContractXml());
 
                default:
                    throw new ArgumentException("Unrecognized report format: " + Format.ToString(), nameof(Format));
            }
        }
 
        private static string FixLocalFileLinks(string Report)
        {
            if (localFileReference is null)
            {
                string s = Gateway.RootFolder;
                if (string.IsNullOrEmpty(s))
                    return Report;
 
                if (!string.IsNullOrEmpty(s) && s[^1] == Path.DirectorySeparatorChar)
                    s = s[..^1];
 
                localFileReference = new Regex("[\"']" + s.Replace("\\", "\\\\") +
                    "(?'LocalUrl'[^\"']*)[\"']", RegexOptions.Compiled | RegexOptions.Multiline);
            }
 
            StringBuilder sb = new StringBuilder();
            int i = 0;
            int c = Report.Length;
 
            while (i < c)
            {
                Match M = localFileReference.Match(Report, i);
                if (!M.Success)
                {
                    sb.Append(Report[i..c]);
                    i = c;
                }
                else
                {
                    sb.Append(Report.Substring(i, M.Index));
                    i = M.Index + M.Length;
 
                    sb.Append('"');
                    sb.Append(Gateway.GetUrl(M.Groups["LocalUrl"].Value.Replace(Path.DirectorySeparatorChar, '/')));
                    sb.Append('"');
                }
            }
 
            return sb.ToString();
        }
 
        private static Regex localFileReference = null;
 
        #endregion
 
        #region Token Added
 
        private static async Task TokenAddedIqHandler(object Sender, IqEventArgs e)
        {
            string Error = null;
            bool Empty = true;
 
            foreach (XmlNode N in e.Query.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    Empty = false;
 
                    Token Token = IsTokenMessageElement(E, e.From, out string Message);
                    if (!(Token is null))
                        await TokenAdded(Token, Token.OwnerJid);
                    else if (!string.IsNullOrEmpty(Message))
                        Error = Message;
                }
            }
 
            if (!string.IsNullOrEmpty(Error))
                await e.IqErrorBadRequest(e.To, Error, "en");
            else if (Empty)
                await e.IqErrorBadRequest(e.To, "No token found.", "en");
            else
                await e.IqResult(string.Empty, e.To);
        }
 
        private static async Task TokenAddedMessageHandler(object Sender, MessageEventArgs e)
        {
            foreach (XmlNode N in e.Content.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    Token Token = IsTokenMessageElement(E, e.From, out _);
                    if (!(Token is null))
                        await TokenAdded(Token, Token.OwnerJid);
                }
            }
        }
 
        internal static async Task TokenAdded(Token Token, CaseInsensitiveString OwnerJid)
        {
            TokenReference Ref = await Database.FindFirstDeleteRest<TokenReference>(
                new FilterFieldEqualTo("TokenId", Token.TokenId), "-Updated");
 
            if (Ref is null)
            {
                Ref = new TokenReference()
                {
                    ArchiveOptional = Token.ArchiveOptional,
                    ArchiveRequired = Token.ArchiveRequired,
                    Created = Token.Created,
                    Expires = Token.Expires,
                    OwnerJid = OwnerJid,
                    TokenId = Token.TokenId,
                    Updated = Token.Updated,
                    Value = Token.Value,
                    Currency = Token.Currency
                };
 
                await Database.Insert(Ref);
            }
            else if (
                Ref.OwnerJid != OwnerJid ||
                Ref.Updated != Token.Updated ||
                Ref.Value != Token.Value ||
                Ref.Currency != Token.Currency)
            {
                Ref.OwnerJid = OwnerJid;
                Ref.Updated = Token.Updated;
                Ref.Value = Token.Value;
                Ref.Currency = Token.Currency;
 
                await Database.Update(Ref);
            }
        }
 
        private static Token IsTokenMessageElement(XmlElement E, XmppAddress From, out string Message)
        {
            if (E.LocalName != "token" || E.NamespaceURI != NeuroFeaturesNamespace)
            {
                Message = "Non-token embedded element.";
                return null;
            }
 
            if (!Token.TryParse(E, out Token EmbeddedToken))
            {
                Message = "Unable to parse embedded token.";
                return null;
            }
 
            if (!legal.Server.IsServerDomain(new XmppAddress(EmbeddedToken.OwnerJid).Domain, true))
            {
                Message = "Embedded token discarded. Owner not on broker.";
                return null;
            }
 
            if (From.Address != new XmppAddress(EmbeddedToken.TokenId).Domain)
            {
                Message = "Embedded token discarded. Sender not host of token.";
                return null;
            }
 
            Message = null;
            return EmbeddedToken;
        }
 
        #endregion
 
        #region Token Removed
 
        private static async Task TokenRemovedIqHandler(object Sender, IqEventArgs e)
        {
            string Error = null;
            bool Empty = true;
 
            foreach (XmlNode N in e.Query.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    Empty = false;
 
                    Token Token = IsTokenMessageElement(E, e.From, out string Message);
                    if (!(Token is null))
                        await TokenRemoved(Token, Token.OwnerJid);
                    else if (!string.IsNullOrEmpty(Message))
                        Error = Message;
                }
            }
 
            if (!string.IsNullOrEmpty(Error))
                await e.IqErrorBadRequest(e.To, Error, "en");
            else if (Empty)
                await e.IqErrorBadRequest(e.To, "No token found.", "en");
            else
                await e.IqResult(string.Empty, e.To);
        }
 
        private static async Task TokenRemovedMessageHandler(object Sender, MessageEventArgs e)
        {
            foreach (XmlNode N in e.Content.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    Token Token = IsTokenMessageElement(E, e.From, out _);
                    if (!(Token is null))
                        await TokenRemoved(Token, Token.OwnerJid);
                }
            }
        }
 
        internal static async Task TokenRemoved(Token Token, CaseInsensitiveString OwnerJid)
        {
            if (CaseInsensitiveString.IsNullOrEmpty(OwnerJid))
            {
                await Database.Delete<TokenReference>(
                    new FilterFieldEqualTo("TokenId", Token.TokenId));
            }
            else
            {
                await Database.Delete<TokenReference>(new FilterAnd(
                    new FilterFieldEqualTo("TokenId", Token.TokenId),
                    new FilterFieldEqualTo("OwnerJid", OwnerJid)));
            }
        }
 
        #endregion
 
        #endregion
 
    }
}