MarketplaceProcessor.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content.Xml;
using Waher.Events;
using Waher.IoTGateway;
using Waher.IoTGateway.Setup;
using Waher.Networking.XMPP.Server;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Inventory;
using Waher.Runtime.Settings;
using Waher.Runtime.Threading;
using Waher.Runtime.Timing;
using Waher.Script;
using Waher.Script.Model;
using Waher.Service.IoTBroker.EDaler;
using Waher.Service.IoTBroker.Legal;
using Waher.Service.IoTBroker.Legal.Contracts;
using Waher.Service.IoTBroker.NeuroFeatures;
using Waher.Service.IoTBroker.NeuroFeatures.Events;
using Waher.Service.IoTBroker.Paiwise;
using Waher.Service.IoTBroker.PubSub;
using Waher.Service.IoTBroker.StateMachines;
 
namespace Waher.Service.IoTBroker.Marketplace
{
    public static class MarketplaceProcessor
    {
        private static Scheduler scheduler;
 
        public const string MarketplaceNamespace = "https://paiwise.tagroot.io/Schema/Marketplace.xsd";
 
        public const string AuctioneerRole = "Auctioneer";
 
        public const string SellerRole = "Seller";
 
        public const string BuyerRole = "Buyer";
 
        private static readonly Dictionary<CaseInsensitiveString, AuctionItem> activeItems = new Dictionary<CaseInsensitiveString, AuctionItem>();
        private static decimal? minCommission = null;
 
        internal static async Task ContractSigned(Contract Contract, bool ContractIsLocked,
            Dictionary<CaseInsensitiveString, Parameter> TransientParameters,
            LegalComponent Legal, EDalerComponent EDaler, PubSubComponent PubSub)
        {
            if (Contract?.ForMachines is null || Contract.ForMachinesNamespace != MarketplaceNamespace)
                return;
 
            if ((TransientParameters?.Count ?? 0) > 0)
            {
                await NeuroFeaturesProcessor.RejectContract(Contract,ContractIsLocked,
                    "Transient parameters not permitted in auctions.", true, Legal, EDaler);
                return;
            }
 
            switch (Contract.ForMachinesLocalName)
            {
                case "ForSale":
                    if (!OnlyMissingAuctioneer(Contract, SellerRole, AuctioneerRole, out string PaymentLegalId, out string PaymentJid))
                        return;
 
                    await AddItemForSale(Contract.ForMachinesParsed.DocumentElement, 
                        Contract, ContractIsLocked, PaymentLegalId, PaymentJid, Legal, 
                        EDaler, PubSub);
                    break;
 
                case "ToBuy":
                    if (!OnlyMissingAuctioneer(Contract, BuyerRole, AuctioneerRole, out PaymentLegalId, out PaymentJid))
                        return;
 
                    await AddItemToBuy(Contract.ForMachinesParsed.DocumentElement, Contract, 
                        ContractIsLocked, PaymentLegalId, PaymentJid, Legal, EDaler, PubSub);
                    break;
 
                case "Offer":
                    if (!OnlyMissingAuctioneer(Contract, null, AuctioneerRole, out _, out _))
                        return;
 
                    await AddOffer(Contract.ForMachinesParsed.DocumentElement, Contract, 
                        ContractIsLocked, Legal, EDaler, PubSub);
                    break;
 
                default:
                    Log.Error("Rejected marketplace contract: Unrecognized element: " + Contract.ForMachinesLocalName, Contract.ContractId);
                    break;
            }
        }
 
        internal static bool OnlyMissingAuctioneer(Contract Contract, string PaymentPartyRole,
            string TrustProviderRole, out string PaymentLegalId, out string PaymentJid)
        {
            PaymentLegalId = null;
            PaymentJid = null;
 
            if (Contract.State != ContractState.BeingSigned || Contract.ClientSignatures is null)
                return false;
 
            if ((Contract.Roles?.Length ?? 0) < 2)
                return false;
 
            bool HasAuctioneer = false;
            bool HasPaymentParty = false;
            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;
 
                    HasAuctioneer = true;
                }
                else
                {
                    if (!(PaymentPartyRole is null) && Role.Name == PaymentPartyRole)
                    {
                        if (Role.MinCount != 1 || Role.MaxCount != 1)
                            return false;
 
                        HasPaymentParty = true;
                    }
 
                    Signatures[Role.Name] = new SignatureStat()
                    {
                        Min = Role.MinCount,
                        Max = Role.MaxCount,
                        Count = 0
                    };
                }
            }
 
            if (!HasAuctioneer || (!HasPaymentParty && !(PaymentPartyRole is null)))
                return false;
 
            foreach (ClientSignature Signature in Contract.ClientSignatures)
            {
                if (Signatures.TryGetValue(Signature.Role, out SignatureStat Stat))
                    Stat.Count++;
                else
                    return false;
 
                if (!(PaymentPartyRole is null) && Signature.Role == PaymentPartyRole)
                {
                    PaymentLegalId = Signature.LegalId;
                    PaymentJid = Signature.BareJid;
                }
            }
 
            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 static async Task<bool> AddItemForSale(XmlElement ForSale, Contract Contract, bool ContractIsLocked, string PaymentLegalId,
            string PaymentJid, LegalComponent Legal, EDalerComponent EDaler, PubSubComponent PubSub)
        {
            AuctionItem Item = await ParseAuctionItem(ForSale, PaymentLegalId, PaymentJid, Contract);
            if (Item is null)
                return false;
 
            await AddItem(Item, Contract, ContractIsLocked, OptimizeDirection.Up, Legal, EDaler, PubSub);
 
            return true;
        }
 
        private static async Task<bool> AddItemToBuy(XmlElement ToBuy, Contract Contract, bool ContractIsLocked, string PaymentLegalId,
            string PaymentJid, LegalComponent Legal, EDalerComponent EDaler, PubSubComponent PubSub)
        {
            AuctionItem Item = await ParseAuctionItem(ToBuy, PaymentLegalId, PaymentJid, Contract);
            if (Item is null)
                return false;
 
            await AddItem(Item, Contract, ContractIsLocked, OptimizeDirection.Down, Legal, EDaler, PubSub);
 
            return true;
        }
 
