EDalerClient.cs

using EDaler.Events;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Networking.XMPP;
using Waher.Networking.XMPP.Contracts;
using Waher.Networking.XMPP.Events;
using Waher.Persistence;
using Waher.Runtime.Settings;
using Waher.Script;
 
namespace EDaler
{
    public class EDalerClient : XmppExtension
    {
        public const string NamespaceEDaler = "http://waher.se/Schema/eDaler.xsd";
 
        internal const string EDalerBalanceKeyPrefix = "EDaler.Balance.";
        internal const string EDalerRemoteKeyPrefix = "EDaler.Remote.Key.";
 
        private readonly ContractsClient contractsClient;
        private readonly string componentAddress;
        private LastBalance balance = null;
 
        public EDalerClient(XmppClient Client, ContractsClient ContractsClient, string ComponentAddress)
            : base(Client)
        {
            this.componentAddress = ComponentAddress;
            this.contractsClient = ContractsClient;
 
            Client.RegisterMessageHandler("balance", NamespaceEDaler, this.BalanceEventHandler, true);
            Client.RegisterMessageHandler("buyEDalerOptionsClientUrl", NamespaceEDaler, this.BuyEDalerOptionsClientUrlEventHandler, false);
            Client.RegisterMessageHandler("buyEDalerOptionsCompleted", NamespaceEDaler, this.BuyEDalerOptionsCompletedEventHandler, false);
            Client.RegisterMessageHandler("buyEDalerOptionsError", NamespaceEDaler, this.BuyEDalerOptionsErrorEventHandler, false);
            Client.RegisterMessageHandler("buyEDalerClientUrl", NamespaceEDaler, this.BuyEDalerClientUrlEventHandler, false);
            Client.RegisterMessageHandler("buyEDalerCompleted", NamespaceEDaler, this.BuyEDalerCompletedEventHandler, false);
            Client.RegisterMessageHandler("buyEDalerError", NamespaceEDaler, this.BuyEDalerErrorEventHandler, false);
            Client.RegisterMessageHandler("sellEDalerOptionsClientUrl", NamespaceEDaler, this.SellEDalerOptionsClientUrlEventHandler, false);
            Client.RegisterMessageHandler("sellEDalerOptionsCompleted", NamespaceEDaler, this.SellEDalerOptionsCompletedEventHandler, false);
            Client.RegisterMessageHandler("sellEDalerOptionsError", NamespaceEDaler, this.SellEDalerOptionsErrorEventHandler, false);
            Client.RegisterMessageHandler("sellEDalerClientUrl", NamespaceEDaler, this.SellEDalerClientUrlEventHandler, false);
            Client.RegisterMessageHandler("sellEDalerCompleted", NamespaceEDaler, this.SellEDalerCompletedEventHandler, false);
            Client.RegisterMessageHandler("sellEDalerError", NamespaceEDaler, this.SellEDalerErrorEventHandler, false);
        }
 
        public override void Dispose()
        {
            this.client.UnregisterMessageHandler("balance", NamespaceEDaler, this.BalanceEventHandler, true);
            this.client.UnregisterMessageHandler("buyEDalerOptionsClientUrl", NamespaceEDaler, this.BuyEDalerOptionsClientUrlEventHandler, false);
            this.client.UnregisterMessageHandler("buyEDalerOptionsCompleted", NamespaceEDaler, this.BuyEDalerOptionsCompletedEventHandler, false);
            this.client.UnregisterMessageHandler("buyEDalerOptionsError", NamespaceEDaler, this.BuyEDalerOptionsErrorEventHandler, false);
            this.client.UnregisterMessageHandler("buyEDalerClientUrl", NamespaceEDaler, this.BuyEDalerClientUrlEventHandler, false);
            this.client.UnregisterMessageHandler("buyEDalerCompleted", NamespaceEDaler, this.BuyEDalerCompletedEventHandler, false);
            this.client.UnregisterMessageHandler("buyEDalerError", NamespaceEDaler, this.BuyEDalerErrorEventHandler, false);
            this.client.UnregisterMessageHandler("sellEDalerOptionsClientUrl", NamespaceEDaler, this.SellEDalerOptionsClientUrlEventHandler, false);
            this.client.UnregisterMessageHandler("sellEDalerOptionsCompleted", NamespaceEDaler, this.SellEDalerOptionsCompletedEventHandler, false);
            this.client.UnregisterMessageHandler("sellEDalerOptionsError", NamespaceEDaler, this.SellEDalerOptionsErrorEventHandler, false);
            this.client.UnregisterMessageHandler("sellEDalerClientUrl", NamespaceEDaler, this.SellEDalerClientUrlEventHandler, false);
            this.client.UnregisterMessageHandler("sellEDalerCompleted", NamespaceEDaler, this.SellEDalerCompletedEventHandler, false);
            this.client.UnregisterMessageHandler("sellEDalerError", NamespaceEDaler, this.SellEDalerErrorEventHandler, false);
 
            base.Dispose();
        }
 
        public string ComponentAddress => this.componentAddress;
 
        public override string[] Extensions => new string[] { };
 
        #region Balance
 
        public Task GetBalance(EventHandlerAsync<BalanceIqResultEventArgs> Callback, object State)
        {
            return this.GetBalance(this.componentAddress, Callback, State);
        }
 
        public Task GetBalance(string ComponentAddress, EventHandlerAsync<BalanceIqResultEventArgs> Callback, object State)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<balance xmlns='");
            Xml.Append(NamespaceEDaler);
            Xml.Append("'/>");
 
            return this.client.SendIqGet(ComponentAddress, Xml.ToString(), async (Sender, e) =>
            {
                XmlElement E;
                Balance Balance;
 
                if (e.Ok &&
                    !((E = e.FirstElement) is null) &&
                    E.LocalName == "balance" &&
                    E.NamespaceURI == NamespaceEDaler)
                {
                    Balance = await this.ParseBalance(E);
 
                    if (Balance is null)
                        e.Ok = false;
                    else
                        await this.BalanceReported(Balance);
                }
                else
                {
                    e.Ok = false;
                    Balance = null;
                }
 
                await Callback.Raise(this, new BalanceIqResultEventArgs(e, Balance));
 
            }, State);
        }
 
        private async Task BalanceReported(Balance Balance)
        {
            string LastBalanceKey = EDalerBalanceKeyPrefix + this.client.BareJID;
            bool Changed = false;
 
            this.balance ??= await RuntimeSettings.GetAsync(LastBalanceKey, (object)null) as LastBalance;
 
            if (this.balance is null ||
                this.balance.Timestamp < Balance.Timestamp ||
                (this.balance.Timestamp < Balance.Timestamp.AddSeconds(1) && this.balance.Balance != Balance.Amount))
            {
                if (this.balance is null)
                {
                    this.balance = new LastBalance()
                    {
                        Balance = Balance.Amount,
                        Currency = Balance.Currency,
                        Timestamp = Balance.Timestamp
                    };
                }
                else
                {
                    this.balance.Balance = Balance.Amount;
                    this.balance.Currency = Balance.Currency;
                    this.balance.Timestamp = Balance.Timestamp;
                }
 
                Changed = true;
            }
 
            if (!(this.balance.Pending is null) && !(Balance.Event is null))
            {
                List<PendingPayment> Pending = new List<PendingPayment>();
                DateTime Today = DateTime.Today;
 
                foreach (PendingPayment Payment in this.balance.Pending)
                {
                    if (Payment.Expires.AddDays(1) < Today || Payment.Id == Balance.Event.TransactionId)
                    {
                        Changed = true;
                        continue;
                    }
 
                    Pending.Add(Payment);
                }
 
                if (Changed)
                    this.balance.Pending = Pending.ToArray();
            }
 
            if (Changed)
                await RuntimeSettings.SetAsync(LastBalanceKey, this.balance);
        }
 
        public Task<Balance> GetBalanceAsync()
        {
            return this.GetBalanceAsync(this.componentAddress);
        }
 
        public async Task<Balance> GetBalanceAsync(string ComponentAddress)
        {
            TaskCompletionSource<Balance> Result = new TaskCompletionSource<Balance>();
 
            await this.GetBalance(ComponentAddress, async (Sender, e) =>
            {
                if (e.Ok)
                {
                    await this.BalanceReported(e.Balance);
                    Result.TrySetResult(e.Balance);
                }
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to get current balance."));
 
            }, null);
 
            return await Result.Task;
        }
 
        private async Task BalanceEventHandler(object Sender, MessageEventArgs e)
        {
            if (e.From != this.componentAddress)
                return;
 
            Balance Balance = await this.ParseBalance(e.Content);
            await this.BalanceReported(Balance);
 
            await this.BalanceUpdated.Raise(this, new BalanceEventArgs(Balance));
        }
 
        private async Task<Balance> ParseBalance(XmlElement Xml)
        {
            CaseInsensitiveString Currency = null;
            DateTime? Timestamp = null;
            decimal? Balance = null;
            decimal Reserved = 0;
            AccountEvent Event = null;
 
            foreach (XmlAttribute Attr in Xml.Attributes)
            {
                switch (Attr.Name)
                {
                    case "amount":
                        if (!CommonTypes.TryParse(Attr.Value, out decimal d))
                            return null;
 
                        Balance = d;
                        break;
 
                    case "reserved":
                        if (!CommonTypes.TryParse(Attr.Value, out d))
                            return null;
 
                        Reserved = d;
                        break;
 
                    case "currency":
                        Currency = Attr.Value;
                        break;
 
                    case "timestamp":
                        if (!XML.TryParse(Attr.Value, out DateTime TP))
                            return null;
 
                        Timestamp = TP;
                        break;
                }
            }
 
            if (!Balance.HasValue || Currency is null || !Timestamp.HasValue)
                return null;
 
            foreach (XmlNode N in Xml.ChildNodes)
            {
                if (N is XmlElement E && E.LocalName == "event" && E.NamespaceURI == NamespaceEDaler)
                {
                    Event = await AccountEvent.FromXml(E, this);
                    break;
                }
            }
 
            return new Balance(Timestamp.Value, Balance.Value, Reserved, Currency, Event);
        }
 
        public event EventHandlerAsync<BalanceEventArgs> BalanceUpdated = null;
 
        #endregion
 
        #region eDaler URIs
 
        public Task SendEDalerUri(string Uri, EventHandlerAsync<TransactionEventArgs> Callback, object State)
        {
            return this.SendEDalerUri(this.componentAddress, Uri, Callback, State);
        }
 