        private static async Task AddItem(AuctionItem Item, Contract Contract, bool ContractIsLocked, OptimizeDirection Direction, LegalComponent Legal,
            EDalerComponent EDaler, PubSubComponent PubSub)
        {
            Item.Direction = Direction;
            await Database.Insert(Item);
 
            Item.ScheduledExpiry = AddItem(Item, EDaler);
 
            SignatureReference Ref = await SignContract(Contract, ContractIsLocked, Legal, PubSub, Item.Node, AuctioneerRole);
            if (Ref is null)
            {
                lock (activeItems)
                {
                    activeItems.Remove(Item.ContractId);
                }
 
                Scheduler.Remove(Item.ScheduledExpiry);
                Item.ScheduledExpiry = DateTime.MinValue;
 
                await Database.Delete(Item);
                return;
            }
 
            Item.TrustProviderJid = Ref.BareJid;
            Item.TrustProviderLegalId = Ref.LegalId;
 
            await Database.Update(Item);
        }
 
        internal class SignatureReference
        {
            public string LegalId;
            public string BareJid;
        }
 
        internal static Task<SignatureReference> SignContract(Contract Contract, bool ContractIsLocked, LegalComponent Legal, string Role)
        {
            return SignContract(Contract, ContractIsLocked, Legal, null, null, Role);
        }
 
        private static async Task<SignatureReference> SignContract(Contract Contract, bool ContractIsLocked, LegalComponent Legal,
            PubSubComponent PubSub, string Node, string Role)
        {
            try
            {
                if (Gateway.ContractsClient is null)
                    return null;
 
                StringBuilder sb = new StringBuilder();
 
                if (Legal.IsComponentDomain(Networking.XMPP.XmppClient.GetDomain(Contract.ContractId), true))
                {
                    Semaphore Semaphore;
 
                    if (ContractIsLocked)
                        Semaphore = null;
                    else
                        Semaphore = await Semaphores.BeginWrite("iotsc:" + Contract.ContractId.LowerCase);
 
                    try
                    {
                        await Contract.Serialize(sb, false, false, false, false, false, false, false, null, Legal);
                        byte[] Data = Encoding.UTF8.GetBytes(sb.ToString());
                        byte[] Signature = await Gateway.ContractsClient.SignAsync(Data, Networking.XMPP.Contracts.SignWith.LatestApprovedId);
 
                        Contract = await Legal.SignContract(Contract, true, Role, false, Signature, new XmppAddress(Gateway.ContractsClient.Client.BareJID));
 
                        if (!string.IsNullOrEmpty(Node))
                        {
                            string ContractXml = null;
 
                            try
                            {
                                sb.Clear();
                                await Contract.Serialize(sb, true, true, false, false, false, false, false, null, Legal);
                                ContractXml = sb.ToString();
 
                                XmlDocument Xml = XML.ParseXml(ContractXml, true);
 
                                await PubSub.PublishItem(CaseInsensitiveString.Empty, Node, NodeAccessModel.open,
                                    new XmppAddress(Contract.Account + "@" + Legal.MainDomain.Address),
                                    PubSub.Subdomain, Contract.ContractId, Xml, Contract.DefaultLanguage);
                            }
                            catch (XmlException ex)
                            {
                                Log.Exception(XML.AnnotateException(ex, ContractXml), Contract.ContractId);
                            }
                            catch (Exception ex)
                            {
                                Log.Exception(ex, Contract.ContractId);
                            }
                        }
 
                        SignatureReference Result = new SignatureReference();
 
                        if (!(Contract.ClientSignatures is null))
                        {
                            foreach (ClientSignature Signature2 in Contract.ClientSignatures)
                            {
                                if (Signature2.Role == Role)
                                {
                                    Result.LegalId = Signature2.Role;
                                    Result.BareJid = Signature2.BareJid;
                                }
                            }
                        }
 
                        return Result;
                    }
                    finally
                    {
                        if (!(Semaphore is null))
                            await Semaphore.DisposeAsync();
                    }
                }
                else
                {
                    await Contract.Serialize(sb, true, true, false, false, false, false, false, null, Legal);
 
                    string ContractXml = sb.ToString();
                    XmlDocument Xml = XML.ParseXml(ContractXml, true);
 
                    Networking.XMPP.Contracts.ParsedContract Parsed = await Networking.XMPP.Contracts.Contract.Parse(Xml, Gateway.ContractsClient);
                    Networking.XMPP.Contracts.Contract Contract2 = Parsed.Contract;
 
                    Contract2 = await Gateway.ContractsClient.SignContractAsync(Contract2, Role, false);
 
                    if (!string.IsNullOrEmpty(Node))
                    {
                        ContractXml = null;
                        
                        try
                        {
                            sb.Clear();
                            Contract2.Serialize(sb, true, true, false, false, false, false, false);
                            ContractXml = sb.ToString();
                            Xml = XML.ParseXml(ContractXml, true);
 
                            await PubSub.PublishItem(CaseInsensitiveString.Empty, Node, NodeAccessModel.open,
                                new XmppAddress(Contract.Account + "@" + Legal.MainDomain.Address),
                                PubSub.Subdomain, Contract.ContractId, Xml, Contract2.DefaultLanguage);
                        }
                        catch (XmlException ex)
                        {
                            Log.Exception(XML.AnnotateException(ex, ContractXml), Contract.ContractId);
                        }
                        catch (Exception ex)
                        {
                            Log.Exception(ex, Contract.ContractId);
                        }
                    }
 
                    SignatureReference Result = new SignatureReference();
 
                    if (!(Contract2.ClientSignatures is null))
                    {
                        foreach (Networking.XMPP.Contracts.ClientSignature Signature in
                            Contract2.ClientSignatures)
                        {
                            if (Signature.Role == Role)
                            {
                                Result.LegalId = Signature.Role;
                                Result.BareJid = Signature.BareJid;
                            }
                        }
                    }
 
                    return Result;
                }
            }
            catch (XmlException ex)
            {
                ex = XML.AnnotateException(ex);
                Log.Error("Unable to sign contract: " + ex.Message, Contract.ContractId);
                return null;
            }
            catch (Exception ex)
            {
                Log.Error("Unable to sign contract: " + ex.Message, Contract.ContractId);
                return null;
            }
        }
 
        private static DateTime AddItem(AuctionItem Item, EDalerComponent EDaler)
        {
            if (Item.ContractId is null)
                return DateTime.MaxValue;
 
            lock (activeItems)
            {
                activeItems[Item.ContractId] = Item;
            }
 
            Item.ScheduledExpiry = Scheduler.Add(Item.Expires.ToLocalTime(), ItemExpires, new ExpiryRecord()
            {
                Item = Item,
                EDaler = EDaler
            });
 
            return Item.ScheduledExpiry;
        }
 
        private class ExpiryRecord
        {
            public AuctionItem Item;
            public EDalerComponent EDaler;
        }
 
        private static Scheduler Scheduler
        {
            get
            {
                if (scheduler is null)
                {
                    if (Types.TryGetModuleParameter("Scheduler", out Scheduler Scheduler))
                        scheduler = Scheduler;
                    else
                    {
                        scheduler = new Scheduler();
                        Log.Terminating += Log_Terminating;
                    }
                }
 
                return scheduler;
            }
        }
 
        private static Task Log_Terminating(object Sender, EventArgs e)
        {
            scheduler?.Dispose();
            scheduler = null;
 
            Log.Terminating -= Log_Terminating;
 
            return Task.CompletedTask;
        }
 
        internal static async Task LoadActiveItems(EDalerComponent EDaler)
        {
            foreach (AuctionItem Item in await Database.Find<AuctionItem>(new FilterFieldEqualTo("Processed", null), "Created"))
                AddItem(Item, EDaler);
        }
 