        public Task SendEDalerUri(string ComponentAddress, string Uri, EventHandlerAsync<TransactionEventArgs> Callback, object State)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<uri xmlns=\"");
            Xml.Append(NamespaceEDaler);
            Xml.Append("\">");
            Xml.Append(XML.Encode(Uri));
            Xml.Append("</uri>");
 
            return this.client.SendIqSet(ComponentAddress, Xml.ToString(), async (Sender, e) =>
            {
                if (Callback is null)
                    return;
 
                Transaction Transaction = null;
 
                if (e.Ok)
                {
                    if (e.FirstElement is null ||
                        e.FirstElement.LocalName != "tr" ||
                        e.FirstElement.NamespaceURI != NamespaceEDaler)
                    {
                        e.Ok = false;
                    }
                    else
                        Transaction = Transaction.FromXml(e.FirstElement);
                }
 
                await Callback.Raise(this, new TransactionEventArgs(e, Transaction));
 
            }, State);
        }
 
        public Task<Transaction> SendEDalerUriAsync(string Uri)
        {
            return this.SendEDalerUriAsync(this.componentAddress, Uri);
        }
 
        public async Task<Transaction> SendEDalerUriAsync(string ComponentAddress, string Uri)
        {
            TaskCompletionSource<Transaction> Result = new TaskCompletionSource<Transaction>();
 
            await this.SendEDalerUri(ComponentAddress, Uri, (Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(e.Transaction);
                else if (!(e.StanzaError is null))
                    Result.TrySetException(e.StanzaError);
                else
                    Result.TrySetException(new Exception("Unable to process eDaler URI."));
 
                return Task.CompletedTask;
            }, null);
 
            return await Result.Task;
        }
 
        #endregion
 
        #region eDaler Account events
 
        public Task GetAccountEvents(int MaxEvents, EventHandlerAsync<AccountEventsEventArgs> Callback, object State)
        {
            return this.GetAccountEvents(this.componentAddress, MaxEvents, DateTime.MaxValue, Callback, State);
        }
 
        public Task GetAccountEvents(string ComponentAddress, int MaxEvents, EventHandlerAsync<AccountEventsEventArgs> Callback, object State)
        {
            return this.GetAccountEvents(ComponentAddress, MaxEvents, DateTime.MaxValue, Callback, State);
        }
 
        public Task GetAccountEvents(int MaxEvents, DateTime From, EventHandlerAsync<AccountEventsEventArgs> Callback, object State)
        {
            return this.GetAccountEvents(this.componentAddress, MaxEvents, From, Callback, State);
        }
 
        public Task GetAccountEvents(string ComponentAddress, int MaxEvents, DateTime From, EventHandlerAsync<AccountEventsEventArgs> Callback, object State)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<events xmlns=\"");
            Xml.Append(NamespaceEDaler);
            Xml.Append("\" maxCount=\"");
            Xml.Append(MaxEvents.ToString());
 
            if (From != DateTime.MaxValue)
            {
                Xml.Append("\" from=\"");
                Xml.Append(XML.Encode(From));
            }
 
            Xml.Append("\"/>");
 
            return this.client.SendIqGet(ComponentAddress, Xml.ToString(), async (Sender, e) =>
            {
                List<AccountEvent> Events = new List<AccountEvent>();
                bool More = false;
 
                if (e.Ok)
                {
                    if (e.FirstElement is null ||
                        e.FirstElement.LocalName != "events" ||
                        e.FirstElement.NamespaceURI != NamespaceEDaler)
                    {
                        e.Ok = false;
                    }
                    else
                    {
                        foreach (XmlNode N in e.FirstElement.ChildNodes)
                        {
                            if (!(N is XmlElement E) || E.NamespaceURI != NamespaceEDaler)
                                continue;
 
                            switch (E.LocalName)
                            {
                                case "event":
                                    AccountEvent Event = await AccountEvent.FromXml(E, this);
                                    Events.Add(Event);
                                    break;
 
                                case "more":
                                    More = true;
                                    break;
                            }
                        }
 
                        await Callback.Raise(this, new AccountEventsEventArgs(Events.ToArray(), More, e));
                    }
                }
            }, State);
        }
 
 
        public Task<(AccountEvent[], bool)> GetAccountEventsAsync(int MaxEvents)
        {
            return this.GetAccountEventsAsync(this.componentAddress, MaxEvents, DateTime.MaxValue);
        }
 
        public Task<(AccountEvent[], bool)> GetAccountEventsAsync(string ComponentAddress, int MaxEvents)
        {
            return this.GetAccountEventsAsync(ComponentAddress, MaxEvents, DateTime.MaxValue);
        }
 
        public Task<(AccountEvent[], bool)> GetAccountEventsAsync(int MaxEvents, DateTime From)
        {
            return this.GetAccountEventsAsync(this.componentAddress, MaxEvents, From);
        }
 
        public async Task<(AccountEvent[], bool)> GetAccountEventsAsync(string ComponentAddress, int MaxEvents, DateTime From)
        {
            TaskCompletionSource<(AccountEvent[], bool)> Result = new TaskCompletionSource<(AccountEvent[], bool)>();
 
            await this.GetAccountEvents(ComponentAddress, MaxEvents, From, async (Sender, e) =>
            {
                if (e.Ok)
                {
                    try
                    {
                        if (this.balance is null)
                            await this.GetBalanceAsync();
 
                        if (!(this.balance.Pending is null) && this.balance.Pending.Length > 0)
                        {
                            Dictionary<Guid, PendingPayment> Pending = new Dictionary<Guid, PendingPayment>();
                            DateTime Today = DateTime.Today;
                            bool Changed = false;
 
                            foreach (PendingPayment Payment in this.balance.Pending)
                            {
                                if (Payment.Expires.AddDays(1) < Today)
                                    Changed = true;
                                else
                                    Pending[Payment.Id] = Payment;
                            }
 
                            foreach (AccountEvent Event in e.Events)
                            {
                                if (Pending.Remove(Event.TransactionId))
                                    Changed = true;
                            }
 
                            if (Changed)
                            {
                                PendingPayment[] Pending2 = new PendingPayment[Pending.Count];
                                Pending.Values.CopyTo(Pending2, 0);
                                this.balance.Pending = Pending2;
 
                                await RuntimeSettings.SetAsync(EDalerBalanceKeyPrefix + this.client.BareJID, this.balance);
                            }
                        }
 
                        Result.TrySetResult((e.Events, e.More));
                    }
                    catch (Exception ex)
                    {
                        Result.TrySetException(ex);
                    }
                }
                else if (!(e.StanzaError is null))
                    Result.TrySetException(e.StanzaError);
                else
                    Result.TrySetException(new Exception("Unable to process eDaler URI."));
 
            }, null);
 
            return await Result.Task;
        }
 
        #endregion
 
        #region Payment URIs
 
        public Task<string> CreateFullPaymentUri(decimal Amount, decimal? AmountExtra,
            CaseInsensitiveString Currency, int ValidNrDays)
        {
            return this.CreateFullPaymentUri(string.Empty, Amount, AmountExtra, Currency, ValidNrDays, string.Empty);
        }
 
        public Task<string> CreateFullPaymentUri(string ToBareJid, decimal Amount, decimal? AmountExtra,
            CaseInsensitiveString Currency, int ValidNrDays)
        {
            return this.CreateFullPaymentUri(ToBareJid, Amount, AmountExtra, Currency, ValidNrDays, string.Empty);
        }
 
        public async Task<string> CreateFullPaymentUri(string ToBareJid, decimal Amount, decimal? AmountExtra,
            CaseInsensitiveString Currency, int ValidNrDays, string Message)
        {
            await this.ValidatePaymentArguments(Amount, AmountExtra, Currency, ValidNrDays);
 
            StringBuilder Uri = new StringBuilder();
            DateTime Created = DateTime.UtcNow;
            DateTime Expires = DateTime.Today.AddDays(ValidNrDays);
            Guid Id = Guid.NewGuid();
 
            Uri.Append("edaler:id=");
            Uri.Append(Id.ToString());
            Uri.Append(";f=");
            Uri.Append(XML.Encode(this.client.BareJID));
 
            if (!string.IsNullOrEmpty(ToBareJid))
            {
                if (ToBareJid.IndexOf('@') < 0)
                {
                    Uri.Append(";xx=");     // Destruction (payment to operator)
                    Uri.Append(XML.Encode(ToBareJid));
                }
                else
                {
                    Uri.Append(";t=");
                    Uri.Append(XML.Encode(ToBareJid));
                }
            }
 
            Uri.Append(";am=");
            Uri.Append(CommonTypes.Encode(Amount));
 
            if (AmountExtra.HasValue)
            {
                Uri.Append(";amx=");
                Uri.Append(CommonTypes.Encode(AmountExtra.Value));
            }
 
            Uri.Append(";cu=");
            Uri.Append(XML.Encode(Currency));
            Uri.Append(";cr=");
            Uri.Append(XML.Encode(Created, false));
            Uri.Append(";ex=");
            Uri.Append(XML.Encode(Expires, true));
 
            if (!string.IsNullOrEmpty(Message))
            {
                Uri.Append(";m=");
                Uri.Append(Convert.ToBase64String(Encoding.UTF8.GetBytes(Message)));
            }
 
            await this.SignAndCheckBalance(Uri, Amount, AmountExtra, Currency, Id, Expires, ToBareJid);
 
            return Uri.ToString();
        }
 
        private async Task ValidatePaymentArguments(decimal Amount, decimal? AmountExtra, CaseInsensitiveString Currency, int ValidNrDays)
        {
            if (ValidNrDays <= 0)
                throw new ArgumentException("Must be a positive integer.", nameof(ValidNrDays));
 
            if (Amount <= 0)
                throw new ArgumentException("Amount must be positive.", nameof(Amount));
 
            if (AmountExtra.HasValue && AmountExtra.Value <= 0)
                throw new ArgumentException("Amount must be positive.", nameof(AmountExtra));
 
            if (this.balance is null)
                await this.GetBalanceAsync();
 
            LastBalance Balance = this.balance;
            if (Currency != Balance.Currency)   // TODO: Currency conversion, if supported by neuron
            {
                throw new ArgumentException("Currency in payment (" + Currency.Value +
                    ") does not correspond to currency of wallet (" + Balance.Currency.Value + ").",
                    nameof(Currency));
            }
        }
 
        private async Task SignAndCheckBalance(StringBuilder Uri, decimal Amount, decimal? AmountExtra, string Currency,
            Guid Id, DateTime Expires, string To)
        {
            byte[] PreSign = Encoding.UTF8.GetBytes(Uri.ToString());
            byte[] Signature = await this.contractsClient.SignAsync(PreSign, SignWith.LatestApprovedId);
 
            Uri.Append(";s=");
            Uri.Append(Convert.ToBase64String(Signature));
 
            LastBalance Balance;
            DateTime Today = DateTime.Today;
            List<PendingPayment> Pending;
            decimal PendingAmount;
 
            do
            {
                Balance = this.balance;
                Pending = new List<PendingPayment>();
                PendingAmount = 0;
 
                if (!(Balance.Pending is null))
                {
                    foreach (PendingPayment PendingPayment in Balance.Pending)
                    {
                        if (PendingPayment.Expires.AddDays(1) >= Today)
                        {
                            Pending.Add(PendingPayment);
                            PendingAmount += PendingPayment.Amount;
                        }
                    }
                }
 
                if (Amount + (AmountExtra ?? 0) + PendingAmount > Balance.Balance)
                {
                    StringBuilder Msg = new StringBuilder();
 
                    Msg.Append("Amount larger than current balance. Amount: ");
                    Msg.Append(Amount.ToString());
 
                    if (AmountExtra.HasValue)
                    {
                        Msg.Append(". Extra: ");
                        Msg.Append(AmountExtra.Value.ToString());
                    }
 
                    if (PendingAmount > 0)
                    {
                        Msg.Append(". Pending: ");
                        Msg.Append(PendingAmount.ToString());
                    }
 
                    Msg.Append(". Balance: ");
                    Msg.Append(Balance.Balance.ToString());
 
                    Msg.Append(". Difference: ");
                    Msg.Append((Balance.Balance - Amount - (AmountExtra ?? 0) - PendingAmount).ToString());
 
                    throw new InvalidOperationException(Msg.ToString());
                }
 
                Pending.Add(new PendingPayment()
                {
                    Id = Id,
                    Expires = Expires,
                    Currency = Currency,
                    Amount = Amount + (AmountExtra ?? 0),
                    From = this.client.BareJID,
                    To = To,
                    Uri = Uri.ToString()
                });
 
                Balance.Pending = Pending.ToArray();
 
                await RuntimeSettings.SetAsync(EDalerBalanceKeyPrefix + this.client.BareJID, Balance);
            }
            while (this.balance != Balance);
        }
 
        public Task<string> CreateFullPaymentUri(LegalIdentity ToLegalId, decimal Amount, decimal? AmountExtra,
            CaseInsensitiveString Currency, int ValidNrDays)
        {
            return this.CreateFullPaymentUri(ToLegalId, Amount, AmountExtra, Currency, ValidNrDays, string.Empty);
        }
 
        public async Task<string> CreateFullPaymentUri(LegalIdentity RecipientLegalId,
            decimal Amount, decimal? AmountExtra, CaseInsensitiveString Currency,
            int ValidNrDays, string PrivateMessage)
        {
            if (RecipientLegalId is null)
                throw new ArgumentNullException("Recipient Legal ID cannot be null.", nameof(RecipientLegalId));
 
            if (!RecipientLegalId.HasClientPublicKey)
                throw new ArgumentNullException("Recipient Legal ID lacks a public key.", nameof(RecipientLegalId));
 
            await this.ValidatePaymentArguments(Amount, AmountExtra, Currency, ValidNrDays);
 
            StringBuilder Uri = new StringBuilder();
            DateTime Created = DateTime.UtcNow;
            DateTime Expires = DateTime.Today.AddDays(ValidNrDays);
            Guid Id = Guid.NewGuid();
 
            byte[] MessageBin = Encoding.UTF8.GetBytes(PrivateMessage ?? string.Empty);
            (byte[] EncryptedMessage, byte[] LocalPublicKey) = this.contractsClient.Encrypt(MessageBin, Id.ToByteArray(), RecipientLegalId.ClientPubKey, RecipientLegalId.ClientKeyName);
 
            await RuntimeSettings.SetAsync(EDalerRemoteKeyPrefix + RecipientLegalId.Id, Convert.ToBase64String(RecipientLegalId.ClientPubKey));
            string FromLegalId = await this.contractsClient.GetLatestApprovedLegalId(LocalPublicKey);
 
            Uri.Append("edaler:id=");
            Uri.Append(Id.ToString());
 
            if (FromLegalId is null)
            {
                Uri.Append(";f=");
                Uri.Append(XML.Encode(this.client.BareJID));
            }
            else
            {
                Uri.Append(";fi=");
                Uri.Append(XML.Encode(FromLegalId));
            }
 
            Uri.Append(";ti=");
            Uri.Append(XML.Encode(RecipientLegalId.Id));
            Uri.Append(";am=");
            Uri.Append(CommonTypes.Encode(Amount));
 
            if (AmountExtra.HasValue)
            {
                Uri.Append(";amx=");
                Uri.Append(CommonTypes.Encode(AmountExtra.Value));
            }
 
            Uri.Append(";cu=");
            Uri.Append(XML.Encode(Currency));
            Uri.Append(";cr=");
            Uri.Append(XML.Encode(Created, false));
            Uri.Append(";ex=");
            Uri.Append(XML.Encode(Expires, true));
 
            if (!string.IsNullOrEmpty(PrivateMessage))
            {
                Uri.Append(";em=");
                Uri.Append(Convert.ToBase64String(EncryptedMessage));
                Uri.Append(";ep=");
                Uri.Append(Convert.ToBase64String(LocalPublicKey));
            }
 
            await this.SignAndCheckBalance(Uri, Amount, AmountExtra, Currency, Id, Expires, RecipientLegalId.Id);
 
            return Uri.ToString();
        }
 
        public string CreateIncompletePayMeUri(string BareJid, decimal? Amount, decimal? AmountExtra, string Currency, string Message)
        {
            return this.CreateIncompletePayMeUri(BareJid, "t", Amount, AmountExtra, Currency, Message);
        }
 
        public string CreateIncompletePayMeUri(LegalIdentity Id, decimal? Amount, decimal? AmountExtra,
            string Currency, string PrivateMessage)
        {
            return this.CreateIncompletePayMeUri(Id.Id, "ti", Amount, AmountExtra, Currency, PrivateMessage);
        }
 
        private string CreateIncompletePayMeUri(string To, string ToType, decimal? Amount, decimal? AmountExtra,
            string Currency, string Message)
        {
            StringBuilder Uri = new StringBuilder();
 
            Uri.Append("edaler:cu=");
            Uri.Append(Currency);
 
            if (Amount.HasValue)
            {
                Uri.Append(";am=");
                Uri.Append(CommonTypes.Encode(Amount.Value));
            }
 
            if (AmountExtra.HasValue)
            {
                Uri.Append(";amx=");
                Uri.Append(CommonTypes.Encode(AmountExtra.Value));
            }
 
            Uri.Append(';');
            Uri.Append(ToType);
            Uri.Append('=');
            Uri.Append(To);
 
            if (!string.IsNullOrEmpty(Message))
            {
                Uri.Append(";m=");
                Uri.Append(Convert.ToBase64String(Encoding.UTF8.GetBytes(Message)));
            }
 
            return Uri.ToString();
        }
 
        public string DecryptMessage(byte[] EncryptedMessage, byte[] PublicKey,
            Guid TransactionId, bool LocalIsRecipient)
        {
            if (EncryptedMessage is null)
                return string.Empty;
 
            if (PublicKey is null)
                return Encoding.UTF8.GetString(EncryptedMessage);
 
            try
            {
                byte[] Decrypted;
 
                if (PublicKey is null)
                    Decrypted = EncryptedMessage;
                else if (LocalIsRecipient)
                {
                    Decrypted = this.contractsClient.DecryptReceivedMessage(EncryptedMessage, PublicKey,
                        TransactionId.ToByteArray());
                }
                else
                {
                    Decrypted = this.contractsClient.DecryptSentMessage(EncryptedMessage, PublicKey,
                        TransactionId.ToByteArray());
                }
 
                return Encoding.UTF8.GetString(Decrypted);
            }
            catch (Exception)
            {
                return string.Empty;
            }
        }
 
        public async Task<string> DecryptMessage(byte[] EncryptedMessage, byte[] PublicKey,
            Guid TransactionId, string RemoteEndPoint, bool LocalIsRecipient)
        {
            if (!string.IsNullOrEmpty(RemoteEndPoint) && PublicKey is null)
            {
                string RemotePublicKey = await RuntimeSettings.GetAsync(EDalerRemoteKeyPrefix + RemoteEndPoint, string.Empty);
 
                if (!string.IsNullOrEmpty(RemotePublicKey))
                {
                    try
                    {
                        PublicKey = Convert.FromBase64String(RemotePublicKey);
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                    }
                }
            }
 
            return this.DecryptMessage(EncryptedMessage, PublicKey, TransactionId, LocalIsRecipient);
        }
 
        #endregion
 
        #region Pending Payments
 
        public async Task<(decimal, string, PendingPayment[])> GetPendingPayments()
        {
            if (this.balance is null)
                await this.GetBalanceAsync();
 
            List<PendingPayment> PendingPayments = new List<PendingPayment>();
            DateTime Today = DateTime.Today;
            LastBalance Balance = this.balance;
            decimal PendingAmount = 0;
 
            if (!(Balance.Pending is null))
            {
                foreach (PendingPayment PendingPayment in Balance.Pending)
                {
                    if (PendingPayment.Expires.AddDays(1) >= Today)
                    {
                        PendingPayments.Add(new PendingPayment()
                        {
                            Id = PendingPayment.Id,
                            Expires = PendingPayment.Expires,
                            Currency = PendingPayment.Currency,
                            Amount = PendingPayment.Amount,
                            From = PendingPayment.From,
                            To = PendingPayment.To,
                            Uri = PendingPayment.Uri
                        });
 
                        PendingAmount += PendingPayment.Amount;
                    }
                }
            }
 
            return (PendingAmount, Balance.Currency, PendingPayments.ToArray());
        }
 
        #endregion
 
        #region Service Providers for buying eDaler
 
        public Task GetServiceProvidersForBuyingEDaler(EventHandlerAsync<BuyEDalerServiceProvidersEventArgs> Callback, object State)
        {
            return this.GetServiceProvidersForBuyingEDaler(this.componentAddress, Callback, State);
        }
 
        public Task GetServiceProvidersForBuyingEDaler(string ComponentAddress,
            EventHandlerAsync<BuyEDalerServiceProvidersEventArgs> Callback, object State)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<buyEDalerProviders xmlns='");
            Xml.Append(NamespaceEDaler);
            Xml.Append("'/>");
 
            return this.client.SendIqGet(ComponentAddress, Xml.ToString(), async (Sender, e) =>
            {
                List<IBuyEDalerServiceProvider> Providers = null;
                XmlElement E;
 
                if (e.Ok &&
                    !((E = e.FirstElement) is null) &&
                    E.LocalName == "providers" &&
                    E.NamespaceURI == NamespaceEDaler)
                {
                    Providers = new List<IBuyEDalerServiceProvider>();
 
                    foreach (XmlNode N in E.ChildNodes)
                    {
                        if (N is XmlElement E2 &&
                            E2.LocalName == "provider" &&
                            E2.NamespaceURI == NamespaceEDaler)
                        {
                            IBuyEDalerServiceProvider Provider = this.ParseServiceProvider<BuyEDalerServiceProvider>(E2);
 
                            if (!(Provider is null))
                                Providers.Add(Provider);
                        }
                    }
                }
                else
                    e.Ok = false;
 
                await Callback.Raise(this, new BuyEDalerServiceProvidersEventArgs(e, Providers?.ToArray()));
 
            }, State);
        }
 
        private T ParseServiceProvider<T>(XmlElement Xml)
            where T : IServiceProviderWithTemplate, new()
        {
            string Id = null;
            string Type = null;
            string Name = null;
            string IconUrl = null;
            string TemplateId = null;
            int IconWidth = -1;
            int IconHeight = -1;
 
            foreach (XmlAttribute Attr in Xml.Attributes)
            {
                switch (Attr.Name)
                {
                    case "id":
                        Id = Attr.Value;
                        break;
 
                    case "type":
                        Type = Attr.Value;
                        break;
 
                    case "name":
                        Name = Attr.Value;
                        break;
 
                    case "iconUrl":
                        IconUrl = Attr.Value;
                        break;
 
                    case "iconWidth":
                        if (!int.TryParse(Attr.Value, out int i))
                            return default;
 
                        IconWidth = i;
                        break;
 
                    case "iconHeight":
                        if (!int.TryParse(Attr.Value, out i))
                            return default;
 
                        IconHeight = i;
                        break;
 
                    case "templateId":
                        TemplateId = Attr.Value;
                        break;
                }
            }
 
            if (Id is null || Type is null || Name is null)
                return default;
 
            if (string.IsNullOrEmpty(IconUrl))
            {
                T Temp = new T();
                return (T)Temp.Create(Id, Type, Name, TemplateId);
            }
            else
            {
                if (IconWidth < 0 || IconHeight < 0)
                    return default;
 
                T Temp = new T();
                return (T)Temp.Create(Id, Type, Name, IconUrl, IconWidth, IconHeight, TemplateId);
            }
        }
 
        public Task<IBuyEDalerServiceProvider[]> GetServiceProvidersForBuyingEDalerAsync()
        {
            return this.GetServiceProvidersForBuyingEDalerAsync(this.componentAddress);
        }
 
        public async Task<IBuyEDalerServiceProvider[]> GetServiceProvidersForBuyingEDalerAsync(string ComponentAddress)
        {
            TaskCompletionSource<IBuyEDalerServiceProvider[]> Providers = new TaskCompletionSource<IBuyEDalerServiceProvider[]>();
 
            await this.GetServiceProvidersForBuyingEDaler(ComponentAddress, (Sender, e) =>
            {
                if (e.Ok)
                    Providers.TrySetResult(e.ServiceProviders);
                else
                    Providers.TrySetException(e.StanzaError ?? new Exception("Unable to get service providers."));
 
                return Task.CompletedTask;
 
            }, null);
 
            return await Providers.Task;
        }
 
        #endregion
 
        #region Service Providers for selling eDaler
 
        public Task GetServiceProvidersForSellingEDaler(EventHandlerAsync<SellEDalerServiceProvidersEventArgs> Callback, object State)
        {
            return this.GetServiceProvidersForSellingEDaler(this.componentAddress, Callback, State);
        }
 
        public Task GetServiceProvidersForSellingEDaler(string ComponentAddress,
            EventHandlerAsync<SellEDalerServiceProvidersEventArgs> Callback, object State)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<sellEDalerProviders xmlns='");
            Xml.Append(NamespaceEDaler);
            Xml.Append("'/>");
 
            return this.client.SendIqGet(ComponentAddress, Xml.ToString(), async (Sender, e) =>
            {
                List<ISellEDalerServiceProvider> Providers = null;
                XmlElement E;
 
                if (e.Ok &&
                    !((E = e.FirstElement) is null) &&
                    E.LocalName == "providers" &&
                    E.NamespaceURI == NamespaceEDaler)
                {
                    Providers = new List<ISellEDalerServiceProvider>();
 
                    foreach (XmlNode N in E.ChildNodes)
                    {
                        if (N is XmlElement E2 &&
                            E2.LocalName == "provider" &&
                            E2.NamespaceURI == NamespaceEDaler)
                        {
                            ISellEDalerServiceProvider Provider = this.ParseServiceProvider<SellEDalerServiceProvider>(E2);
 
                            if (!(Provider is null))
                                Providers.Add(Provider);
                        }
                    }
                }
                else
                    e.Ok = false;
 
                await Callback.Raise(this, new SellEDalerServiceProvidersEventArgs(e, Providers?.ToArray()));
 
            }, State);
        }
 
        public Task<ISellEDalerServiceProvider[]> GetServiceProvidersForSellingEDalerAsync()
        {
            return this.GetServiceProvidersForSellingEDalerAsync(this.componentAddress);
        }
 
        public async Task<ISellEDalerServiceProvider[]> GetServiceProvidersForSellingEDalerAsync(string ComponentAddress)
        {
            TaskCompletionSource<ISellEDalerServiceProvider[]> Providers = new TaskCompletionSource<ISellEDalerServiceProvider[]>();
 
            await this.GetServiceProvidersForSellingEDaler(ComponentAddress, (Sender, e) =>
            {
                if (e.Ok)
                    Providers.TrySetResult(e.ServiceProviders);
                else
                    Providers.TrySetException(e.StanzaError ?? new Exception("Unable to get service providers."));
 
                return Task.CompletedTask;
 
            }, null);
 
            return await Providers.Task;
        }
 
        #endregion
 
        #region Initiation of getting Payment options for buying eDaler using smart contracts
 
        public Task InitiateGetOptionsBuyEDaler(string ServiceId, string ServiceProvider,
            EventHandlerAsync<TransactionIdEventArgs> Callback, object State)
        {
            return this.InitiateGetOptionsBuyEDaler(this.componentAddress, ServiceId, ServiceProvider, Callback, State);
        }
 
        public Task InitiateGetOptionsBuyEDaler(string ComponentAddress, string ServiceId, string ServiceProvider,
            EventHandlerAsync<TransactionIdEventArgs> Callback, object State)
        {
            return this.InitiateGetOptionsBuyEDaler(ComponentAddress, ServiceId, ServiceProvider, null, null, null, null, Callback, State);
        }
 
        public Task InitiateGetOptionsBuyEDaler(string ServiceId, string ServiceProvider,
            string TransactionId, string SuccessUrl, string FailureUrl, string CancelUrl, EventHandlerAsync<TransactionIdEventArgs> Callback, object State)
        {
            return this.InitiateGetOptionsBuyEDaler(this.componentAddress, ServiceId, ServiceProvider, TransactionId, SuccessUrl, FailureUrl, CancelUrl, Callback, State);
        }
 
        public Task InitiateGetOptionsBuyEDaler(string ComponentAddress, string ServiceId, string ServiceProvider,
            string TransactionId, string SuccessUrl, string FailureUrl, string CancelUrl, EventHandlerAsync<TransactionIdEventArgs> Callback, object State)
        {
            if (!string.IsNullOrEmpty(SuccessUrl))
                SuccessUrl = SuccessUrl.Replace("{TID}", TransactionId);
 
            if (!string.IsNullOrEmpty(FailureUrl))
                FailureUrl = FailureUrl.Replace("{TID}", TransactionId);
 
            if (!string.IsNullOrEmpty(CancelUrl))
                CancelUrl = CancelUrl.Replace("{TID}", TransactionId);
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<initiateGetOptionsBuyEDaler xmlns='");
            Xml.Append(NamespaceEDaler);
            Xml.Append("' serviceId='");
            Xml.Append(XML.Encode(ServiceId));
            Xml.Append("' serviceProvider='");
            Xml.Append(XML.Encode(ServiceProvider));
 
            if (!string.IsNullOrEmpty(TransactionId))
            {
                Xml.Append("' tid='");
                Xml.Append(XML.Encode(TransactionId));
            }
 
            if (!string.IsNullOrEmpty(SuccessUrl))
            {
                Xml.Append("' successUrl='");
                Xml.Append(XML.Encode(SuccessUrl));
            }
 
            if (!string.IsNullOrEmpty(FailureUrl))
            {
                Xml.Append("' failureUrl='");
                Xml.Append(XML.Encode(FailureUrl));
            }
 
            if (!string.IsNullOrEmpty(CancelUrl))
            {
                Xml.Append("' cancelUrl='");
                Xml.Append(XML.Encode(CancelUrl));
            }
 
            Xml.Append("'/>");
 
            return this.client.SendIqSet(ComponentAddress, Xml.ToString(), async (Sender, e) =>
            {
                TransactionId = null;
                XmlElement E;
 
                if (e.Ok &&
                    !((E = e.FirstElement) is null) &&
                    E.LocalName == "transaction" &&
                    E.NamespaceURI == NamespaceEDaler)
                {
                    TransactionId = XML.Attribute(E, "tid");
                }
                else
                    e.Ok = false;
 
                await Callback.Raise(this, new TransactionIdEventArgs(e, TransactionId));
 
            }, State);
        }
 
        public Task<string> InitiateGetOptionsBuyEDalerAsync(string ServiceId, string ServiceProvider)
        {
            return this.InitiateGetOptionsBuyEDalerAsync(this.componentAddress, ServiceId, ServiceProvider, null, null, null, null);
        }
 
        public Task<string> InitiateGetOptionsBuyEDalerAsync(string ServiceId, string ServiceProvider,
            string TransactionId, string SuccessUrl, string FailureUrl, string CancelUrl)
        {
            return this.InitiateGetOptionsBuyEDalerAsync(this.componentAddress, ServiceId, ServiceProvider, TransactionId, SuccessUrl, FailureUrl, CancelUrl);
        }
 
        public async Task<string> InitiateGetOptionsBuyEDalerAsync(string ComponentAddress, string ServiceId, string ServiceProvider,
            string TransactionId, string SuccessUrl, string FailureUrl, string CancelUrl)
        {
            TaskCompletionSource<string> Result = new TaskCompletionSource<string>();
 
            await this.InitiateGetOptionsBuyEDaler(ComponentAddress, ServiceId, ServiceProvider, TransactionId, SuccessUrl, FailureUrl, CancelUrl,
                (Sender, e) =>
                {
                    if (e.Ok)
                        Result.TrySetResult(e.TransactionId);
                    else
                        Result.TrySetException(e.StanzaError ?? new Exception("Unable to initiate payment process."));
 
                    return Task.CompletedTask;
                }, null);
 
            return await Result.Task;
        }
 
        private Task BuyEDalerOptionsClientUrlEventHandler(object Sender, MessageEventArgs e)
        {
            string TransactionId = XML.Attribute(e.Content, "tid");
            string Url = XML.Attribute(e.Content, "url");
 
            return this.BuyEDalerOptionsClientUrlReceived.Raise(this, new BuyEDalerClientUrlEventArgs(e, TransactionId, Url));
        }
 
        public event EventHandlerAsync<BuyEDalerClientUrlEventArgs> BuyEDalerOptionsClientUrlReceived;
 
        private async Task BuyEDalerOptionsCompletedEventHandler(object Sender, MessageEventArgs e)
        {
            string TransactionId = XML.Attribute(e.Content, "tid");
            List<Dictionary<CaseInsensitiveString, object>> Options = new List<Dictionary<CaseInsensitiveString, object>>();
 
            foreach (XmlNode N in e.Content.ChildNodes)
            {
                if (N is XmlElement E && E.LocalName == "option" && E.NamespaceURI == NamespaceEDaler)
                {
                    Dictionary<CaseInsensitiveString, object> Option = new Dictionary<CaseInsensitiveString, object>();
                    Variables Variables = new Variables();
 
                    foreach (XmlNode N2 in E.ChildNodes)
                    {
                        if (N2 is XmlElement E2 && E2.LocalName == "variable" && E2.NamespaceURI == NamespaceEDaler)
                        {
                            string Name = XML.Attribute(E2, "name");
                            object Value = await ParseVariable(E2, Variables);
 
                            Option[Name] = Value;
                        }
                    }
 
                    Options.Add(Option);
                }
            }
 
            await this.BuyEDalerOptionsCompleted.Raise(this, new PaymentOptionsEventArgs(e, TransactionId, Options.ToArray()));
        }
 
        private async static Task<object> ParseVariable(XmlElement VariableDefinition, Variables Variables)
        {
            object Value = null;
 
            foreach (XmlNode N2 in VariableDefinition.ChildNodes)
            {
                if (!(N2 is XmlElement E2))
                    continue;
 
                switch (E2.LocalName)
                {
                    case "null":
                        Value = null;
                        break;
 
                    case "dbl":
                        if (CommonTypes.TryParse(E2.InnerText, out double dbl))
                            Value = dbl;
                        break;
 
                    case "fl":
                        if (CommonTypes.TryParse(E2.InnerText, out float fl))
                            Value = fl;
                        break;
 
                    case "dec":
                        if (CommonTypes.TryParse(E2.InnerText, out decimal dec))
                            Value = dec;
                        break;
 
                    case "i8":
                        if (sbyte.TryParse(E2.InnerText, out sbyte i8))
                            Value = i8;
                        break;
 
                    case "i16":
                        if (short.TryParse(E2.InnerText, out short i16))
                            Value = i16;
                        break;
 
                    case "i32":
                        if (int.TryParse(E2.InnerText, out int i32))
                            Value = i32;
                        break;
 
                    case "i64":
                        if (long.TryParse(E2.InnerText, out long i64))
                            Value = i64;
                        break;
 
                    case "ui8":
                        if (byte.TryParse(E2.InnerText, out byte ui8))
                            Value = ui8;
                        break;
 
                    case "ui16":
                        if (ushort.TryParse(E2.InnerText, out ushort ui16))
                            Value = ui16;
                        break;
 
                    case "ui32":
                        if (uint.TryParse(E2.InnerText, out uint ui32))
                            Value = ui32;
                        break;
 
                    case "ui64":
                        if (ulong.TryParse(E2.InnerText, out ulong ui64))
                            Value = ui64;
                        break;
 
                    case "b":
                        if (CommonTypes.TryParse(E2.InnerText, out bool b))
                            Value = b;
                        break;
 
                    case "dt":
                        if (XML.TryParse(E2.InnerText, out DateTime TP))
                            Value = TP;
                        break;
 
                    case "dto":
                        if (XML.TryParse(E2.InnerText, out DateTimeOffset TPO))
                            Value = TPO;
                        break;
 
                    case "ts":
                        if (TimeSpan.TryParse(E2.InnerText, out TimeSpan TS))
                            Value = TS;
                        break;
 
                    case "d":
                        if (Duration.TryParse(E2.InnerText, out Duration D))
                            Value = D;
                        break;
 
                    case "s":
                        Value = E2.InnerText;
                        break;
 
                    case "exp":
                        try
                        {
                            Expression Exp = new Expression(E2.InnerText);
                            Value = await Exp.EvaluateAsync(Variables);
                        }
                        catch (Exception)
                        {
                            Value = E2.InnerText;
                        }
                        break;
                }
            }
 
            return Value;
        }
 
        public event EventHandlerAsync<PaymentOptionsEventArgs> BuyEDalerOptionsCompleted;
 
        private Task BuyEDalerOptionsErrorEventHandler(object Sender, MessageEventArgs e)
        {
            string TransactionId = XML.Attribute(e.Content, "tid");
            string Error = e.Content.InnerText;
 
            return this.BuyEDalerOptionsError.Raise(this, new PaymentErrorEventArgs(e, TransactionId, Error));
        }
 
        public event EventHandlerAsync<PaymentErrorEventArgs> BuyEDalerOptionsError;
 
        #endregion
 
        #region Initiation of getting Payment options for selling eDaler using smart contracts
 
        public Task InitiateGetOptionsSellEDaler(string ServiceId, string ServiceProvider,
            EventHandlerAsync<TransactionIdEventArgs> Callback, object State)
        {
            return this.InitiateGetOptionsSellEDaler(this.componentAddress, ServiceId, ServiceProvider, Callback, State);
        }
 
        public Task InitiateGetOptionsSellEDaler(string ComponentAddress, string ServiceId, string ServiceProvider,
            EventHandlerAsync<TransactionIdEventArgs> Callback, object State)
        {
            return this.InitiateGetOptionsSellEDaler(ComponentAddress, ServiceId, ServiceProvider, null, null, null, null, Callback, State);
        }
 
        public Task InitiateGetOptionsSellEDaler(string ServiceId, string ServiceProvider,
            string TransactionId, string SuccessUrl, string FailureUrl, string CancelUrl, EventHandlerAsync<TransactionIdEventArgs> Callback, object State)
        {
            return this.InitiateGetOptionsSellEDaler(this.componentAddress, ServiceId, ServiceProvider, TransactionId, SuccessUrl, FailureUrl, CancelUrl, Callback, State);
        }
 
        public Task InitiateGetOptionsSellEDaler(string ComponentAddress, string ServiceId, string ServiceProvider,
            string TransactionId, string SuccessUrl, string FailureUrl, string CancelUrl, EventHandlerAsync<TransactionIdEventArgs> Callback, object State)
        {
            if (!string.IsNullOrEmpty(SuccessUrl))
                SuccessUrl = SuccessUrl.Replace("{TID}", TransactionId);
 
            if (!string.IsNullOrEmpty(FailureUrl))
                FailureUrl = FailureUrl.Replace("{TID}", TransactionId);
 
            if (!string.IsNullOrEmpty(CancelUrl))
                CancelUrl = CancelUrl.Replace("{TID}", TransactionId);
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<initiateGetOptionsSellEDaler xmlns='");
            Xml.Append(NamespaceEDaler);
            Xml.Append("' serviceId='");
            Xml.Append(XML.Encode(ServiceId));
            Xml.Append("' serviceProvider='");
            Xml.Append(XML.Encode(ServiceProvider));
 
            if (!string.IsNullOrEmpty(TransactionId))
            {
                Xml.Append("' tid='");
                Xml.Append(XML.Encode(TransactionId));
            }
 
            if (!string.IsNullOrEmpty(SuccessUrl))
            {
                Xml.Append("' successUrl='");
                Xml.Append(XML.Encode(SuccessUrl));
            }
 
            if (!string.IsNullOrEmpty(FailureUrl))
            {
                Xml.Append("' failureUrl='");
                Xml.Append(XML.Encode(FailureUrl));
            }
 
            if (!string.IsNullOrEmpty(CancelUrl))
            {
                Xml.Append("' cancelUrl='");
                Xml.Append(XML.Encode(CancelUrl));
            }
 
            Xml.Append("'/>");
 
            return this.client.SendIqSet(ComponentAddress, Xml.ToString(), (Sender, e) =>
            {
                TransactionId = null;
                XmlElement E;
 
                if (e.Ok &&
                    !((E = e.FirstElement) is null) &&
                    E.LocalName == "transaction" &&
                    E.NamespaceURI == NamespaceEDaler)
                {
                    TransactionId = XML.Attribute(E, "tid");
                }
                else
                    e.Ok = false;
 
                return Callback.Raise(this, new TransactionIdEventArgs(e, TransactionId));
 
            }, State);
        }
 
        public Task<string> InitiateGetOptionsSellEDalerAsync(string ServiceId, string ServiceProvider)
        {
            return this.InitiateGetOptionsSellEDalerAsync(this.componentAddress, ServiceId, ServiceProvider, null, null, null, null);
        }
 
        public Task<string> InitiateGetOptionsSellEDalerAsync(string ServiceId, string ServiceProvider,
            string TransactionId, string SuccessUrl, string FailureUrl, string CancelUrl)
        {
            return this.InitiateGetOptionsSellEDalerAsync(this.componentAddress, ServiceId, ServiceProvider, TransactionId, SuccessUrl, FailureUrl, CancelUrl);
        }
 
        public async Task<string> InitiateGetOptionsSellEDalerAsync(string ComponentAddress, string ServiceId, string ServiceProvider,
            string TransactionId, string SuccessUrl, string FailureUrl, string CancelUrl)
        {
            TaskCompletionSource<string> Result = new TaskCompletionSource<string>();
 
            await this.InitiateGetOptionsSellEDaler(ComponentAddress, ServiceId, ServiceProvider, TransactionId, SuccessUrl, FailureUrl, CancelUrl,
                (Sender, e) =>
                {
                    if (e.Ok)
                        Result.TrySetResult(e.TransactionId);
                    else
                        Result.TrySetException(e.StanzaError ?? new Exception("Unable to initiate payment process."));
 
                    return Task.CompletedTask;
                }, null);
 
            return await Result.Task;
        }
 
        private Task SellEDalerOptionsClientUrlEventHandler(object Sender, MessageEventArgs e)
        {
            string TransactionId = XML.Attribute(e.Content, "tid");
            string Url = XML.Attribute(e.Content, "url");
 
            return this.SellEDalerOptionsClientUrlReceived.Raise(this, new SellEDalerClientUrlEventArgs(e, TransactionId, Url));
        }
 
        public event EventHandlerAsync<SellEDalerClientUrlEventArgs> SellEDalerOptionsClientUrlReceived;
 
        private async Task SellEDalerOptionsCompletedEventHandler(object Sender, MessageEventArgs e)
        {
            string TransactionId = XML.Attribute(e.Content, "tid");
            List<Dictionary<CaseInsensitiveString, object>> Options = new List<Dictionary<CaseInsensitiveString, object>>();
 
            foreach (XmlNode N in e.Content.ChildNodes)
            {
                if (N is XmlElement E && E.LocalName == "option" && E.NamespaceURI == NamespaceEDaler)
                {
                    Dictionary<CaseInsensitiveString, object> Option = new Dictionary<CaseInsensitiveString, object>();
                    Variables Variables = new Variables();
 
                    foreach (XmlNode N2 in E.ChildNodes)
                    {
                        if (N2 is XmlElement E2 && E2.LocalName == "variable" && E2.NamespaceURI == NamespaceEDaler)
                        {
                            string Name = XML.Attribute(E2, "name");
                            object Value = await ParseVariable(E2, Variables);
 
                            Option[Name] = Value;
                        }
                    }
 
                    Options.Add(Option);
                }
            }
 
            await this.SellEDalerOptionsCompleted.Raise(this, new PaymentOptionsEventArgs(e, TransactionId, Options.ToArray()));
        }
 
        public event EventHandlerAsync<PaymentOptionsEventArgs> SellEDalerOptionsCompleted;
 
        private Task SellEDalerOptionsErrorEventHandler(object Sender, MessageEventArgs e)
        {
            string TransactionId = XML.Attribute(e.Content, "tid");
            string Error = e.Content.InnerText;
 
            return this.SellEDalerOptionsError.Raise(this, new PaymentErrorEventArgs(e, TransactionId, Error));
        }
 
        public event EventHandlerAsync<PaymentErrorEventArgs> SellEDalerOptionsError;
 
        #endregion
 
        #region Initiation of buying eDaler using non-contract based services
 
        public Task InitiateBuyEDaler(string ServiceId, string ServiceProvider,
            decimal Amount, string Currency, EventHandlerAsync<TransactionIdEventArgs> Callback, object State)
        {
            return this.InitiateBuyEDaler(this.componentAddress, ServiceId, ServiceProvider, Amount, Currency, Callback, State);
        }
 
        public Task InitiateBuyEDaler(string ComponentAddress, string ServiceId, string ServiceProvider,
            decimal Amount, string Currency, EventHandlerAsync<TransactionIdEventArgs> Callback, object State)
        {
            return this.InitiateBuyEDaler(ComponentAddress, ServiceId, ServiceProvider, Amount, Currency, null, null, null, null, Callback, State);
        }
 
        public Task InitiateBuyEDaler(string ServiceId, string ServiceProvider,
            decimal Amount, string Currency, string TransactionId, string SuccessUrl, string FailureUrl, string CancelUrl, EventHandlerAsync<TransactionIdEventArgs> Callback, object State)
        {
            return this.InitiateBuyEDaler(this.componentAddress, ServiceId, ServiceProvider, Amount, Currency, TransactionId, SuccessUrl, FailureUrl, CancelUrl, Callback, State);
        }
 
        public Task InitiateBuyEDaler(string ComponentAddress, string ServiceId, string ServiceProvider,
            decimal Amount, string Currency, string TransactionId, string SuccessUrl, string FailureUrl, string CancelUrl, EventHandlerAsync<TransactionIdEventArgs> Callback, object State)
        {
            if (!string.IsNullOrEmpty(SuccessUrl))
                SuccessUrl = SuccessUrl.Replace("{TID}", TransactionId);
 
            if (!string.IsNullOrEmpty(FailureUrl))
                FailureUrl = FailureUrl.Replace("{TID}", TransactionId);
 
            if (!string.IsNullOrEmpty(CancelUrl))
                CancelUrl = CancelUrl.Replace("{TID}", TransactionId);
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<initiateBuyEDaler xmlns='");
            Xml.Append(NamespaceEDaler);
            Xml.Append("' serviceId='");
            Xml.Append(XML.Encode(ServiceId));
            Xml.Append("' serviceProvider='");
            Xml.Append(XML.Encode(ServiceProvider));
            Xml.Append("' amount='");
            Xml.Append(CommonTypes.Encode(Amount));
            Xml.Append("' currency='");
            Xml.Append(XML.Encode(Currency));
 
            if (!string.IsNullOrEmpty(TransactionId))
            {
                Xml.Append("' tid='");
                Xml.Append(XML.Encode(TransactionId));
            }
 
            if (!string.IsNullOrEmpty(SuccessUrl))
            {
                Xml.Append("' successUrl='");
                Xml.Append(XML.Encode(SuccessUrl));
            }
 
            if (!string.IsNullOrEmpty(FailureUrl))
            {
                Xml.Append("' failureUrl='");
                Xml.Append(XML.Encode(FailureUrl));
            }
 
            if (!string.IsNullOrEmpty(CancelUrl))
            {
                Xml.Append("' cancelUrl='");
                Xml.Append(XML.Encode(CancelUrl));
            }
 
            Xml.Append("'/>");
 
            return this.client.SendIqSet(ComponentAddress, Xml.ToString(), (Sender, e) =>
            {
                TransactionId = null;
                XmlElement E;
 
                if (e.Ok &&
                    !((E = e.FirstElement) is null) &&
                    E.LocalName == "transaction" &&
                    E.NamespaceURI == NamespaceEDaler)
                {
                    TransactionId = XML.Attribute(E, "tid");
                }
                else
                    e.Ok = false;
 
                return Callback.Raise(this, new TransactionIdEventArgs(e, TransactionId));
 
            }, State);
        }
 
        public Task<string> InitiateBuyEDalerAsync(string ServiceId, string ServiceProvider, decimal Amount, string Currency)
        {
            return this.InitiateBuyEDalerAsync(this.componentAddress, ServiceId, ServiceProvider, Amount, Currency);
        }
 
        public Task<string> InitiateBuyEDalerAsync(string ComponentAddress, string ServiceId, string ServiceProvider,
            decimal Amount, string Currency)
        {
            return this.InitiateBuyEDalerAsync(ComponentAddress, ServiceId, ServiceProvider, Amount, Currency, null, null, null, null);
        }
 
        public Task<string> InitiateBuyEDalerAsync(string ServiceId, string ServiceProvider,
            decimal Amount, string Currency, string TransactionId, string SuccessUrl, string FailureUrl, string CancelUrl)
        {
            return this.InitiateBuyEDalerAsync(this.componentAddress, ServiceId, ServiceProvider, Amount, Currency, TransactionId, SuccessUrl, FailureUrl, CancelUrl);
        }
 
        public async Task<string> InitiateBuyEDalerAsync(string ComponentAddress, string ServiceId, string ServiceProvider,
            decimal Amount, string Currency, string TransactionId, string SuccessUrl, string FailureUrl, string CancelUrl)
        {
            TaskCompletionSource<string> Result = new TaskCompletionSource<string>();
 
            await this.InitiateBuyEDaler(ComponentAddress, ServiceId, ServiceProvider, Amount, Currency, TransactionId, SuccessUrl, FailureUrl, CancelUrl,
                (Sender, e) =>
                {
                    if (e.Ok)
                        Result.TrySetResult(e.TransactionId);
                    else
                        Result.TrySetException(e.StanzaError ?? new Exception("Unable to initiate payment process."));
 
                    return Task.CompletedTask;
                }, null);
 
            return await Result.Task;
        }
 
        private Task BuyEDalerClientUrlEventHandler(object Sender, MessageEventArgs e)
        {
            string TransactionId = XML.Attribute(e.Content, "tid");
            string Url = XML.Attribute(e.Content, "url");
 
            return this.BuyEDalerClientUrlReceived.Raise(this, new BuyEDalerClientUrlEventArgs(e, TransactionId, Url));
        }
 
        public event EventHandlerAsync<BuyEDalerClientUrlEventArgs> BuyEDalerClientUrlReceived;
 
        private Task BuyEDalerCompletedEventHandler(object Sender, MessageEventArgs e)
        {
            string TransactionId = XML.Attribute(e.Content, "tid");
            string Currency = XML.Attribute(e.Content, "currency");
            decimal Amount = XML.Attribute(e.Content, "amount", 0M);
 
            return this.BuyEDalerCompleted.Raise(this, new PaymentCompletedEventArgs(e, TransactionId, Amount, Currency));
        }
 
        public event EventHandlerAsync<PaymentCompletedEventArgs> BuyEDalerCompleted;
 
        private Task BuyEDalerErrorEventHandler(object Sender, MessageEventArgs e)
        {
            string TransactionId = XML.Attribute(e.Content, "tid");
            string Error = e.Content.InnerText;
 
            return this.BuyEDalerError.Raise(this, new PaymentErrorEventArgs(e, TransactionId, Error));
        }
 
        public event EventHandlerAsync<PaymentErrorEventArgs> BuyEDalerError;
 
        #endregion
 
        #region Initiation of selling eDaler using non-contract based services
 
        public Task InitiateSellEDaler(string ServiceId, string ServiceProvider,
            decimal Amount, string Currency, EventHandlerAsync<TransactionIdEventArgs> Callback, object State)
        {
            return this.InitiateSellEDaler(this.componentAddress, ServiceId, ServiceProvider, Amount, Currency, Callback, State);
        }
 
        public Task InitiateSellEDaler(string ComponentAddress, string ServiceId, string ServiceProvider,
            decimal Amount, string Currency, EventHandlerAsync<TransactionIdEventArgs> Callback, object State)
        {
            return this.InitiateSellEDaler(ComponentAddress, ServiceId, ServiceProvider, Amount, Currency, null, null, null, null, Callback, State);
        }
 
        public Task InitiateSellEDaler(string ServiceId, string ServiceProvider,
            decimal Amount, string Currency, string TransactionId, string SuccessUrl, string FailureUrl, string CancelUrl,
            EventHandlerAsync<TransactionIdEventArgs> Callback, object State)
        {
            return this.InitiateSellEDaler(this.componentAddress, ServiceId, ServiceProvider, Amount, Currency, TransactionId, SuccessUrl, FailureUrl, CancelUrl, Callback, State);
        }
 
        public Task InitiateSellEDaler(string ComponentAddress, string ServiceId, string ServiceProvider,
            decimal Amount, string Currency, string TransactionId, string SuccessUrl, string FailureUrl, string CancelUrl,
            EventHandlerAsync<TransactionIdEventArgs> Callback, object State)
        {
            if (!string.IsNullOrEmpty(SuccessUrl))
                SuccessUrl = SuccessUrl.Replace("{TID}", TransactionId);
 
            if (!string.IsNullOrEmpty(FailureUrl))
                FailureUrl = FailureUrl.Replace("{TID}", TransactionId);
 
            if (!string.IsNullOrEmpty(CancelUrl))
                CancelUrl = CancelUrl.Replace("{TID}", TransactionId);
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<initiateSellEDaler xmlns='");
            Xml.Append(NamespaceEDaler);
            Xml.Append("' serviceId='");
            Xml.Append(XML.Encode(ServiceId));
            Xml.Append("' serviceProvider='");
            Xml.Append(XML.Encode(ServiceProvider));
            Xml.Append("' amount='");
            Xml.Append(CommonTypes.Encode(Amount));
            Xml.Append("' currency='");
            Xml.Append(XML.Encode(Currency));
 
            if (!string.IsNullOrEmpty(TransactionId))
            {
                Xml.Append("' tid='");
                Xml.Append(XML.Encode(TransactionId));
            }
 
            if (!string.IsNullOrEmpty(SuccessUrl))
            {
                Xml.Append("' successUrl='");
                Xml.Append(XML.Encode(SuccessUrl));
            }
 
            if (!string.IsNullOrEmpty(FailureUrl))
            {
                Xml.Append("' failureUrl='");
                Xml.Append(XML.Encode(FailureUrl));
            }
 
            if (!string.IsNullOrEmpty(CancelUrl))
            {
                Xml.Append("' cancelUrl='");
                Xml.Append(XML.Encode(CancelUrl));
            }
 
            Xml.Append("'/>");
 
            return this.client.SendIqSet(ComponentAddress, Xml.ToString(), (Sender, e) =>
            {
                TransactionId = null;
                XmlElement E;
 
                if (e.Ok &&
                    !((E = e.FirstElement) is null) &&
                    E.LocalName == "transaction" &&
                    E.NamespaceURI == NamespaceEDaler)
                {
                    TransactionId = XML.Attribute(E, "tid");
                }
                else
                    e.Ok = false;
 
                return Callback.Raise(this, new TransactionIdEventArgs(e, TransactionId));
 
            }, State);
        }
 
        public Task<string> InitiateSellEDalerAsync(string ServiceId, string ServiceProvider, decimal Amount, string Currency)
        {
            return this.InitiateSellEDalerAsync(this.componentAddress, ServiceId, ServiceProvider, Amount, Currency);
        }
 
        public Task<string> InitiateSellEDalerAsync(string ComponentAddress, string ServiceId, string ServiceProvider,
            decimal Amount, string Currency)
        {
            return this.InitiateSellEDalerAsync(ComponentAddress, ServiceId, ServiceProvider, Amount, Currency, null, null, null, null);
        }
 
        public Task<string> InitiateSellEDalerAsync(string ServiceId, string ServiceProvider,
            decimal Amount, string Currency, string TransactionId, string SuccessUrl, string FailureUrl, string CancelUrl)
        {
            return this.InitiateSellEDalerAsync(this.componentAddress, ServiceId, ServiceProvider, Amount, Currency, TransactionId, SuccessUrl, FailureUrl, CancelUrl);
        }
 
        public async Task<string> InitiateSellEDalerAsync(string ComponentAddress, string ServiceId, string ServiceProvider,
            decimal Amount, string Currency, string TransactionId, string SuccessUrl, string FailureUrl, string CancelUrl)
        {
            TaskCompletionSource<string> Result = new TaskCompletionSource<string>();
 
            await this.InitiateSellEDaler(ComponentAddress, ServiceId, ServiceProvider, Amount, Currency, TransactionId, SuccessUrl, FailureUrl, CancelUrl,
                (Sender, e) =>
                {
                    if (e.Ok)
                        Result.TrySetResult(e.TransactionId);
                    else
                        Result.TrySetException(e.StanzaError ?? new Exception("Unable to initiate payment process."));
 
                    return Task.CompletedTask;
                }, null);
 
            return await Result.Task;
        }
 
        private Task SellEDalerClientUrlEventHandler(object Sender, MessageEventArgs e)
        {
            string TransactionId = XML.Attribute(e.Content, "tid");
            string Url = XML.Attribute(e.Content, "url");
 
            return this.SellEDalerClientUrlReceived.Raise(this, new SellEDalerClientUrlEventArgs(e, TransactionId, Url));
        }
 
        public event EventHandlerAsync<SellEDalerClientUrlEventArgs> SellEDalerClientUrlReceived;
 
        private Task SellEDalerCompletedEventHandler(object Sender, MessageEventArgs e)
        {
            string TransactionId = XML.Attribute(e.Content, "tid");
            string Currency = XML.Attribute(e.Content, "currency");
            decimal Amount = XML.Attribute(e.Content, "amount", 0M);
 
            return this.SellEDalerCompleted.Raise(this, new PaymentCompletedEventArgs(e, TransactionId, Amount, Currency));
        }
 
        public event EventHandlerAsync<PaymentCompletedEventArgs> SellEDalerCompleted;
 
        private Task SellEDalerErrorEventHandler(object Sender, MessageEventArgs e)
        {
            string TransactionId = XML.Attribute(e.Content, "tid");
            string Error = e.Content.InnerText;
 
            return this.SellEDalerError.Raise(this, new PaymentErrorEventArgs(e, TransactionId, Error));
        }
 
        public event EventHandlerAsync<PaymentErrorEventArgs> SellEDalerError;
 
        #endregion
 
    }
}