        private static async Task<AuctionItem> ParseAuctionItem(XmlElement Item, string PaymentLegalId,
            string PaymentJid, Contract Contract)
        {
            List<AuctionItemTag> Tags = new List<AuctionItemTag>();
            List<ExpectedTag> ExpectedTags = null;
            string Type = null;
            string Class = null;
            string Node = null;
            string Currency = null;
            string ScoreFunction = null;
            string TokenId = null;
            decimal? AskingPrice = null;
            decimal? RejectPrice = null;
            decimal? AcceptPrice = null;
            decimal? CommissionPercent = null;
            decimal? RejectScore = null;
            decimal? AcceptScore = null;
            decimal? AvailableDays = null;
 
            foreach (XmlNode N in Item.ChildNodes)
            {
                if (!(N is XmlElement E) || E.NamespaceURI != MarketplaceNamespace)
                    continue;
 
                switch (E.LocalName)
                {
                    case "Description":
                        foreach (XmlNode N2 in E.ChildNodes)
                        {
                            if (!(N2 is XmlElement E2))
                                continue;
 
                            switch (E2.LocalName)
                            {
                                case "Type":
                                    if (!(await PaiwiseProcessor.GetParameterValue(E2, Contract) is string s))
                                    {
                                        Log.Error("Rejected marketplace contract: Invalid type.", Contract.ContractId);
                                        return null;
                                    }
 
                                    Type = s;
                                    break;
 
                                case "Class":
                                    if (!(await PaiwiseProcessor.GetParameterValue(E2, Contract) is string s2))
                                    {
                                        Log.Error("Rejected marketplace contract: Invalid class.", Contract.ContractId);
                                        return null;
                                    }
 
                                    Class = s2;
                                    break;
 
                                case "Node":
                                    if (!(await PaiwiseProcessor.GetParameterValue(E2, Contract) is string s3))
                                    {
                                        Log.Error("Rejected marketplace contract: Invalid node.", Contract.ContractId);
                                        return null;
                                    }
 
                                    Node = s3;
                                    break;
 
                                case "Tag":
                                    AuctionItemTag Tag = new AuctionItemTag()
                                    {
                                        Name = XML.Attribute(E2, "name"),
                                        Value = await PaiwiseProcessor.GetParameterValue(E2, Contract)
                                    };
 
                                    Tags.Add(Tag);
 
                                    if (Tag.Name == "TokenID")
                                        TokenId = Tag.Value as string;
                                    break;
                            }
                        }
                        break;
 
                    case "Price":
                        foreach (XmlNode N2 in E.ChildNodes)
                        {
                            if (!(N2 is XmlElement E2))
                                continue;
 
                            switch (E2.LocalName)
                            {
                                case "AskingPrice":
                                    if (!(await PaiwiseProcessor.GetParameterValue(E2, Contract) is decimal d))
                                    {
                                        Log.Error("Rejected marketplace contract: Invalid asking price.", Contract.ContractId);
                                        return null;
                                    }
 
                                    AskingPrice = d;
                                    break;
 
                                case "RejectPrice":
                                    if (!(await PaiwiseProcessor.GetParameterValue(E2, Contract) is decimal d2))
                                    {
                                        Log.Error("Rejected marketplace contract: Invalid rejection price.", Contract.ContractId);
                                        return null;
                                    }
 
                                    RejectPrice = d2;
                                    break;
 
                                case "AcceptPrice":
                                    if (!(await PaiwiseProcessor.GetParameterValue(E2, Contract) is decimal d3))
                                    {
                                        Log.Error("Rejected marketplace contract: Invalid accept price.", Contract.ContractId);
                                        return null;
                                    }
 
                                    AcceptPrice = d3;
                                    break;
 
                                case "CommissionPercent":
                                    if (!(await PaiwiseProcessor.GetParameterValue(E2, Contract) is decimal d4) || d4 < 0 || d4 > 100)
                                    {
                                        Log.Error("Rejected marketplace contract: Invalid commission (%).", Contract.ContractId);
                                        return null;
                                    }
 
                                    CommissionPercent = d4;
                                    break;
 
                                case "Currency":
                                    if (!(await PaiwiseProcessor.GetParameterValue(E2, Contract) is string s))
                                    {
                                        Log.Error("Rejected marketplace contract: Invalid currency.", Contract.ContractId);
                                        return null;
                                    }
 
                                    Currency = s;
                                    break;
                            }
                        }
                        break;
 
                    case "Score":
                        foreach (XmlNode N2 in E.ChildNodes)
                        {
                            if (!(N2 is XmlElement E2))
                                continue;
 
                            switch (E2.LocalName)
                            {
                                case "ExpectsTag":
                                    ExpectedTags ??= new List<ExpectedTag>();
 
                                    string Name = E2.InnerText;
                                    string Where = null;
 
                                    if (E2.HasAttribute("where"))
                                    {
                                        Where = E2.GetAttribute("where");
                                        if (!IsValidExpression(Where, out _))
                                        {
                                            Log.Error("Rejected marketplace contract: Invalid where expression.", Contract.ContractId);
                                            return null;
                                        }
                                    }
 
                                    ExpectedTags.Add(new ExpectedTag()
                                    {
                                        Name = Name,
                                        Where = Where
                                    });
                                    break;
 
                                case "ScoreFunction":
                                    ScoreFunction = E2.InnerText;
                                    if (!IsValidExpression(ScoreFunction, out _))
                                    {
                                        Log.Error("Rejected marketplace contract: Invalid scoring function.", Contract.ContractId);
                                        return null;
                                    }
                                    break;
 
                                case "RejectScore":
                                    if (!(await PaiwiseProcessor.GetParameterValue(E2, Contract) is decimal d))
                                    {
                                        Log.Error("Rejected marketplace contract: Invalid rejection score.", Contract.ContractId);
                                        return null;
                                    }
 
                                    RejectScore = d;
                                    break;
 
                                case "AcceptScore":
                                    if (!(await PaiwiseProcessor.GetParameterValue(E2, Contract) is decimal d2))
                                    {
                                        Log.Error("Rejected marketplace contract: Invalid accept score.", Contract.ContractId);
                                        return null;
                                    }
 
                                    AcceptScore = d2;
                                    break;
                            }
                        }
                        break;
 
                    case "AvailableDays":
                        if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is decimal d5) || d5 <= 0)
                        {
                            Log.Error("Rejected marketplace contract: Invalid number of available days.", Contract.ContractId);
                            return null;
                        }
 
                        AvailableDays = d5;
                        break;
                }
            }
 
            if (Type is null || Class is null || Currency is null || !AskingPrice.HasValue || !CommissionPercent.HasValue || !AvailableDays.HasValue)
            {
                Log.Error("Rejected marketplace contract: Incomplete.", Contract.ContractId);
                return null;
            }
 
            if (CommissionPercent.Value < await GetMinCommission())
            {
                Log.Error("Rejected marketplace contract: Commission too low.", Contract.ContractId);
                return null;
            }
 
            if (Class == NeuroFeaturesProcessor.NeuroFeaturesNamespace)
            {
                if (string.IsNullOrEmpty(TokenId))
                {
                    Log.Error("Rejected marketplace contract: TokenID Tag expected.", Contract.ContractId);
                    return null;
                }
 
                Token Token = await NeuroFeaturesProcessor.GetToken(TokenId, true);
                if (Token is null)
                {
                    // TODO: Allow remote tokens in marketplace.
 
                    Log.Error("Rejected marketplace contract: Token not hosted by Trust Provider.", Contract.ContractId);
                    return null;
                }
 
                if (Token.OwnerJid != PaymentJid)
                {
                    Log.Error("Rejected marketplace contract: Not the current owner of the token.", Contract.ContractId);
                    return null;
                }
 
                if (Token.Expires.ToUniversalTime() < DateTime.UtcNow)
                {
                    Log.Error("Rejected marketplace contract: Token has expired.", Contract.ContractId);
                    return null;
                }
 
                if (Token.Expires.ToUniversalTime() < DateTime.UtcNow.AddDays((double)AvailableDays.Value))
                {
                    Log.Error("Rejected marketplace contract: Token will expire during the auction.", Contract.ContractId);
                    return null;
                }
 
                AuctionItem Item2 = await Database.FindFirstIgnoreRest<AuctionItem>(new FilterAnd(
                    new FilterFieldEqualTo("TokenId", TokenId),
                    new FilterFieldEqualTo("Processed", null)));
 
                if (!(Item2 is null))
                {
                    Log.Error("Rejected marketplace contract: Another auction for the token is already in process.", Contract.ContractId);
                    return null;
                }
            }
 
            DateTime Created = DateTime.UtcNow;
 
            return new AuctionItem()
            {
                ContractId = Contract.ContractId,
                InitiatorLegalId = PaymentLegalId,
                InitiatorJid = PaymentJid,
                Created = Created,
                Expires = Created.AddDays((double)AvailableDays.Value),
                Class = Class,
                Type = Type,
                TokenId = TokenId,
                Node = Node,
                Tags = Tags.ToArray(),
                ExpectedTags = ExpectedTags?.ToArray(),
                AskingPrice = AskingPrice.Value,
                AcceptPrice = AcceptPrice.Value,
                RejectPrice = RejectPrice.Value,
                CommissionPercent = CommissionPercent.Value,
                Currency = Currency,
                ScoreFunction = ScoreFunction,
                AcceptScore = AcceptScore,
                RejectScore = RejectScore,
            };
        }
 
        internal static async Task<decimal> GetMinCommission()
        {
            if (!minCommission.HasValue)
                minCommission = (decimal)await RuntimeSettings.GetAsync("Commission.Min", 10.0);
 
            return (decimal)minCommission.Value;
        }
 
        private static bool IsValidExpression(string Script, out ScriptNode Prohibited)
        {
            if (string.IsNullOrEmpty(Script))
            {
                Prohibited = null;
                return false;
            }
 
            try
            {
                Expression Exp = new Expression(Script);
                return XmppServer.CheckExpressionSafe(Exp, true, true, false, out Prohibited);
            }
            catch (Exception)
            {
                Prohibited = null;
                return false;
            }
        }
 
        private static async Task<bool> AddOffer(XmlElement Offer, Contract Contract, bool ContractIsLocked, LegalComponent Legal, EDalerComponent EDaler,
            PubSubComponent PubSub)
        {
            Variables v = new Variables();
            List<AuctionItemTag> Tags = new List<AuctionItemTag>();
            CaseInsensitiveString ItemReference = null;
            string Currency = null;
            decimal? Price = null;
 
            foreach (XmlNode N in Offer.ChildNodes)
            {
                if (!(N is XmlElement E) || E.NamespaceURI != MarketplaceNamespace)
                    continue;
 
                switch (E.LocalName)
                {
                    case "Tag":
                        AuctionItemTag Tag = new AuctionItemTag()
                        {
                            Name = XML.Attribute(E, "name"),
                            Value = await PaiwiseProcessor.GetParameterValue(E, Contract)
                        };
 
                        Tags.Add(Tag);
                        v[Tag.Name] = Tag.Value;
                        break;
 
                    case "Price":
                        if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is decimal d))
                        {
                            Log.Error("Rejected marketplace offer: Invalid price.", Contract.ContractId);
                            return false;
                        }
 
                        Price = d;
                        break;
 
                    case "Currency":
                        if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is string s))
                        {
                            Log.Error("Rejected marketplace offer: Invalid currency.", Contract.ContractId);
                            return false;
                        }
 
                        Currency = s;
                        break;
 
                    case "ItemReference":
                        if (!(await PaiwiseProcessor.GetParameterValue(E, Contract) is string s2))
                        {
                            Log.Error("Rejected marketplace offer: Invalid item reference.", Contract.ContractId);
                            return false;
                        }
 
                        int i = s2.IndexOf('@');
                        if (i < 0 || !Guid.TryParse(s2[..i], out Guid _))
                        {
                            Log.Error("Rejected marketplace offer: Invalid item reference.", Contract.ContractId);
                            return false;
                        }
 
                        ItemReference = s2;
 
                        s2 = s2[(i + 1)..];
                        if (!Legal.IsComponentDomain(s2, true))
                        {
                            // TODO: If contract reference on other domain, send proposal message to that neuron
                            return false;
                        }
                        break;
                }
            }
 
            if (ItemReference is null || Currency is null || !Price.HasValue)
            {
                Log.Error("Rejected marketplace offer: Incomplete.", Contract.ContractId);
                return false;
            }
 
            AuctionItem Item;
 
            lock (activeItems)
            {
                if (!activeItems.TryGetValue(ItemReference, out Item))
                    Item = null;
            }
 
            if (Item is null)
            {
                Log.Error("Rejected marketplace offer: Not active.", ItemReference, Contract.ContractId);
                return false;
            }
 
            if (!(Item.Tags is null))
            {
                foreach (AuctionItemTag Tag in Item.Tags)
                {
                    if (!v.ContainsVariable(Tag.Name))
                        v[Tag.Name] = Tag.Value;
                }
            }
 
            v["Price"] = Price.Value;
 
            if (!(Item.ExpectedTags is null))
            {
                foreach (ExpectedTag ExpectedTag in Item.ExpectedTags)
                {
                    if (!v.ContainsVariable(ExpectedTag.Name))
                    {
                        Log.Error("Rejected marketplace offer: Tag '" + ExpectedTag
                            + "' used for scoring offers is missing.", ItemReference, Contract.ContractId);
                        return false;
                    }
 
                    if (!string.IsNullOrEmpty(ExpectedTag.Where))
                    {
                        try
                        {
                            object Result = await ExpectedTag.Parsed.EvaluateAsync(v);
 
                            if (Result is bool b)
                            {
                                if (!b)
                                {
                                    Log.Error("Rejected marketplace offer: Tag '" + ExpectedTag
                                        + "' not valid in accordance with where expression.", ItemReference, Contract.ContractId);
                                    return false;
                                }
                            }
                            else
                            {
                                Log.Error("Rejected marketplace offer: Where expression for '" + ExpectedTag
                                    + "' did not return a boolean value.", ItemReference, Contract.ContractId);
                                return false;
                            }
                        }
                        catch (Exception ex)
                        {
                            Log.Error("Rejected marketplace offer: Where expression for '" + ExpectedTag
                                + "' returned an exception: " + ex.Message, ItemReference, Contract.ContractId);
                            return false;
                        }
                    }
                }
            }
 
            bool Accept = false;
            bool NewBest = false;
            decimal? Score = null;
            string BestBidContractIdBak = Item.BestBidContractId;
            string BestBidLegalIdBak = Item.BestBidLegalId;
            string BestBidLegalJidBak = Item.BestBidJid;
            decimal? BestBidPriceBak = Item.BestBidPrice;
            decimal? BestBidScoreBak = Item.BestBidScore;
            string PaymentLegalId;
            string PaymentJid;
 
            switch (Item.Direction)
            {
                case OptimizeDirection.Up:      // Initiator sells. Offerers buy.
                    if (!OnlyMissingAuctioneer(Contract, BuyerRole, AuctioneerRole, out PaymentLegalId, out PaymentJid))
                    {
                        Log.Error("Rejected marketplace offer: No buyer defined.", ItemReference, Contract.ContractId);
                        return false;
                    }
                    break;
 
                case OptimizeDirection.Down:    // Initiator buys. Offerers sell.
                    if (!OnlyMissingAuctioneer(Contract, SellerRole, AuctioneerRole, out PaymentLegalId, out PaymentJid))
                    {
                        Log.Error("Rejected marketplace offer: No seller defined.", ItemReference, Contract.ContractId);
                        return false;
                    }
                    break;
 
                default:
                    return false;
            }
 
            using (Semaphore Lock = await Semaphores.BeginWrite(Item.ObjectId.ToString()))
            {
                if (Item.Processed.HasValue)
                {
                    Log.Error("Rejected marketplace offer: Not active.", ItemReference, Contract.ContractId);
                    return false;
                }
 
                if (Currency != Item.Currency)
                {
                    Log.Error("Rejected marketplace offer: Currency mismatch.", ItemReference, Contract.ContractId);
                    return false;
                }
 
                if (Item.RejectPrice.HasValue)
                {
                    switch (Item.Direction)
                    {
                        case OptimizeDirection.Up:
                            if (Price.Value < Item.RejectPrice.Value)
                            {
                                Log.Notice("Rejected marketplace offer: Below rejection price threshold.", ItemReference, Contract.ContractId);
                                return false;
                            }
                            break;
 
                        case OptimizeDirection.Down:
                            if (Price.Value > Item.RejectPrice.Value)
                            {
                                Log.Notice("Rejected marketplace offer: Above rejection price threshold.", ItemReference, Contract.ContractId);
                                return false;
                            }
                            break;
                    }
                }
 
                if (!(Item.ScoreFunction is null))
                {
                    try
                    {
                        if (Item.ScoreExpression is null)
                        {
                            Expression Exp = new Expression(Item.ScoreFunction);
 
                            if (!XmppServer.CheckExpressionSafe(Exp, true, true, false, out ScriptNode Prohibited))
                                throw new UnauthorizedAccessException("Expression not permitted: " + Prohibited?.SubExpression);
 
                            Item.ScoreExpression = Exp;
                        }
 
                        object Result = await Item.ScoreExpression.EvaluateAsync(v);
                        Score = Expression.ToDecimal(Result);
                    }
                    catch (Exception ex)
                    {
                        Log.Notice("Rejected marketplace offer: Scoring error: " + ex.Message, ItemReference, Contract.ContractId);
                        return false;
                    }
 
                    if (Item.RejectScore.HasValue)
                    {
                        switch (Item.Direction)
                        {
                            case OptimizeDirection.Up:
                                if (Score.Value < Item.RejectScore.Value)
                                {
                                    Log.Notice("Rejected marketplace offer: Below rejection score threshold.", ItemReference, Contract.ContractId);
                                    return false;
                                }
                                break;
 
                            case OptimizeDirection.Down:
                                if (Score.Value > Item.RejectScore.Value)
                                {
                                    Log.Notice("Rejected marketplace offer: Above rejection score threshold.", ItemReference, Contract.ContractId);
                                    return false;
                                }
                                break;
                        }
                    }
 
                    if (Item.AcceptScore.HasValue)
                    {
                        switch (Item.Direction)
                        {
                            case OptimizeDirection.Up:
                                if (Score.Value >= Item.AcceptScore.Value)
                                {
                                    Accept = NewBest = true;
                                    Item.Processed = DateTime.UtcNow;
                                }
                                break;
 
                            case OptimizeDirection.Down:
                                if (Score.Value <= Item.AcceptScore.Value)
                                {
                                    Accept = NewBest = true;
                                    Item.Processed = DateTime.UtcNow;
                                }
                                break;
                        }
                    }
                }
 
                if (Item.AcceptPrice.HasValue && !Accept)
                {
                    switch (Item.Direction)
                    {
                        case OptimizeDirection.Up:
                            if (Price.Value >= Item.AcceptPrice.Value)
                            {
                                Accept = NewBest = true;
                                Item.Processed = DateTime.UtcNow;
                            }
                            break;
 
                        case OptimizeDirection.Down:
                            if (Price.Value <= Item.AcceptPrice.Value)
                            {
                                Accept = NewBest = true;
                                Item.Processed = DateTime.UtcNow;
                            }
                            break;
                    }
                }
 
                if (!NewBest)
                {
                    if (Score.HasValue)
                    {
                        switch (Item.Direction)
                        {
                            case OptimizeDirection.Up:
                                if (!Item.BestBidScore.HasValue || Score.Value > Item.BestBidScore.Value)
                                    NewBest = true;
                                break;
 
                            case OptimizeDirection.Down:
                                if (!Item.BestBidScore.HasValue || Score.Value < Item.BestBidScore.Value)
                                    NewBest = true;
                                break;
                        }
                    }
                    else
                    {
                        switch (Item.Direction)
                        {
                            case OptimizeDirection.Up:
                                if (!Item.BestBidPrice.HasValue || Price.Value > Item.BestBidPrice.Value)
                                    NewBest = true;
                                break;
 
                            case OptimizeDirection.Down:
                                if (!Item.BestBidPrice.HasValue || Price.Value < Item.BestBidPrice.Value)
                                    NewBest = true;
                                break;
                        }
                    }
                }
 
                if (NewBest)
                {
                    Item.BestBidContractId = Contract.ContractId;
                    Item.BestBidLegalId = PaymentLegalId;
                    Item.BestBidJid = PaymentJid;
                    Item.BestBidPrice = Price;
                    Item.BestBidScore = Score;
                }
            }
 
            if (await SignContract(Contract, ContractIsLocked, Legal, PubSub, Item.Node, AuctioneerRole) is null)
            {
                if (Accept)
                    Item.Processed = null;
 
                if (NewBest)
                {
                    Item.BestBidContractId = BestBidContractIdBak;
                    Item.BestBidLegalId = BestBidLegalIdBak;
                    Item.BestBidJid = BestBidLegalJidBak;
                    Item.BestBidPrice = BestBidPriceBak;
                    Item.BestBidScore = BestBidScoreBak;
                }
 
                return false;
            }
 
            if (!Accept && NewBest)
                await Database.Update(Item);
 
            await Database.Insert(new AuctionOffer()
            {
                OfferContractId = Contract.ContractId,
                ContractId = ItemReference,
                OfferLegalId = PaymentLegalId,
                OfferJid = PaymentJid,
                Created = DateTime.UtcNow,
                Price = Price.Value,
                Currency = Currency,
                Score = Score ?? Price,
                Tags = Tags.ToArray()
            });
 
            if (Accept)
            {
                if (await ResolvePayments(Item, EDaler, false))    // Will update Item in the database
                {
                    lock (activeItems)
                    {
                        activeItems.Remove(Item.ContractId);
                    }
 
                    Scheduler.Remove(Item.ScheduledExpiry);
                    Item.ScheduledExpiry = DateTime.MinValue;
                }
                else
                {
                    Item.Processed = null;
                    Item.BestBidContractId = BestBidContractIdBak;
                    Item.BestBidLegalId = BestBidLegalIdBak;
                    Item.BestBidJid = BestBidLegalJidBak;
                    Item.BestBidPrice = BestBidPriceBak;
                    Item.BestBidScore = BestBidScoreBak;
 
                    await Database.Update(Item);
                }
            }
 
            return true;
        }
 
        private static async Task ItemExpires(object P)
        {
            ExpiryRecord Rec = (ExpiryRecord)P;
            AuctionItem Item = Rec.Item;
            if (Item.Processed.HasValue)
                return;
 
            lock (activeItems)
            {
                activeItems.Remove(Item.ContractId);
            }
 
            Item.Processed = DateTime.UtcNow;
 
            if (!await ResolvePayments(Item, Rec.EDaler, true))    // Will update Item in the database
                Log.Error("Auctioned item expired, but payments offered were not possible to process.", Item.ContractId);
        }
 
        private static async Task<bool> ResolvePayments(AuctionItem Item, EDalerComponent EDaler,
            bool BackTrackIfPaymentFails)
        {
            bool Ok = true;
 
            if (Item.BestBidPrice.HasValue)
            {
                CaseInsensitiveString BidderId = Item.BestBidLegalId;
                CaseInsensitiveString BidderJid = Item.BestBidJid;
                CaseInsensitiveString BidId = Item.BestBidContractId;
                decimal Amount = Item.BestBidPrice.Value;
 
                if (!(Ok = await ResolvePayments(BidderId, BidderJid, Amount, BidId, Item, EDaler)))
                {
                    if (BackTrackIfPaymentFails)
                    {
                        string Order = Item.Direction == OptimizeDirection.Up ? "-Score" : "Score";
                        IEnumerable<AuctionOffer> Bids = await Database.Find<AuctionOffer>(
                            new FilterAnd(
                                new FilterFieldEqualTo("ContractId", Item.ContractId),
                                new FilterFieldNotEqualTo("OfferContractId", Item.BestBidContractId)),
                            Order);
 
                        foreach (AuctionOffer Bid in Bids)
                        {
                            BidderId = Bid.OfferLegalId;
                            BidderJid = Bid.OfferJid;
                            BidId = Bid.OfferContractId;
                            Amount = Bid.Price;
 
                            if (Ok = await ResolvePayments(BidderId, BidderJid, Amount, BidId, Item, EDaler))
                                break;
                        }
                    }
                }
            }
 
            await Database.Update(Item);
 
            return Ok;
        }
 
        private static async Task<bool> ResolvePayments(CaseInsensitiveString Bidder,
            CaseInsensitiveString BidderJid, decimal Amount, CaseInsensitiveString BidId,
            AuctionItem Item, EDalerComponent EDaler)
        {
            decimal Commission = Amount * Item.CommissionPercent * 0.01m;
            string Ref = "iotsc:" + Item.ContractId;
            Token Token;
            int i = Item.ContractId.IndexOf('@');
 
            if (i <= 0 || !Guid.TryParse(Item.ContractId.Substring(0, i), out Guid TransactionId))
                TransactionId = Guid.NewGuid();
 
            if (Item.Class == NeuroFeaturesProcessor.NeuroFeaturesNamespace)
            {
                string TokenId = Item.TokenId;
                if (string.IsNullOrEmpty(TokenId))
                    return false;
 
                Token = await NeuroFeaturesProcessor.GetToken(TokenId, true);
                if (Token is null)
                    return false;
 
                // TODO: Allow remote tokens in marketplace.
            }
            else
                Token = null;
 
            switch (Item.Direction)
            {
                case OptimizeDirection.Up:      // Creator of item sells item to generator of best offer
 
                    if (!(Token is null) && Item.InitiatorJid != Token.OwnerJid)
                        return false;
 
                    Item.SalePaymentUri = PaiwiseProcessor.GenerateContractualPaymentUri(TransactionId, Bidder, true,
                        Gateway.ContractsClient.Client.BareJID, false, Item.Currency, Amount, null, Ref,
                        BidId, null, 1, out _, out _);
 
                    Item.CommissionPaymentUri = PaiwiseProcessor.GenerateContractualPaymentUri(Guid.NewGuid(),
                        Gateway.ContractsClient.Client.BareJID, false, Item.InitiatorLegalId, true, Item.Currency,
                        Amount - Commission, null, Ref, Item.ContractId, null, 1, out _, out _);
 
                    break;
 
                case OptimizeDirection.Down:    // Generator of best offer sells item to generator of item
 
                    if (!(Token is null) && BidderJid != Token.OwnerJid)
                        return false;
 
                    Item.SalePaymentUri = PaiwiseProcessor.GenerateContractualPaymentUri(TransactionId, Item.InitiatorLegalId, true,
                        Gateway.ContractsClient.Client.BareJID, false, Item.Currency, Amount + Commission,
                        null, Ref, Item.ContractId, null, 1, out _, out _);
 
                    Item.CommissionPaymentUri = PaiwiseProcessor.GenerateContractualPaymentUri(Guid.NewGuid(),
                        Gateway.ContractsClient.Client.BareJID, false, Bidder, true, Item.Currency, Amount, null,
                        Ref, Item.ContractId, null, 1, out _, out _);
 
                    break;
 
                default:
                    return false;
            }
 
            if (!string.IsNullOrEmpty(await PaiwiseProcessor.ProcessPayment(Item.SalePaymentUri, EDaler)))
            {
                Log.Error("Unable to process payment for consigned auction item.",
                    Item.ContractId, string.Empty, "AuctionPayment",
                    new KeyValuePair<string, object>("Bidder", Bidder),
                    new KeyValuePair<string, object>("BidId", BidId),
                    new KeyValuePair<string, object>("Amount", Amount),
                    new KeyValuePair<string, object>("Currency", Item.Currency));
 
                return false;
            }
 
            if (Commission > 0)
            {
                string Msg = await PaiwiseProcessor.ProcessPayment(Item.CommissionPaymentUri, EDaler);  // Funds covered by first transaction
                if (!string.IsNullOrEmpty(Msg))
                {
                    Log.Error("Auction payment error: Sales payment went through to Auctioneer, but secondary payment failed: " + Msg,
                        Item.ContractId, string.Empty, "AuctionPayment",
                        new KeyValuePair<string, object>("Bidder", Bidder),
                        new KeyValuePair<string, object>("BidId", BidId),
                        new KeyValuePair<string, object>("Amount", Amount),
                        new KeyValuePair<string, object>("Currency", Item.Currency),
                        new KeyValuePair<string, object>("URI", Item.CommissionPaymentUri));
                }
            }
 
            if (!(Token is null))
            {
                Transferred TransferToAuctioneer;
                Transferred TransferToBuyer;
                string SellerJid;
                string BuyerJid;
 
                switch (Item.Direction)
                {
                    case OptimizeDirection.Up:      // Creator of item sells item to generator of best offer
 
                        SellerJid = Item.InitiatorJid;
                        BuyerJid = BidderJid;
 
                        Token.Value = Amount;
                        Token.Currency = Item.Currency;
                        Token.Owner = Bidder;
                        Token.OwnerJid = BidderJid;
                        Token.OwnershipContract = BidId;
                        await Token.Sign();
 
                        TransferToAuctioneer = new Transferred()
                        {
                            ArchiveOptional = Token.ArchiveOptional,
                            ArchiveRequired = Token.ArchiveRequired,
                            Expires = Token.Expires,
                            Seller = Item.InitiatorLegalId,
                            Owner = Item.TrustProviderLegalId,
                            OwnershipContract = Item.ContractId,
                            Value = Amount,
                            Commission = 0,
                            Currency = Item.Currency,
                            TokenId = Token.TokenId,
                            Timestamp = DateTime.UtcNow.AddSeconds(-1),
                            Personal = false
                        };
 
                        TransferToBuyer = new Transferred()
                        {
                            ArchiveOptional = Token.ArchiveOptional,
                            ArchiveRequired = Token.ArchiveRequired,
                            Expires = Token.Expires,
                            Seller = Item.TrustProviderLegalId,
                            Owner = Bidder,
                            OwnershipContract = BidId,
                            Value = Amount,
                            Commission = Commission,
                            Currency = Item.Currency,
                            TokenId = Token.TokenId,
                            Timestamp = DateTime.UtcNow,
                            Personal = false
                        };
                        break;
 
                    case OptimizeDirection.Down:    // Generator of best offer sells item to generator of item
 
                        SellerJid = BidderJid;
                        BuyerJid = Item.InitiatorJid;
 
                        Token.Value = Amount;
                        Token.Currency = Item.Currency;
                        Token.Owner = Item.InitiatorLegalId;
                        Token.OwnerJid = Item.InitiatorJid;
                        Token.OwnershipContract = Item.ContractId;
                        await Token.Sign();
 
                        TransferToAuctioneer = new Transferred()
                        {
                            ArchiveOptional = Token.ArchiveOptional,
                            ArchiveRequired = Token.ArchiveRequired,
                            Expires = Token.Expires,
                            Seller = Bidder,
                            Owner = Item.TrustProviderLegalId,
                            OwnershipContract = BidId,
                            Value = Amount,
                            Commission = 0,
                            Currency = Item.Currency,
                            TokenId = Token.TokenId,
                            Timestamp = DateTime.UtcNow.AddSeconds(-1),
                            Personal = false
                        };
 
                        TransferToBuyer = new Transferred()
                        {
                            ArchiveOptional = Token.ArchiveOptional,
                            ArchiveRequired = Token.ArchiveRequired,
                            Expires = Token.Expires,
                            Seller = Item.TrustProviderLegalId,
                            Owner = Item.InitiatorLegalId,
                            OwnershipContract = Item.ContractId,
                            Value = Amount,
                            Commission = Commission,
                            Currency = Item.Currency,
                            TokenId = Token.TokenId,
                            Timestamp = DateTime.UtcNow,
                            Personal = false
                        };
 
                        break;
 
                    default:
                        return false;
                }
 
                await Database.StartBulk();
                try
                {
                    await NeuroFeaturesProcessor.DeletePersonalEvents(new string[] { Token.TokenId });
                    await Database.Update(Token);
 
                    try
                    {
                        await Database.Insert(TransferToAuctioneer, TransferToBuyer);
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                    }
 
                    // TODO: Protect integrity with transaction, commit, rollback, etc.
                }
                finally
                {
                    await Database.EndBulk();
                }
 
                try
                {
                    await StateMachineProcessor.EventGenerated(Token, TransferToAuctioneer);
                }
                catch (Exception ex)
                {
                    Log.Exception(ex, Token.TokenId);
                }
 
                try
                {
                    await StateMachineProcessor.EventGenerated(Token, TransferToBuyer);
                }
                catch (Exception ex)
                {
                    Log.Exception(ex, Token.TokenId);
                }
 
                StringBuilder Xml = new StringBuilder();
 
                Xml.Append("<tokenRemoved xmlns='");
                Xml.Append(NeuroFeaturesProcessor.NeuroFeaturesNamespace);
                Xml.Append("'>");
                await Token.Serialize(Xml, false, true);
                Xml.Append("</tokenRemoved>");
 
                if (await NeuroFeaturesProcessor.SendTokenMessage(EDaler, Xml.ToString(), SellerJid, true, true))
                    await NeuroFeaturesProcessor.TokenRemoved(Token, SellerJid);
 
                Xml.Clear();
 
                Xml.Append("<tokenAdded xmlns='");
                Xml.Append(NeuroFeaturesProcessor.NeuroFeaturesNamespace);
                Xml.Append("'>");
                await Token.Serialize(Xml, false, true);
                Xml.Append("</tokenAdded>");
 
                if (await NeuroFeaturesProcessor.SendTokenMessage(EDaler, Xml.ToString(), BuyerJid, true, true))
                    await NeuroFeaturesProcessor.TokenAdded(Token, BuyerJid);
            }
 
            return true;
        }
 
    }
}