From 491f2edfe7350d6bbafc87c861ba54ad744cd7b1 Mon Sep 17 00:00:00 2001 From: orangeentropy Date: Thu, 28 Nov 2024 23:07:36 +0100 Subject: [PATCH] added Majestic Bank and bumped version numbers of relevant packages --- .../CurrencyMetadata.js | 10 + .../EventListeners.js | 2 +- .../EventListenersMajesticBank.js | 309 ++++++++++++++ .../UtilityFunctions.js | 67 ++- packages/mymonero-exchange-helper/index.js | 36 +- .../initialiseExchange.js | 80 +++- .../mymonero-exchange-helper/package.json | 8 +- .../mymonero-exchange-majesticbank/index.js | 382 ++++++++++++++++++ .../package.json | 35 ++ packages/mymonero-exchange/index.js | 52 ++- packages/mymonero-exchange/package.json | 5 +- packages/mymonero-page-templates/index.esm.js | 1 + packages/mymonero-page-templates/package.json | 9 +- .../ExchangeNavigationController.js | 2 + .../Elements/ChangenowFixedRateView.js | 13 +- .../Exchange/Elements/ExchangeLandingPage.js | 9 + .../Elements/MajesticBankFloatingRateView.js | 184 +++++++++ packages/mymonero-page-templates/src/index.js | 1 + packages/mymonero-web-components/package.json | 5 +- .../src/Assets/ProviderCardImages.js | 7 +- .../src/Components/Shared/ProviderCard.js | 18 +- 21 files changed, 1176 insertions(+), 59 deletions(-) create mode 100644 packages/mymonero-exchange-helper/EventListenersMajesticBank.js create mode 100644 packages/mymonero-exchange-majesticbank/index.js create mode 100644 packages/mymonero-exchange-majesticbank/package.json create mode 100644 packages/mymonero-page-templates/src/Exchange/Elements/MajesticBankFloatingRateView.js diff --git a/packages/mymonero-exchange-helper/CurrencyMetadata.js b/packages/mymonero-exchange-helper/CurrencyMetadata.js index dc44fb7c..8a683e68 100644 --- a/packages/mymonero-exchange-helper/CurrencyMetadata.js +++ b/packages/mymonero-exchange-helper/CurrencyMetadata.js @@ -39,6 +39,16 @@ currencyMetadata = { symbol: "DOT", precision: 16 }, + "FIRO": { + name: "Firo", + symbol: "FIRO", + precision: 8 + }, + "WOW": { + name: "Wownero", + symbol: "WOW", + precision: 12 + } } module.exports = currencyMetadata \ No newline at end of file diff --git a/packages/mymonero-exchange-helper/EventListeners.js b/packages/mymonero-exchange-helper/EventListeners.js index b7862495..8a1dfbbe 100644 --- a/packages/mymonero-exchange-helper/EventListeners.js +++ b/packages/mymonero-exchange-helper/EventListeners.js @@ -264,7 +264,7 @@ updateMinimumInputValue = function(event, exchangeElements) { // console.log("updateMinimum"); // console.log(event); // console.log(exchangeElements); - Utils.getMinimalExchangeAmount("XMR", exchangeElements.outCurrencyTickerCodeDiv.value).then(response => { + Utils.getMinimalExchangeAmount("mymonero", "XMR", exchangeElements.outCurrencyTickerCodeDiv.value).then(response => { //exchangeElements.minimumFeeText.innerText = response.minAmount + " XMR minimum (excluding tx fee)" // use this line when we switch to polling ChangeNow exchangeElements.minimumFeeText.innerText = response.data.in_min + " XMR minimum (excluding tx fee)" }).catch(error => { diff --git a/packages/mymonero-exchange-helper/EventListenersMajesticBank.js b/packages/mymonero-exchange-helper/EventListenersMajesticBank.js new file mode 100644 index 00000000..37548a9a --- /dev/null +++ b/packages/mymonero-exchange-helper/EventListenersMajesticBank.js @@ -0,0 +1,309 @@ +const Utils = require('./UtilityFunctions.js'); +const CurrencyMetadata = require("./CurrencyMetadata"); +const ExchangeLibrary = require('@mymonero/mymonero-exchange-majesticbank') +const handleOfferError = require('./ErrorHelper') +const exchangeFunctions = new ExchangeLibrary() +const validationMessages = document.getElementById('validation-messages'); +//const addressValidation = document.getElementById('address-messages'); +const serverValidation = document.getElementById('server-messages') +const orderBtn = document.getElementById("order-button"); +const loaderPage = document.getElementById('loader'); + +let exchangeXmrDiv = document.getElementById('exchange-xmr'); +let backBtn = document.getElementsByClassName('nav-button-left-container')[0]; +let inCurrencyInput = document.getElementById('inCurrencyValue'); +let outCurrencyInput = document.getElementById('outCurrencyValue'); +let currencyInputTimer; + +clearCurrencies = function() { + document.getElementById("inCurrencyValue").value = ""; + document.getElementById("outCurrencyValue").value = ""; +} + +outAddressInputListener = function(exchangeElements, currencyTickerCode, address) { + + return new Promise((resolve, reject) => { + exchangeElements.serverValidation.innerText = ""; + try { + exchangeElements.serverValidation.innerHTML = '' + if (exchangeElements.currencyInputTimer !== undefined) { + clearTimeout(exchangeElements.currencyInputTimer) + } + exchangeElements.getAddressValidationLoader.style.display = "block"; + exchangeElements.getAddressValidationLoaderText.style.display = "block"; + exchangeElements.validationMessages.innerHTML = '' + exchangeElements.serverValidation.innerHTML = '' + exchangeElements.addressInputTimer = setTimeout(() => { + Utils.validateOutAddress(currencyTickerCode, address).then(response => { + // successful response in following format: {"isActivated":null,"result":true,"message":null} + let element = document.createElement("div"); + element.classList.add('message-label'); + if (response.result == true) { + element.innerHTML = "✔ Validated address successfully"; + exchangeElements.getAddressValidationLoaderText.innerHTML = "
✔ Validated address successfully
"; + exchangeElements.getAddressValidationLoaderContainer.style.display = "none"; + resolve(); + } else if (response.result == false) { + // failed response in following format: {"isActivated":null,"result":false,"message":"Invalid checksum"} + element.innerText = "Your address is invalid"; + exchangeElements.getAddressValidationLoaderText.innerHTML = "✖ The address you've specified is not valid"; + exchangeElements.getAddressValidationLoaderContainer.style.display = "none"; + resolve(); + } else { + console.log(error); + element.innerText = "An unexpected error occurred: " + response.message.toString(); + exchangeElements.getAddressValidationLoaderContainer.style.display = "none"; + reject(error); + } + }).catch(error => { + // 4xx or 5xx errors of some sort + let errorStr = "An unexpected error has occurred: " + error.message; + if (typeof(error.response) !== "undefined") { + if (error.response.data.message !== null) { + errorStr += "
" + error.response.data.message; + } + } + exchangeElements.getAddressValidationLoaderText.innerHTML = errorStr; + exchangeElements.getAddressValidationLoaderContainer.style.display = "none"; + reject(error); + }) + }, 1500) + } catch (error) { + // console.log("outBalanceChecks error route"); + reject(error); + } + }) +} + +inCurrencyGetOfferMajesticBank = function(inCurrencyDiv, outCurrencyDiv, inAmount, exchangeElements) { + return new Promise((resolve, reject) => { + + exchangeFunctions.getOfferWithInAmount(inCurrencyDiv.value, outCurrencyDiv.value, inAmount) + .then((response) => { + resolve(response) + }).catch((error) => { + // console.log("Rejecting with error to bubble up to inCurrencyBalanceChecks") + reject(error); + }) + }) +} + +outCurrencyGetOfferMajesticBank = function(inCurrencyDiv, outCurrencyDiv, inAmount, exchangeElements) { + return new Promise((resolve, reject) => { + + exchangeFunctions.getOfferWithOutAmount(inCurrencyDiv.value, outCurrencyDiv.value, inAmount) + .then((response) => { + resolve(response) + }).catch((error) => { + // console.log("Rejecting with error to bubble up to outCurrencyBalanceChecks") + reject(error); + }) + }) +} + +walletSelectorClickListener = function(event, exchangeElements) { + let walletElement = document.getElementById('wallet-options'); + let selectedWallet = document.getElementById('selected-wallet'); + walletElement.classList.add('active'); + if (event.srcElement.parentElement.className.includes("optionCell")) { + let dataAttributes = event.srcElement.parentElement.dataset; + selectedWallet.dataset.walletlabel = dataAttributes.walletlabel; + selectedWallet.dataset.walletbalance = dataAttributes.walletbalance; + selectedWallet.dataset.swatch = dataAttributes.swatch; + selectedWallet.dataset.walletselected = true; + selectedWallet.dataset.walletoffset = dataAttributes.walletoffset; + selectedWallet.dataset.walletpublicaddress = dataAttributes.walletpublicaddress; + let walletLabel = document.getElementById('selected-wallet-label'); + let walletBalance = document.getElementById('selected-wallet-balance'); + let walletIcon = document.getElementById('selected-wallet-icon'); + walletElement.classList.remove('active'); + walletIcon.style.backgroundImage = `url('../../../assets/img/wallet-${dataAttributes.swatch}@3x.png'`; + walletLabel.innerText = dataAttributes.walletlabel; + walletBalance.innerText = dataAttributes.walletbalance + " XMR"; + let walletSelector = document.getElementById('wallet-selector'); + walletSelector.dataset.walletchosen = true; + clearCurrencies(); + } else { + // console.log("Didn't update wallet dataset"); + } + if (event.srcElement.parentElement.className.includes("selectionDisplayCellView")) { + walletElement.classList.add('active'); + } + if (event.srcElement == 'div.hoverable-cell.utility.selectionDisplayCellView') { + + } +} + +inBalanceChecks = function (exchangeElements, exchangeFunctions) { + return new Promise((resolve, reject) => { + try { + exchangeElements.serverValidation.innerHTML = '' + //let inAmountToReceive = exchangeElements.BTCToReceive + const inBalance = parseFloat(exchangeElements.inCurrencyValue.value) + const in_amount = inBalance.toFixed(12) + exchangeElements.outCurrencyValue.value = '' + if (exchangeElements.currencyInputTimer !== undefined) { + clearTimeout(exchangeElements.currencyInputTimer) + } + + exchangeElements.validationMessages.innerHTML = '' + exchangeElements.serverValidation.innerHTML = '' + exchangeElements.currencyInputTimer = setTimeout(() => { + let inCurrencyDiv = document.getElementById("inCurrencySelectList"); + let outCurrencyDiv = document.getElementById("outCurrencySelectList"); + let inCurrencyValue = document.getElementById("inCurrencyValue").value; + inCurrencyGetOfferMajesticBank(inCurrencyDiv, outCurrencyDiv, inCurrencyValue, exchangeElements).then((response) => { + // successfully retrieved an offer + exchangeElements.outCurrencyValue.value = response.out_amount; + // replace minAmount with estimated total + let txFee = parseFloat(exchangeElements.txFee.dataset.txFee) + let inAmount = parseFloat(response.in_amount) + let estimatedTotal = txFee + inAmount; + exchangeElements.minimumFeeText.innerText = `~ ${estimatedTotal} XMR EST. TOTAL`; + resolve(response); + }).catch((error) => { + + exchangeElements.minimumFeeText.innerText = `${exchangeElements.minimumFeeText.dataset.minimumAmount} XMR minimum (excluding tx fee)` + reject(error); + }) + }, 1500) + } catch (error) { + // console.log("InBalanceChecks error route"); + reject(error); + } + }) +} + +// This would have been through key screening and an offer would've come back +outBalanceChecks = function(exchangeElements) { + return new Promise((resolve, reject) => { + try { + exchangeElements.serverValidation.innerHTML = '' + //let inAmountToReceive = exchangeElements.BTCToReceive + const outBalance = parseFloat(exchangeElements.outCurrencyValue.value) + const out_amount = outBalance.toFixed(12) + exchangeElements.inCurrencyValue.value = '' + if (exchangeElements.currencyInputTimer !== undefined) { + clearTimeout(exchangeElements.currencyInputTimer) + } + + exchangeElements.validationMessages.innerHTML = '' + exchangeElements.serverValidation.innerHTML = '' + exchangeElements.currencyInputTimer = setTimeout(() => { + let inCurrencyDiv = document.getElementById("inCurrencySelectList"); + let outCurrencyDiv = document.getElementById("outCurrencySelectList"); + let outCurrencyValue = document.getElementById("outCurrencyValue").value; + outCurrencyGetOfferMajesticBank(inCurrencyDiv, outCurrencyDiv, outCurrencyValue, exchangeElements).then((response) => { + exchangeElements.inCurrencyValue.value = response.in_amount; + let txFee = parseFloat(exchangeElements.txFee.dataset.txFee) + let inAmount = parseFloat(response.in_amount) + let estimatedTotal = txFee + inAmount; + exchangeElements.minimumFeeText.innerText = `~ ${estimatedTotal} XMR EST. TOTAL`; + + resolve(response); + }).catch((error) => { + // console.log("outBalance promise rejection"); + exchangeElements.minimumFeeText.innerText = `${exchangeElements.minimumFeeText.dataset.minimumAmount} XMR minimum (excluding tx fee)` + reject(error); + }) + }, 1500) + } catch (error) { + // console.log("outBalanceChecks error route"); + reject(error); + } + }) +} + +backButtonClickListener = function() { + let backBtn = document.getElementsByClassName('nav-button-left-container')[0]; + let viewOrderBtn = document.getElementById('view-order'); + orderCreated = false; + document.getElementById("orderStatusPage").classList.add('active'); + backBtn.style.display = "none"; + let orderStatusDiv = document.getElementById("exchangePage"); + loaderPage.classList.remove('active'); + orderStatusDiv.classList.remove('active'); + exchangeXmrDiv.classList.remove('active'); + viewOrderBtn.style.display = "block"; +} + +function clearCurrencyInputValues() { + document.getElementById("inCurrencyValue").value = ""; + document.getElementById("outCurrencyValue").value = ""; +} + +orderButtonClickedListener = function(orderStarted, ExchangeFunctions) { + // 1. Do validation + if (validateOrder) { + // console.log("Order valid"); + } + // console.log(orderStarted); + // console.log(ExchangeFunctions); + +} + +validateOrder = function() { + let validationError = false; + // console.log(validationMessages); + if (orderStarted == true) { + + return false; + } + if (validationMessages.firstChild !== null) { + validationMessages.firstChild.style.color = "#ff0000"; + validationError = true; + return false; + } + if (addressValidation.firstChild !== null) { + addressValidation.firstChild.style.color = "#ff0000"; + validationError = true; + return false; + } + +} + +updateMinimumInputValue = function(event, exchangeElements) { + // console.log("updateMinimum"); + // console.log(event); + // console.log(exchangeElements); + Utils.getMinimalExchangeAmount("majesticbank", "XMR", exchangeElements.outCurrencyTickerCodeDiv.value).then(response => { + //exchangeElements.minimumFeeText.innerText = response.minAmount + " XMR minimum (excluding tx fee)" // use this line when we switch to polling ChangeNow + exchangeElements.minimumFeeText.innerText = response.data.in_min + " XMR minimum (excluding tx fee)" + }).catch(error => { + exchangeElements.minimumFeeText.innerText = "An error was encountered when fetching the minimum: " + error.message; + }) +} + +outCurrencySelectListChangeListener = function(event, exchangeElements) { + + updateMinimumInputValue(event, exchangeElements); + clearCurrencies(); + clearInterval(exchangeElements.currencyInputTimer); + clearInterval(exchangeElements.offerRetrievalIsSlowTimer); + exchangeElements.getOfferLoader.style.display = "none"; + // get elements that show the + // clear timers too... +} + +updateCurrencyLabels = function(event, exchangeElements) { + let coinTickerCode = event.srcElement.value; + let coinName = CurrencyMetadata[coinTickerCode].name.toUpperCase(); + document.getElementById("outCurrencyTickerCode").innerText = coinTickerCode; + document.getElementById("orderStatusPageCurrencyTicker").innerText = coinName; + document.getElementById("outCurrencyCoinName").innerText = coinName; + document.getElementById("outAddress").placeholder = `Destination ${coinTickerCode} Address`; + clearCurrencyInputValues(); +} + +module.exports = { + outAddressInputListener, + //inCurrencyInputKeydownListener, + walletSelectorClickListener, + inBalanceChecks, + orderButtonClickedListener, + updateCurrencyLabels, + validateOrder, + outBalanceChecks, + inCurrencyGetOffer, + outCurrencySelectListChangeListener +}; \ No newline at end of file diff --git a/packages/mymonero-exchange-helper/UtilityFunctions.js b/packages/mymonero-exchange-helper/UtilityFunctions.js index ff947ff6..39b3f12d 100644 --- a/packages/mymonero-exchange-helper/UtilityFunctions.js +++ b/packages/mymonero-exchange-helper/UtilityFunctions.js @@ -1,19 +1,35 @@ const axios = require('axios'); -function getMinimalExchangeAmount(fromCurrency, toCurrency) { +function getMinimalExchangeAmount(exchange_name, fromCurrency, toCurrency) { + + if(exchange_name === "majesticbank") { + const ExchangeFunctionsMajesticBank = require("@mymonero/mymonero-exchange-majesticbank") + this.exchangeFunctions = new ExchangeFunctionsMajesticBank() + + return new Promise((resolve, reject) => { + this.exchangeFunctions.getRatesAndLimits(fromCurrency, toCurrency) + .then((response) => { + // emulating the response from ChangeNow + resolve({"data": {"in_min": response.data["limits"][fromCurrency].min}}) + }).catch((error) => { + reject(error) + }) + }) + } + let self = this; return new Promise((resolve, reject) => { this.apiUrl = "https://api.mymonero.com:443/cx"; let data = { - "in_currency": "XMR", - "out_currency": "BTC" + "in_currency": fromCurrency, + "out_currency": toCurrency } let endpoint = `${this.apiUrl}/get_info`; axios.post(endpoint, data) .then((response) => { self.currentRates = response.data; - self.in_currency = "XMR"; - self.out_currency = "BTC"; + self.in_currency = fromCurrency; + self.out_currency = toCurrency; self.currentRates.minimum_xmr = self.currentRates.in_min; self.currentRates.maximum_xmr = self.currentRates.in_max; resolve(response); @@ -53,6 +69,46 @@ function getMinimalExchangeAmount(fromCurrency, toCurrency) { // } function validateOutAddress(currencyTickerCode, address) { + + // This is the type of response ChangeNow provides + // For simplicity, we will use this response even when checks are done locally + const successfulResponse = { + "isActivated": null, + "result": true, + "message": "Valid address. (Local checks passed)." + } + + const failedResponse = { + "isActivated": null, + "result": false, + "message": "Invalid address. (Failed local checks)." + } + + // We use regex to validate the address locally for currencies unsupported by ChangeNow + if(currencyTickerCode === "WOW") { + return new Promise((resolve, reject) => { + // Wownero addresses are 97 characters long + // start with W followed by 96 base58 characters + regex = /^W[1-9A-HJ-NP-Za-km-z]{96}$/ + if(regex.test(address)){ + resolve(successfulResponse) + } + reject(failedResponse) + }) + } + else if (currencyTickerCode === "FIRO"){ + return new Promise((resolve, reject) => { + // Firo addresses either: + // start with a followed by 33 base58 characters (transparent address) + // or start with firos followed by 94 base58 characters (shielded address) + regex = /^(a[1-9A-HJ-NP-Za-km-z]{33}|firos[1-9A-HJ-NP-Za-km-z]{94})$/ + if(regex.test(address)){ + resolve(successfulResponse) + } + reject(failedResponse) + }) + } + return new Promise((resolve, reject) => { this.apiUrl = "https://api.changenow.io/v2/"; var axios = require('axios'); @@ -126,6 +182,7 @@ function sendFunds (wallet, xmr_amount, xmr_send_address, sweep_wallet, validati // end of functions to check Bitcoin address function renderOrderStatus (order) { + // TODO - MajesticBank - ensure order statuses match this schema /* "btc_amount", diff --git a/packages/mymonero-exchange-helper/index.js b/packages/mymonero-exchange-helper/index.js index c8ea5024..0d63d22f 100644 --- a/packages/mymonero-exchange-helper/index.js +++ b/packages/mymonero-exchange-helper/index.js @@ -1,30 +1,49 @@ const HtmlHelper = require("./HtmlHelper"); const WalletHelper = require("./WalletHelper") const html = require("./HtmlHelper") -const EventListeners = require("./EventListeners") const TimerHelper = require('./TimerHelper'); const CurrencyMetadata = require('./CurrencyMetadata') const monero_amount_format_utils = require('@mymonero/mymonero-money-format') const JSBigInt = require('@mymonero/mymonero-bigint') const ErrorHelper = require("./ErrorHelper") const InitialiseExchange = require("./initialiseExchange") -const ExchangeFunctions = require("@mymonero/mymonero-exchange") -const exchangeFunctions = new ExchangeFunctions(); class ExchangeHelper { // We declare these in this module so that we don't tightly couple currencies to the REST API module - constructor() { + constructor(exchange_name="mymonero") { // Assignment to `this` variable is so that we can invoke these functions using an instance of this class in a public fashion - this.supportedOutCurrencies = ["BTC", "ETH", "LTC"] - this.supportedInCurrencies = ["XMR"]; + if (exchange_name === "mymonero") { + this.exchange_name = "mymonero"; + this.supportedOutCurrencies = ["BTC", "ETH", "LTC"] + this.supportedInCurrencies = ["XMR"]; + + // very very ugly but solves the problem of global variables overriding each other + const ExchangeFunctions = require("@mymonero/mymonero-exchange") + this.exchangeFunctions = new ExchangeFunctions() + + const EventListeners = require("./EventListeners") + this.eventListeners = EventListeners; + console.log("ExchangeHelper: Using MyMonero exchange functions") + } + else if (exchange_name === "majesticbank") { + this.exchange_name = "majesticbank"; + this.supportedOutCurrencies = ["BTC", "LTC", "WOW", "BCH", "FIRO"] + this.supportedInCurrencies = ["XMR"]; + + const ExchangeFunctionsMajesticBank = require("@mymonero/mymonero-exchange-majesticbank") + this.exchangeFunctions = new ExchangeFunctionsMajesticBank() + + const EventListenersMajesticBank = require("./EventListenersMajesticBank") + this.eventListeners = EventListenersMajesticBank + console.log("ExchangeHelper: Using MajesticBank exchange functions") + } this.baseForm = ""; // Fetch form we'll insert into the content view's innerHTML - + this.htmlHelper = new HtmlHelper(); this.baseForm = this.htmlHelper.getBaseForm(); - this.eventListeners = EventListeners; this.timerHelper = TimerHelper; this.currencyMetadata = CurrencyMetadata; this.errorHelper = ErrorHelper; @@ -34,7 +53,6 @@ class ExchangeHelper { this.renderWalletSelector = this.renderWalletSelector; this.initialiseExchangeHelper = InitialiseExchange; this.doInit = this.doInit; - this.exchangeFunctions = exchangeFunctions; this.handleSendFundsResponseCallback = this.handleSendFundsResponseCallback; this.sendFundsValidationStatusCallback = this.sendFundsValidationStatusCallback; diff --git a/packages/mymonero-exchange-helper/initialiseExchange.js b/packages/mymonero-exchange-helper/initialiseExchange.js index d11c40dc..15868b88 100644 --- a/packages/mymonero-exchange-helper/initialiseExchange.js +++ b/packages/mymonero-exchange-helper/initialiseExchange.js @@ -267,7 +267,7 @@ function initialiseExchangeHelper(context, exchangeHelper) { } // Gets the initial minimum value - Utils.getMinimalExchangeAmount("XMR", "BTC").then(response => { + Utils.getMinimalExchangeAmount(exchangeHelper.exchange_name, "XMR", "BTC").then(response => { // let minimumAmount = parseFloat(response.minAmount); let minimumAmount = parseFloat(response.data.in_min); exchangeElements.minimumFeeText.innerText = `${minimumAmount} XMR minimum (excluding tx fee)`; @@ -466,14 +466,23 @@ function initialiseExchangeHelper(context, exchangeHelper) { // We attempt to retrieve enabled currency pairs from the server exchangeHelper.exchangeFunctions.getCurrencyPairs().then((response) => { - - response = {"out_currencies":[ - {"name":"Bitcoin","symbol":"BTC"}, - {"name":"Ether","symbol":"ETH"}, - {"name":"Litecoin","symbol":"LTC"}, - {"name":"Bitcoin Cash","symbol":"BCH"}, - {"name":"Polkadot","symbol":"DOT"} - ]} + + if(exchangeHelper.exchangeFunctions.apiUrl.includes("majesticbank")){ + // Majestic Bank supports different currencies than the other exchanges + // This isn't the ideal way of detecting the exchange + // For Majestic Bank we use the API to get the available currencies + } + else{ + // For all other exchanges we use the default currencies + response = {"out_currencies":[ + {"name":"Bitcoin","symbol":"BTC"}, + {"name":"Ether","symbol":"ETH"}, + {"name":"Litecoin","symbol":"LTC"}, + {"name":"Bitcoin Cash","symbol":"BCH"}, + {"name":"Polkadot","symbol":"DOT"} + ]} + } + let outCurrencySelectList = document.getElementById('outCurrencySelectList') let length = outCurrencySelectList.length; for (let i = length - 1; i >= 0; i--) { @@ -602,6 +611,11 @@ function initialiseExchangeHelper(context, exchangeHelper) { let e = document.getElementById('orderStatusPage'); e = document.getElementById('orderStatusPage'); // backBtn.innerHTML = `
`; + + // Added a semaphore to prevent multiple order status checks from being fired simultaneously + // This is especially important for Majestic Bank servers as they are quite happy to send 429s (Too Many Requests) + let orderStatusCheckSemaphore = false + exchangeElements.orderTimer = setInterval(() => { //exchangeElements.orderStatusPage.classList.add('active') exchangeElements.exchangePageDiv.classList.add('active') @@ -623,14 +637,17 @@ function initialiseExchangeHelper(context, exchangeHelper) { const xmr_dest_address_elem = document.getElementById('in_address') xmr_dest_address_elem.value = response.receiving_subaddress } - - if (orderStatusResponse.status == 'PAID' - || orderStatusResponse.status == 'TIMED_OUT' - || orderStatusResponse.status == 'DONE' - || orderStatusResponse.status == 'FLAGGED_DESTINATION_ADDRESS' - || orderStatusResponse.status == 'PAYMENT_FAILED' - || orderStatusResponse.status == 'REJECTED' - || orderStatusResponse.status == 'EXPIRED') { + + if (orderStatusResponse.status == 'PAID' + || orderStatusResponse.status == 'TIMED_OUT' + || orderStatusResponse.status == 'DONE' + || orderStatusResponse.status == 'FLAGGED_DESTINATION_ADDRESS' + || orderStatusResponse.status == 'PAYMENT_FAILED' + || orderStatusResponse.status == 'REJECTED' + || orderStatusResponse.status == 'EXPIRED' + || orderStatusResponse.status == 'Completed' //used by MajesticBank + || orderStatusResponse.status == 'Not found' //used by MajesticBank + ) { clearInterval(exchangeElements.orderTimer) document.getElementById("exchange-xmr").classList.remove("active"); } @@ -642,15 +659,24 @@ function initialiseExchangeHelper(context, exchangeHelper) { document.getElementById("exchange-xmr").classList.remove("active"); } } - if ((orderStatusResponse.orderTick % 10) == 0) { + if ((orderStatusResponse.orderTick % 10) === 0 && !orderStatusCheckSemaphore) { + + // Set the semaphore to true to prevent multiple order status checks from being fired simultaneously + orderStatusCheckSemaphore = true + + exchangeHelper.exchangeFunctions.getOrderStatus().then(function (response) { + + // Set the semaphore to false to allow the next order status check to be fired + orderStatusCheckSemaphore = false + let elemArr = document.getElementsByClassName('provider-name') if (firstTick == true || elemArr.length > 0) { exchangeHelper.renderOrderStatus(response) elemArr[0].innerHTML = response.provider_name elemArr[1].innerHTML = response.provider_name elemArr[2].innerHTML = response.provider_name - + elemArr = document.getElementsByClassName('outCurrencyTickerCode'); elemArr[0].innerHTML = out_currency; elemArr[1].innerHTML = out_currency; @@ -660,6 +686,22 @@ function initialiseExchangeHelper(context, exchangeHelper) { orderTick++ response.orderTick = orderTick orderStatusResponse = response + }).catch((error) => { + // Failed to get order status + + // Set the semaphore to false to allow the next order status check to be fired + orderStatusCheckSemaphore = false + + // Axios errors have a status property, so we can check for a 429 (Too Many Requests) error + // If we get a 429, we don't want to throw an error, we just want to wait for the next interval + // Majestic Bank servers are quite happy to send 429s + if (error.hasOwnProperty('status') && error.status == 429) { + return + } + else{ + // We shouldn't get other errors that 429s, so if we do something is wrong and we pass throw the error + throw error + } }) } }, 1000) diff --git a/packages/mymonero-exchange-helper/package.json b/packages/mymonero-exchange-helper/package.json index 8c2a89bd..c4673d5d 100644 --- a/packages/mymonero-exchange-helper/package.json +++ b/packages/mymonero-exchange-helper/package.json @@ -1,6 +1,6 @@ { "name": "@mymonero/mymonero-exchange-helper", - "version": "3.0.3", + "version": "3.0.4", "description": "A library of helper functions used for rendering the in-app exchange", "main": "index.js", "scripts": { @@ -8,7 +8,8 @@ }, "dependencies": { "@mymonero/mymonero-bigint": "^3.0.3", - "@mymonero/mymonero-exchange": "^3.0.3", + "@mymonero/mymonero-exchange": "^3.0.4", + "@mymonero/mymonero-exchange-majesticbank": "^3.0.4", "@mymonero/mymonero-money-format": "^3.0.3", "axios": "^0.21.3" }, @@ -42,6 +43,5 @@ "license": "BSD-3-Clause", "publishConfig": { "access": "public" - }, - "gitHead": "8b2fb278e4a5aa84e577c9985fbca332fca4f1b0" + } } diff --git a/packages/mymonero-exchange-majesticbank/index.js b/packages/mymonero-exchange-majesticbank/index.js new file mode 100644 index 00000000..f39261bd --- /dev/null +++ b/packages/mymonero-exchange-majesticbank/index.js @@ -0,0 +1,382 @@ +const axios = require("axios"); +const FormData = require("form-data"); +//const fetch = require("fetch"); +class ExchangeFunctionsMajesticBank { + + constructor() { + this.apiUrl = "https://majesticbank.sc/api"; + this.apiVersion = "v1"; + this.referral_code = "mgzySX"; + + this.offer = {} + this.offer_type = ""; + this.order = {}; + this.orderRefreshTimer = {}; + this.currentRates = {}; + this.orderStatus = {}; + this.exchangeConfiguration = {}; + } + + getApiPath() { + return `${this.apiUrl}/${this.apiVersion}` + } + + initialiseExchangeConfiguration() { + + // not needed for MB + return new Promise((resolve, reject) => { + resolve(); + }); + } + + getOfferWithOutAmount(in_currency, out_currency, out_amount) { + + // Response + // from_currency -> string + // from_amount -> number + // receive_currency -> string + // receive_amount -> number + + const self = this; + let endpoint = `${self.getApiPath()}/calculate`; + let data = new FormData(); + data.append('from_currency', in_currency); + data.append('receive_currency', out_currency); + data.append('receive_amount', out_amount); + self.offer_type = "out_amount"; + + return new Promise((resolve, reject) => { + axios.post(endpoint, data) + .then(function (response) { + console.log('response from MajesticBank getOfferWithOutAmount', response); + + // changenow has offer_id but majesticbank does not + self.offer = { + "in_amount": parseFloat(response.data.from_amount), + "out_amount": parseFloat(response.data.receive_amount), + "expires_at": new Date(new Date().getTime() + 10 * 60000), + } + + resolve(self.offer); + }) + .catch(function (error) { + console.log(error); + reject(error); + }); + }); + } + + getOfferWithInAmount(in_currency, out_currency, in_amount) { + + // Response + // from_currency -> string + // from_amount -> number + // receive_currency -> string + // receive_amount -> number + + const self = this; + let endpoint = `${self.getApiPath()}/calculate`; + let data = new FormData(); + data.append('from_currency', in_currency); + data.append('receive_currency', out_currency); + data.append('from_amount', in_amount); + self.offer_type = "in_amount"; + + return new Promise((resolve, reject) => { + axios.post(endpoint, data) + .then(function (response) { + console.log('response from MajesticBank getOfferWithInAmount', response); + + // changenow has offer_id but majesticbank does not + self.offer = { + "in_amount": response.data.from_amount, + "out_amount": response.data.receive_amount, + "expires_at": new Date(new Date().getTime() + 600 * 60000), + } + + resolve(self.offer); + }) + .catch(function (error) { + console.log(error); + reject(error); + }); + }); + } + + getOffer(in_currency, out_currency, amount, offerType) { + + return new Promise((resolve, reject) => { + if (offerType == "in") { + this.getOfferWithInAmount(in_currency, out_currency, amount).then(response => { + resolve(response); + }).catch(error => { + reject(error); + }); + } else if (offerType == "out") { + this.getOfferWithOutAmount(in_currency, out_currency, amount).then(response => { + resolve(response); + }).catch(error => { + reject(error); + }); + } else { + // TODO (from original ChangeNow code): Handle error a bit more elegantly + let error = new Error("Please ensure you have specified an amount to exchange"); + console.log(error); + reject(error); + } + }) + } + + + + getOrderStatus() { + + const self = this; + + let endpoint = `${self.getApiPath()}/track`; + return new Promise((resolve, reject) => { + let data = new FormData(); + data.append('trx', self.order.order_id); + + axios.post(endpoint, data) + .then(function (response) { + + // Response: + // trx -> string + // status -> string + // from_currency -> string + // from_amount -> number + // receive_currency -> string + // receive_amount -> number + // address -> string + // received -> number + // confirmed -> number + + let resolve_data = { + "order_id": response.data.trx, + "expires_at": self.order.expires_at, + "in_address": response.data.address, + "in_amount": parseFloat(response.data.from_amount), + "out_currency": response.data.receive_currency, + "out_amount": parseFloat(response.data.receive_amount), + "status": response.data.status, + "in_amount_remaining": parseFloat(response.data.from_amount) - parseFloat(response.data.received), + "out_address": self.order.out_address, + "provider_name": "MajesticBank", + "provider_url": "https://majesticbank.sc/track", + "provider_order_id": response.data.trx, + } + + self.orderStatus = resolve_data + resolve(self.orderStatus); + }) + .catch(function (error) { + console.log(error); + reject(error); + }); + }); + } + + getOrderExpiry() { + return this.orderStatus.expires_at; + } + + getTimeRemaining() { + return this.orderStatus.seconds_till_timeout; + } + + createOrder(out_address, refund_address, in_currency = "XMR", out_currency = "BTC") { + + let self = this; + let endpoint = `${self.getApiPath()}/exchange`; + + let data = new FormData() + data.append('from_currency', in_currency); + data.append('receive_currency', out_currency); + + data.append('receive_address', out_address); + data.append('referral_code', self.referral_code); + + if (self.offer_type === "in_amount") { + data.append('from_amount', self.offer.in_amount); + } + else if (self.offer_type === "out_amount") { + return this.pay(out_address, refund_address, in_currency, out_currency); + } + + return new Promise((resolve, reject) => { + try { + axios.post(endpoint, data) + .then(function (response) { + self.order = response; + // Response: + // trx -> string + // from_currency -> string + // from_amount -> number + // receive_currency -> string + // receive_amount -> number + // address -> string + // expiration -> number (minutes) - 600 + + + self.order = { + "order_id": response.data.trx, + "in_currency": response.data.from_currency, + "in_amount": parseFloat(response.data.from_amount), + "out_currency": response.data.receive_currency, + "out_amount": parseFloat(response.data.receive_amount), + "out_address": response.data.address, + "expires_at": new Date(new Date().getTime() + response.data.expiration * 60000), + "seconds_till_timeout": parseInt(response.data.expiration) * 60 + } + + // expires_at + // seconds_till_timeout + resolve(response); + }) + .catch(function (error) { + reject(error); + }); + } catch (error) { + reject(error); + } + }); + } + + pay(out_address, refund_address, in_currency = "XMR", out_currency = "BTC"){ + // creates a fixed / pay order + // only called from createOrder + let self = this; + let endpoint = `${self.getApiPath()}/pay`; + + let data = new FormData() + data.append('from_currency', in_currency); + data.append('receive_currency', out_currency); + + data.append('receive_address', out_address); + data.append('referral_code', self.referral_code); + + if (self.offer_type === "out_amount") { + data.append('receive_amount', self.offer.out_amount); + } + else if (self.offer_type === "in_amount") { + // This should never happen, but in case it does we can handle it + return this.createOrder(out_address, refund_address, in_currency, out_currency); + } + + return new Promise((resolve, reject) => { + try { + axios.post(endpoint, data) + .then(function (response) { + self.order = response; + // Response: (identical to createOrder, except for expiration time) + // trx -> string + // from_currency -> string + // from_amount -> number + // receive_currency -> string + // receive_amount -> number + // address -> string + // expiration -> number (minutes) - 10 + + + self.order = { + "order_id": response.data.trx, + "in_currency": response.data.from_currency, + "in_amount": parseFloat(response.data.from_amount), + "out_currency": response.data.receive_currency, + "out_amount": parseFloat(response.data.receive_amount), + "out_address": response.data.address, + "expires_at": new Date(new Date().getTime() + response.data.expiration * 60000), + "seconds_till_timeout": parseInt(response.data.expiration) * 60 + } + + // expires_at + // seconds_till_timeout + resolve(response); + }) + .catch(function (error) { + reject(error); + }); + } catch (error) { + reject(error); + } + }); + } + + + getRatesAndLimits(in_currency, out_currency) { + + let self = this; + return new Promise((resolve, reject) => { + axios.get(`${this.getApiPath()}/rates`) + .then(response => { + // sample data + // { "BTC-USD": 95873.25, "BTC-XMR": 587.27871363, "BTC-LTC": 1000.43427567, "BTC-WOW": 907408.37140125, "BTC-FIRO": 66530.88804593, "BTC-BCH": 188.6681292, "XMR-USD": 159.985, "XMR-BTC": 0.00163534, "XMR-LTC": 1.66943832, "XMR-WOW": 1514.20472654, "XMR-FIRO": 111.02100037, "XMR-BCH": 0.31483308, "LTC-USD": 93.915, "LTC-BTC": 0.00095998, "LTC-XMR": 0.57528331, "LTC-WOW": 888.87418754, "LTC-FIRO": 65.17196768, "LTC-BCH": 0.18481451, "WOW-USD": 0.103543, "WOW-BTC": 1.06e-6, "WOW-XMR": 0.00063426, "WOW-LTC": 0.00108047, "WOW-FIRO": 0.07185328, "WOW-BCH": 0.00020376, "FIRO-USD": 1.412213, "FIRO-BTC": 1.444e-5, "FIRO-XMR": 0.00865062, "FIRO-LTC": 0.0147364, "FIRO-WOW": 13.36612557, "FIRO-BCH": 0.00277908, "BCH-USD": 497.995, "BCH-BTC": 0.00509042, "BCH-XMR": 3.05050536, "BCH-LTC": 5.19656178, "BCH-WOW": 4713.35676965, "BCH-FIRO": 345.58179255, "limits": { "BTC": { "min": 0.00104304, "max": 2.60760953 }, "XMR": { "min": 0.07500703, "max": 1562.64649811 }, "LTC": { "min": 0.12777512, "max": 2661.98157909 }, "WOW": { "min": 115.89387984, "max": 2414455.82994505 }, "FIRO": { "min": 8.49730175, "max": 177027.11984665 }, "BCH": { "min": 0.02409663, "max": 502.01307242 } } } + self.in_currency = in_currency; + self.out_currency = out_currency; + self.currentRates = response.data; + // access the limits in the data + self.currentRates.minimum_xmr = response.data["limits"][in_currency].min; + self.currentRates.maximum_xmr = response.data["limits"][in_currency].max; + + resolve(response); + }) + .catch(error => { + reject(error); + }); + }); + } + + getCurrencyPairs(in_currency = "XMR") { + + let self = this; + return new Promise((resolve, reject) => { + + let currencies = [ + { + "name": "Bitcoin", + "symbol": "BTC", + "precision": 8 + }, + { + "name": "Monero", + "symbol": "XMR", + "precision": 12 + }, + { + "name": "Litecoin", + "symbol": "LTC", + "precision": 8 + }, + { + "name": "Bitcoin Cash", + "symbol": "BCH", + "precision": 8 + }, + { + "name": "Wownero", + "symbol": "WOW", + "precision": 12 + }, + { + "name": "Firo", + "symbol": "FIRO", + "precision": 8 + } + ] + + // throw out the in_currency + currencies = currencies.filter(currency => currency.symbol !== in_currency); + + self.enabledCurrencies = currencies; + let out_currencies = { + "out_currencies": currencies + } + resolve(out_currencies); + + }); + } + +} + +module.exports = ExchangeFunctionsMajesticBank; diff --git a/packages/mymonero-exchange-majesticbank/package.json b/packages/mymonero-exchange-majesticbank/package.json new file mode 100644 index 00000000..99db333a --- /dev/null +++ b/packages/mymonero-exchange-majesticbank/package.json @@ -0,0 +1,35 @@ +{ + "name": "@mymonero/mymonero-exchange-majesticbank", + "version": "3.0.4", + "description": "This module is used by the desktop and web versions of the MyMonero wallet to facilitate the exchange of XMR into other cryptocurrencies. It can be used to facilitate transactions where a user converts one cryptocurrency into another.", + "main": "index.js", + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "keywords": [ + "cryptocurrency-conversion", + "cryptocurrency-exchange", + "mymonero", + "xmrtobtc", + "monerotobitcoin", + "monero-to-bitcoin" + ], + "author": "MyMonero", + "repository": { + "type": "git", + "url": "git+https://github.com/mymonero/mymonero-utils.git" + }, + "homepage": "https://mymonero.com", + "bugs": { + "url": "https://github.com/mymonero/mymonero-utils/issues", + "email": "info@mymonero.com" + }, + "license": "BSD-3-Clause", + "dependencies": { + "axios": "^1.6.8", + "process": "^0.11.10" + }, + "publishConfig": { + "access": "public" + } +} diff --git a/packages/mymonero-exchange/index.js b/packages/mymonero-exchange/index.js index a4708c1e..7840f46c 100644 --- a/packages/mymonero-exchange/index.js +++ b/packages/mymonero-exchange/index.js @@ -79,9 +79,18 @@ class ExchangeFunctions { self.offer_type = "out_amount"; let endpoint = `${self.apiUrl}/get_offer`; return new Promise((resolve, reject) => { + + //sample response + // { + // "offer_id": "d604-2-101", + // "expires_at": "2024-11-24T20:37:46.328Z", + // "in_amount": "60.75456303", + // "out_amount": "0.1" + // } + axios.post(endpoint, data) .then(function (response) { - console.log('outAmount', response); + console.log('response from MyMonero for getOfferWithOutAmount', response); self.offer = response.data; self.offer.out_amount = out_amount; resolve(self.offer); @@ -104,9 +113,18 @@ class ExchangeFunctions { self.offer_type = "in_amount"; let endpoint = `${self.apiUrl}/get_offer`; return new Promise((resolve, reject) => { + + //sample response + // { + // "offer_id": "d604-1-lZDUeP+JpbSTxZ8gOCHLwR7WL8ETr1Jbkji7NqVlFVXusF4oQ+e/3uL8/2jL2dfoCqjTf2X9NIrBg4QrrB2XHh9XmlLEL6i1IR9B72qDnZ0Dzamr9AlMJDcm4cxfxDA8BzYN8x2n7BjT+dZgUJszBVivKZwpHMaPWAVUso11QIda/0I/o2NsjjRGoolJ/46tVncCOJGi6PhO9H4qPwSHkg==", + // "expires_at": "2024-11-24T20:35:43.541Z", + // "in_amount": "1", + // "out_amount": "0.00162612" + // } + axios.post(endpoint, data) .then(function (response) { - console.log('resp from getOfferwithtinamount', response); + console.log('response from MyMonero for getOfferwithtinamount', response); self.offer = response.data; resolve(self.offer); }) @@ -167,6 +185,24 @@ class ExchangeFunctions { let endpoint = `${self.apiUrl}/order_status`; return new Promise((resolve, reject) => { + + // sample response + // { + // "order_id": "d604-662e2c5f78f8b2", + // "expires_at": "2024-11-24T21:52:15.460Z", + // "in_address": "8B96tmezmMhWVwUdaYe87oY9y7SP3YXND3HmGYZKACyYFJYh9wG4LaVKCzWrpQmUvHYQZxmsUERJaidhtRSRFKMmUQVQ7zm", + // "in_currency": "XMR", + // "in_amount": "0.5", + // "out_currency": "BTC", + // "out_amount": "0.00079765", + // "status": "NEW", + // "in_amount_remaining": "0.5", + // "out_address": "bc1pp83964w2q3nun33gd79gg54n3zfudmfzn6ar4spk8g9dc86mtv3s6me7lq", + // "provider_name": "ChangeNOW", + // "provider_url": "https://support.changenow.io", + // "provider_order_id": "662e2c5f78f8b2" + // } + let data = { "order_id": self.order.data.order_id } @@ -209,6 +245,18 @@ class ExchangeFunctions { delete data.out_amount; } return new Promise((resolve, reject) => { + + // sample response + // { + // "order_id": "d604-662e2c5f78f8b2", + // "expires_at": "2024-11-24T21:52:15.460Z", + // "in_address": "8B96tmezmMhWVwUdaYe87oY9y7SP3YXND3HmGYZKACyYFJYh9wG4LaVKCzWrpQmUvHYQZxmsUERJaidhtRSRFKMmUQVQ7zm", + // "in_currency": "XMR", + // "in_amount": "0.1", + // "out_currency": "BTC", + // "out_amount": "0.00079765" + // } + try { axios.post(endpoint, data) .then(function (response) { diff --git a/packages/mymonero-exchange/package.json b/packages/mymonero-exchange/package.json index d2a8cf24..ee2a3beb 100644 --- a/packages/mymonero-exchange/package.json +++ b/packages/mymonero-exchange/package.json @@ -1,6 +1,6 @@ { "name": "@mymonero/mymonero-exchange", - "version": "3.0.3", + "version": "3.0.4", "description": "This module is used by the desktop and web versions of the MyMonero wallet to facilitate the exchange of XMR into other cryptocurrencies. It can be used to facilitate transactions where a user converts one cryptocurrency into another.", "main": "index.js", "scripts": { @@ -31,6 +31,5 @@ }, "publishConfig": { "access": "public" - }, - "gitHead": "8b2fb278e4a5aa84e577c9985fbca332fca4f1b0" + } } diff --git a/packages/mymonero-page-templates/index.esm.js b/packages/mymonero-page-templates/index.esm.js index f21f7956..23336ff4 100644 --- a/packages/mymonero-page-templates/index.esm.js +++ b/packages/mymonero-page-templates/index.esm.js @@ -2,6 +2,7 @@ require("@mymonero/mymonero-web-components"); /* Require various view elements */ +require("./src/Exchange/Elements/MajesticBankFloatingRateView"); require("./src/Exchange/Elements/ChangenowBuyWithFiatView"); require("./src/Exchange/Elements/ChangenowFixedRateView") require("./src/Exchange/Elements/ChangenowFloatingRateView"); diff --git a/packages/mymonero-page-templates/package.json b/packages/mymonero-page-templates/package.json index b54c0816..68112e2a 100644 --- a/packages/mymonero-page-templates/package.json +++ b/packages/mymonero-page-templates/package.json @@ -1,6 +1,6 @@ { "name": "@mymonero/mymonero-page-templates", - "version": "3.0.3", + "version": "3.0.4", "description": "This npm package contains a number of Lit element templates that MyMonero uses for various page layouts.", "main": "./lib/index", "exports": { @@ -30,8 +30,8 @@ "license": "BSD-3-Clause", "dependencies": { "@mymonero/changenow-exchange-integration": "^3.0.3", - "@mymonero/mymonero-exchange-helper": "^3.0.3", - "@mymonero/mymonero-web-components": "^3.0.3", + "@mymonero/mymonero-exchange-helper": "^3.0.4", + "@mymonero/mymonero-web-components": "^3.0.4", "lit": "*", "lit-html": "^1.4.1", "sweetalert2": "^11.3.0" @@ -44,6 +44,5 @@ }, "publishConfig": { "access": "public" - }, - "gitHead": "8b2fb278e4a5aa84e577c9985fbca332fca4f1b0" + } } diff --git a/packages/mymonero-page-templates/src/Exchange/Controllers/ExchangeNavigationController.js b/packages/mymonero-page-templates/src/Exchange/Controllers/ExchangeNavigationController.js index 9424e0f4..a1f8bd99 100644 --- a/packages/mymonero-page-templates/src/Exchange/Controllers/ExchangeNavigationController.js +++ b/packages/mymonero-page-templates/src/Exchange/Controllers/ExchangeNavigationController.js @@ -5,6 +5,7 @@ const ExchangeNavigationController = (superClass) => class extends superClass { /* class fields & methods to extend superClass with */ navigateToPage(destination) { let routeMap = { + "majesticbankFloatingRateView": "majesticbank-floating-rate-view", "changenowBuyWithFiatView": "changenow-buy-with-fiat-view", "changenowFixedRateView": "changenow-fixed-rate-view", "changenowFloatingRateView": "changenow-floating-rate-view", @@ -92,6 +93,7 @@ const ExchangeNavigationController = (superClass) => class extends superClass { selfNavigate(page) { let routeMap = { + "majesticbankFloatingRateView": "majesticbank-floating-rate-view", "changenowBuyWithFiatView": "changenow-buy-with-fiat-view", "changenowFixedRateView": "changenow-fixed-rate-view", "changenowFloatingRateView": "changenow-floating-rate-view" diff --git a/packages/mymonero-page-templates/src/Exchange/Elements/ChangenowFixedRateView.js b/packages/mymonero-page-templates/src/Exchange/Elements/ChangenowFixedRateView.js index b1939020..fbd1945d 100644 --- a/packages/mymonero-page-templates/src/Exchange/Elements/ChangenowFixedRateView.js +++ b/packages/mymonero-page-templates/src/Exchange/Elements/ChangenowFixedRateView.js @@ -12,8 +12,7 @@ const ExchangeUtils = require("../Utils/ExchangeUtilityFunctions") // const commonComponents_activityIndicators = require('../../MMAppUICommonComponents/activityIndicators.web') const JSBigInt = require('@mymonero/mymonero-bigint').BigInteger // important: grab defined export const monero_amount_format_utils = require('@mymonero/mymonero-money-format') -const ExchangeHelper = require("@mymonero/mymonero-exchange-helper") -let exchangeHelper = new ExchangeHelper(); +const ExchangeHelperMyMonero = require("@mymonero/mymonero-exchange-helper") // NB: because of legacy reasons, we don't want this to render inside a shadow dom. We override createRenderRoot to address this export class ChangenowFixedRateView extends ExchangeNavigationController(LitElement) { @@ -75,7 +74,7 @@ export class ChangenowFixedRateView extends ExchangeNavigationController(LitElem connectedCallback() { super.connectedCallback(); - exchangeHelper.doInit(this.context); + this.exchangeHelper.doInit(this.context); } sendFunds() { @@ -93,7 +92,7 @@ export class ChangenowFixedRateView extends ExchangeNavigationController(LitElem this.context.walletsListController.orderSent = false } - ExchangeUtils.default.sendFunds(this.context.walletsListController.records[selectorOffset], in_amount, send_address, sweep_wallet, exchangeHelper.sendFundsValidationStatusCallback, exchangeHelper.handleSendFundsResponseCallback, this.context) + ExchangeUtils.default.sendFunds(this.context.walletsListController.records[selectorOffset], in_amount, send_address, sweep_wallet, this.exchangeHelper.sendFundsValidationStatusCallback, this.exchangeHelper.handleSendFundsResponseCallback, this.context) } catch (error) { console.log(error) } @@ -101,7 +100,11 @@ export class ChangenowFixedRateView extends ExchangeNavigationController(LitElem constructor() { super(); + // Previously the exchangeHelper was initialized globally. This was causing some issues whenever this file was imported. + // To avoid those issues we are now initializing the exchangeHelper in the constructor. + // There seems to be no reason for the exchangeHelper to be global. this.clickHandler = this.clickHandler; + this.exchangeHelper = new ExchangeHelperMyMonero(); } clickHandler(event) { @@ -109,7 +112,7 @@ export class ChangenowFixedRateView extends ExchangeNavigationController(LitElem } render() { - let exchangeFormTemplate = exchangeHelper.htmlFormTemplate(); + let exchangeFormTemplate = this.exchangeHelper.htmlFormTemplate(); let exchangeFormHtml = exchangeFormTemplate.content.firstElementChild.cloneNode(true); return html` diff --git a/packages/mymonero-page-templates/src/Exchange/Elements/ExchangeLandingPage.js b/packages/mymonero-page-templates/src/Exchange/Elements/ExchangeLandingPage.js index cf097f2e..d5fdbfd1 100644 --- a/packages/mymonero-page-templates/src/Exchange/Elements/ExchangeLandingPage.js +++ b/packages/mymonero-page-templates/src/Exchange/Elements/ExchangeLandingPage.js @@ -36,6 +36,15 @@ export default class ExchangeLandingPage extends ExchangeNavigationController(Li this.clickHandler = this.clickHandler; this.context = {}; this.providerServices = [ + { + service_provider: "majesticbank", + title: "Exchange Monero for other cryptocurrencies (floating rate)", + description: ` + Use a floating rate when you want to take advantage of the best exchange rate. + This exchange provides the best privacy.`, + navigationType: "internalLink", + destination: "majesticbankFloatingRateView" + }, { service_provider: "changenow", title: "Exchange Monero for other cryptocurrencies (fixed rate)", diff --git a/packages/mymonero-page-templates/src/Exchange/Elements/MajesticBankFloatingRateView.js b/packages/mymonero-page-templates/src/Exchange/Elements/MajesticBankFloatingRateView.js new file mode 100644 index 00000000..046efbd7 --- /dev/null +++ b/packages/mymonero-page-templates/src/Exchange/Elements/MajesticBankFloatingRateView.js @@ -0,0 +1,184 @@ + + +import { html, css, LitElement } from 'lit'; +import ExchangeNavigationController from "../Controllers/ExchangeNavigationController"; + +// Legacy imports for fixed rate exchange +const Utils = require("../Utils/ExchangeUtilityFunctions") +const ExchangeUtils = require("../Utils/ExchangeUtilityFunctions") +// const ValidationLibrary = require('wallet-address-validator') +//const View = require('../../Views/View.web') +// const commonComponents_navigationBarButtons = require('../../MMAppUICommonComponents/navigationBarButtons.web') +// const commonComponents_activityIndicators = require('../../MMAppUICommonComponents/activityIndicators.web') +const JSBigInt = require('@mymonero/mymonero-bigint').BigInteger // important: grab defined export +const monero_amount_format_utils = require('@mymonero/mymonero-money-format') +const ExchangeHelperMajesticBank = require("@mymonero/mymonero-exchange-helper") + +// NB: because of legacy reasons, we don't want this to render inside a shadow dom. We override createRenderRoot to address this +export class MajesticBankFloatingRateView extends ExchangeNavigationController(LitElement) { + + static get styles() { + return css` + .submit-button-wrapper { + position: fixed; + top: -45px; + right: 16px; + width: 15%; + min-width: 41px; + height: 41px; + z-index: 12; + } + .submit-button { + z-index: 13; + position: fixed; + right: 16px; + font-weight: bold; + top: -40px; + z-index: 10000; + } + .submit-button, .confirmation-button { + cursor: default; + border-radius: 3px; + height: 24px; + font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell, "Open Sans", "Helvetica Neue", sans-serif; + text-align: center; + border: none; + text-decoration: none; + line-height: 24px; + box-sizing: border-box; + width: auto; + padding: 0px 8px; + background-color: rgb(0, 198, 255); + box-shadow: rgb(22 20 22) 0px 0.5px 1px 0px, rgb(255 255 255 / 20%) 0px 0.5px 0px 0px inset; + color: rgb(22, 20, 22); + -webkit-font-smoothing: subpixel-antialiased; + font-size: 12px; + font-weight: bold; + letter-spacing: 0.5px; + float: right; + margin-top: 5px; + -webkit-app-region: no-drag; + } + ` + } + + createRenderRoot() { + return this; + } + + static get properties() { + return { + context: Object, + } + } + + connectedCallback() { + super.connectedCallback(); + this.exchangeHelper.doInit(this.context); + } + + sendFunds() { + const in_amount = document.getElementById('in_amount_remaining').innerHTML + const send_address = document.getElementById('receiving_subaddress').innerHTML + const in_amount_str = '' + in_amount + + const selectedWallet = document.getElementById('selected-wallet') + const selectorOffset = selectedWallet.dataset.walletoffset + const sweep_wallet = false // TODO: Add sweeping functionality + try { + if (this.context.walletsListController.hasOwnProperty('orderSent')) { + console.log('Order already sent previously') + } else { + this.context.walletsListController.orderSent = false + } + + ExchangeUtils.default.sendFunds(this.context.walletsListController.records[selectorOffset], in_amount, send_address, sweep_wallet, this.exchangeHelper.sendFundsValidationStatusCallback, this.exchangeHelper.handleSendFundsResponseCallback, this.context) + } catch (error) { + console.log(error) + } + } + + constructor() { + super(); + this.clickHandler = this.clickHandler; + this.exchangeHelper = new ExchangeHelperMajesticBank("majesticbank"); + } + + clickHandler(event) { + console.log(event); + } + + render() { + let exchangeFormTemplate = this.exchangeHelper.htmlFormTemplate(); + let exchangeFormHtml = exchangeFormTemplate.content.firstElementChild.cloneNode(true); + + return html` +
+
 
+ ${exchangeFormHtml} +
+ +
+ +
+ + + `; + } + +} + +try { + customElements.define('majesticbank-floating-rate-view', MajesticBankFloatingRateView); +} catch (error) { + // already defined +} \ No newline at end of file diff --git a/packages/mymonero-page-templates/src/index.js b/packages/mymonero-page-templates/src/index.js index 21930bcf..9e78a735 100644 --- a/packages/mymonero-page-templates/src/index.js +++ b/packages/mymonero-page-templates/src/index.js @@ -4,6 +4,7 @@ //require("@mymonero/mymonero-web-components"); /* Require various view elements */ +require("./Exchange/Elements/MajesticBankFloatingRateView"); require("./Exchange/Elements/ChangenowBuyWithFiatView"); require("./Exchange/Elements/ChangenowFixedRateView") require("./Exchange/Elements/ChangenowFloatingRateView"); diff --git a/packages/mymonero-web-components/package.json b/packages/mymonero-web-components/package.json index 7c545044..9dcff99f 100644 --- a/packages/mymonero-web-components/package.json +++ b/packages/mymonero-web-components/package.json @@ -1,6 +1,6 @@ { "name": "@mymonero/mymonero-web-components", - "version": "3.0.3", + "version": "3.0.4", "description": "This npm package contains a number of Lit web components.", "main": "./lib/index", "exports": { @@ -42,6 +42,5 @@ "@babel/core": "^7.5.5", "@babel/plugin-transform-runtime": "^7.15.0", "@babel/preset-env": "^7.5.5" - }, - "gitHead": "8b2fb278e4a5aa84e577c9985fbca332fca4f1b0" + } } diff --git a/packages/mymonero-web-components/src/Assets/ProviderCardImages.js b/packages/mymonero-web-components/src/Assets/ProviderCardImages.js index 4a563824..2b7e4f5f 100644 --- a/packages/mymonero-web-components/src/Assets/ProviderCardImages.js +++ b/packages/mymonero-web-components/src/Assets/ProviderCardImages.js @@ -1,6 +1,11 @@ +let MajesticbankLogo = 'url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAA8UAAAG9CAYAAAA83NTpAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAABmJLR0QA/wD/AP+gvaeTAAAAB3RJTUUH5QsECjI4ugrv7gAAAAFvck5UAc+id5oAAH9PSURBVHja7d13nFTV+cfxz8zO7NI7WEAQVOwtYItmx4I1xtgwxopoxGiMvygr9hITA5nVGKMmYDRqbBF7otGIxl1rQOxgoQiooPS+ZWZnfn+cu7oguzsz9849d2a+79drRNi5955zd8p97jnneUBERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERESlcoHztNp9O2+yUiUpKSVTHbTZDi1NF5VACdga7On83/3sH5WbnziABpoMzZvsl5JID6Fn+uB+qAtcBqYJ3z73VAo+1OS2GJxGtsN0FEXAqF8hKetitiu+MiIiJiVWegG7AF0BfoA2zpPHoCvZxHb6ATJvhtDoKjfBv45qIJE/w2YILhBmAlsBxY6vy5GPgCWOT820Ln39diAm8RERFXFBSLiIgUv+6YgHcwsBWwPTAQ6O/8vZvz8Pu6oIxvR5ubDWpnm1WYUeUvgfnO4xPnz7nAEkzALCIikhEFxSIiIsWjAjPiOxQT+O4GDAG2xYz2drHdQA90dx5bAftu9LM1mJHlWcCnwAfADGAeZqRZRETkOxQUi4iIFKYwZlR1J0zwOwwTDG+NWfNbiro6j22AI5x/S2OmXX+KCZDfdh5zMNOwRUSkxCkoFhERKQwdge2AvYB9gO9hguBSDYAzFcJMHe8L7O/8Wwoz/fpD4E3n8QEaTRYRKUkKikVERIKpDNgRE8jtjwmGt0Xf3V4IY6ZfbwUc6fzbYkxg/ApQC7yHRpJFREqCvlhFRESCYzPMKPAIoBITFJfbblSJ6Acc4jzAZLyeCrwIvAzMtN1AERHJDwXFIiIidg3FBMFHYBJH9bXdIAFggPM4HlMq6l3gP8C/MWuSG2w3UEREvKGgWERExH87A0cBRwN7Y+r+SnBVYEbw9wGuBj7CBMj/BN4A1ttuoIiI5E5BsYiIiD+2wwTBx2MCYU2LLlw7Oo+LMFmtnwGexCTsarTdOBERyY6CYhERkfzpi5kW/RPgQKCz7QaJ54Y6j19hknM9CTwOvG+7YSIikhkFxSIiIt4KAQdgAuEfY9alSmnY3Xlcjslg/TDwL+Br2w0TEZHWKSgWERHxRl/gBOAMYD/bjRGryjHJ00YAC4GngPsw06tFRCRgwrYbICIiUuB2AW7GZCT+MwqIZUNbAj8HXgdeAk4DutlulIiIfEsjxSIiIrkZAfwM+BHQ0XZjLEk6jyYg5TxaCmFuwIeBMsx1R5ntRlsSAg5yHrOBe4D7gfm2GyYiUuoUFIuIiGSuDDgW+AUmcVaxWQ+sAZZg1sEuA5Y6/78UWOE8Z63zZ73zaODbADmNCQDh24C4HFPWqALo5Dw6O3/2BPq0ePTCTEXvB3R1HsVmW+A3mORc/wAmosRcIiLWKCgWERFpXwVwEnAhsJftxrhUjwlw52NGLD/DlBX6AliECYjXAwmLbSzDBMw9gM2dx0BgG2AQMBgzLbkPhT3y3Bs4HzgbeAy4Ffif7UaJiJQaBcUiIiKt6wicjKlHu7vtxmSpDvgSE/h+DHwEzMEkfvoCMyIcVE1O+9YAn2/i52FMwDwIEyzviimLtAsm23df2x3IUgVwCua19hRwG2b9sYiI+EBBsYiIyHd1wAQpFwG72W5MBlLAPGAmMB2T9GsWZhS43nbj8tTf5c7jHUwgCSZY3gwzorwn5kbGns7fu9tudAbCwHHO43ngFuA5240SESl2CopFRES+VQb8FLgYE0wFVRNmyvNbwBuYKbezCPborx9SmCngi4BXnX8LY0aUdwL2Br6PGVHe3HZj23G483geuAl4wXaDRESKlYJiERER42jgMmB/2w1pxSJgGvAiJuD7CDNFWtqWwoyYfwY84/zbZpjA+AdADNgDMx07iJqD46eB8ZibICIi4iEFxSIiUur2Aq7GlFYKkjQwA/gv8B9gKrDYdqOKxNfO40Xn7wMx9aVHAJWY9clBcwxwJKaM0wTgE9sNEhEpFgqKRUSkVA0AxmFqDVfYbowjjVkj+yzwb8za4GJcExw0C5zHPzClovbk2xHaPQnO9VIUOAuz5vgPwJ8wZbJERMSFkPtdfFc6nbbdLxGRkpSsitluQiGIYsrgjAO2sN0YxwzM9NinMeuEk7YbJIBZj7wHZmr9j4Bh5OnaKUefAr8GHrDdkCCIxGtsN0FEXAqF7HzEKigWESkiCorbdRgmiNjHdkMw5ZL+BTwCvAY02G6QtCmMmWp/gvMYYrtBLTwPXInJPF6yFBSLFD5bQXHYdsdFRER80A/4KyZ4sBkQN2CmRZ+OKRd0HqYerQLi4EthsnxfiplSfTLmpkYQkp0djkm+9jugp+3GiIgUGgXFIiJS7PbEJKs622Ib5mAyBw8HjsIkS1pm+8RIzlZj1h//CPgeZvbBp5bb1AGTPf014FjLbRERKSgKikVEpJjthhmZ3cnCsZsw2Y1PxaxFvRz40PYJEc99DFyLueFxMmY2gs014TsCTwB/A/rbPjkiIoVAQbGIiBSrrpgR2c18Pu5K4E5MDdwRwIPAKtsnQ/JuDWb0+Ajg+8AdwBKL7RmFGTU+1faJEREJOgXFIiJSrH4B7Orj8eYDN2BGhc8F3rB9AsSaacAFmKn7lwIfWWrHIMyNofsxJchERGQTFBSLiEgxKgdO8elYM4GLMMHwNcBc252XwPgSiAN7Y0Zubd0oORWTiOtE2ydERCSIglKMXkRExEsDgMF5PsbbmCmyDwPrst34/p+daeG0iFdOu/PebJ6+FrgXM2J7FHAhcKjPTR4ETAYmYta3r/D5+CIigaWRYhERKUblQDRP+56GGYX+PnAXOQTEUrKagH9i6mWPAJ6x0IYxQC1QaftkiIgEhUaKRUSkGH0NLAW29HCf04GbMaNtCdsdDKpRQ0f3x5Qo2h0Ye8+nd79su00B9aLziAFjgaN9PPYuwBTgOkypsJTtkyEiYpNGikVEpBitAN70aF8zgXOA/TGZpBUQb8KooaO7jRo6+jdN6aZZ7y9/b/QrX9UOW51Y/d9RQ0c/Pmro6G1tty/AajD1jg8BXvDxuFHgt8BTwEDbJ0FExCaNFIuISLH6M3C8i+2/AP4ATMKsCZVNGDV0dDnwszTp62avmtXn3WXvsC5pZpR/tmYuO/bY6bjde+/xw1FDR98JXHfPp3cvtd3mgHrJeRwLXAbs49Nxj8ZkaT8feNb2SRARsUEjxSIiUqymAI/msN1aYAImY/DNKCDepFFDR4dGDR19IjDjy3Vf3Pb0/Kf6vPb1q98ExACpdIoZKz7k8c8eLf945UcXpNKpWaOGjr7ECaRl057ErPcdA8zx6ZiDgKeBq4GQ7RMgIuI3BcUiIlLMLgLmZfH8ycB+mJG6RbYbH1Sjho7+AfD68oZlk5//4rltX/jyP6xoWN7q8+ub6nlz8Rs8Pf/JHgvWLqgGZowaOvo42/0IsEbMDIV9MbWvV/twzDLMWvBHgc1snwARET9p+rSIiBSzhcBPMKNvW7TxvA8wNYaftN3gIBs1dPSOwG/XJdceN33JdD5bM5c06Yy3X9m4kpcWTmHzTltsu3ffvR8fNXT0a5hkXF6t/y42SzGvy38A1wIjfTjm8cCOwJmYTOsiIkVPI8UiIlLspgIHAf/mu1l25wFXAAeggLhVo4aO3mLU0NF3NKYa35+2ZOpxj3/2GHPXzGk1IN6qy0B27bUbZaGyTf78q/WL+Of8p3nt61f3r0uuf33U0NEPjho6WsmeWjcDOAkTsM7w4Xg7YpYfnG674yIifsjLupF0OvO7xiIi4p1kVcx2E4JuL2A4UAF8hMlQvcrvRkTiNbbPQ6a6AJek0qmxH62c2eW95e/R2NTQ6pN7VfRm7757s3mnLWYCM9Yl1544fclboblr5ra6TTQcZeeeu7Bzz13qouHozZgSQQWzjtvCe647cDnwK0w97nz7LWatceAv7grofSUirQiF7KQ1UFAsIlJEFBQXhgK4eI8AZ6dJX/vZms+2mL7kLdYlW49TO0e6MKzPMAZ3G7IoROgpzMj7U5g6vDcuqV+879TFU1lSv7jVfXSMdOJ7vb/Htt23WxwidD1mTW3S9oloj8X33PeBmzDrjvPtEeBcLNxAykYBvK9EpB0KikVExDUFxYUh4BfvxwK/XbR+0U7TlkxlecOyVp8YDUfZtddu7Nxzl7qyUNl9wA5AyxfhIswoYx3wu7lr5g5sL8DeaLT5EuA52yekLZbfcxXApZglAB3yfKz/AacAc93uKF8C/r4SkQwoKBYREdcUFBeGgF687wtMWNGwovKtpdP4ct0XrT4xHAoztPv27NF7z1SHsg4PAwngVFpP4PkOZsrv8KZ002UzVnzY5YPl75NIJVo9xsAug/hen2H0KO/xHCY4nmn7BG1KQN5z+wF/xCwPyKf5mMD4ddsd3pSAvq9EJAu2gmJlnxYRESlt2wI3rkuuO/HdZe+EZq+a1WZG6RbB6hRM1u6zgB7tHGNPzIjvE2WhssN267X7Odt1227U28veDrd2vAVr5/PFus8Z2n37I/boveehHco63AtchUplbcobwMHA9Zi1xvm6qhwEPAuMQonpRKSIKPu0iIhIaeoD3NqYapzx9tLpIx//7NHQrFWfthoQ96rozREDjuTgLQ+Z2aO8x9XAlpgArEcWxzwOeBlY0THS6aD9Nzvg5R8NOobNO226WlYqneLjlR/x+GePls1Y8eHoVDr1KXAl0NH2yQugtZgR9eOAz/N4nO6YElHn2u6wiIhXNH1aRKSIBGQqp7TD8jTPjsDFqXRq7CerPu7x3rJ3qW+qb/XJnSNdGNZ3GIO7DlkUIvQXTIKnwz1ox1JM7d3FwO8WrJ2/7VtLprE6sbrVDbpFu7Fnn2EM7jp4AXAZ8DCWsyIH9D03CPgzcGSej3MVJjt1IGj6tEjh05piERFxLaAX6M22AnbHJGPqDtQDs4H3MeWRSoali/cwZtrr9fPWfDbg7aXT2wxAy8Pl7NJrV3buucv6slDZn4HOwDl4v/RqJjAO2D6VTl390cqZ3d9b9i6NqcZWN+jboR9799ubvh36vY0ZHX3ZxgmFQL/nIpibDleSv+nUAHFMsi/rFBSLFD6tKRYRkWL1feBC4DCg1yZ+Xo+pF/xnTOkX8d4RwO+/rvtq17eWvNVmaaSNkmjdB3wKXIyZbp0POwH/BJ4Lh8I/3rnnLmds023bUe8ueyf86apPSKVT39lgSf1inlnwL4Z0HfK9YX2H/7dzpMsTmMBstuXzHCRJTObvdzHvrb55Ok4V0BW4AEi53JeIiBUaKRYRKSIBG7XqCPwO+AVQluE2zzjPn2e78fnk44jWnkD1ysaVB7+9dDoL1s5v88ktkmj9B3gaOB8TtPolialP/ChwzcrGlQdOWzK1zUzYZaEyduq5M7v22q2xPFz+J+A3wErfGhys91xrdgLuBYbn8Rj3Aj/DZCK3QiPFIoVP06dFRMS1AF2gd8OM+uay9vQz4BjgQ9udyBcfLt4HAuPrkut/8u6yd8OzVn+6yRHXZhvVBr4J+BGmXrEtKzHB7QLgxi/XfbHttCVTWdm4stUNOpR1YI/eezK0+/Yrw6Hwb4A/AY2ZHMyNAL3n2tMDuA1TOitfHsJM0c/7ed8UBcUihU9BsYiIuBaQC/QyYDImC26u5gA/oEjL7+Tx4r0HcFUilbhwxooPy2es+LDNWsAmidZwBncdvChE6HfAYMw02HLb58gxG7gCGJhKp676dNUnPd5d9k6bicF6lPdgr75707/zgNmYKdVP5LOBAXnPZeM6zFrjfHkYOBMLgbGCYpHCpzXFIiJSLMbgLiAG2AYzYnmK7c4UiArgFyZw/LTHe8vfpS65vtUnt0iitbYsVHYr8BVwDflbN5yrbTEzDl4Oh8LH79BjxxOHdNvm3PeWvRv5aOXMTY5+r2xcyQtf/of+nftvO6zP8Md7VfR+GZOM623bnQmI6zA3nf4CdMrD/k/GrC0ehcWp1CIi2dBIsYhIEQnAqFUv4ANMDVu30kAMeMV2p7yW5YhWR0yiq7eBf2/0szAmCPndgrXzB05fOp1VbUwx3iiJ1j3As5jsxHvm0o958+Yxffp0pk6dysyZM1m4cCHLli1j3bp1pFIpotEoXbt2pV+/fgwcOJA99tiDvfbaiz333JOePXtme7gUZr3x/cBVqxOrj3hrybQ210mHCLFt9+34Xu/vpTtGOj2MKeO0IJe+tiYA77lcHYw5l1u43VEr7gHOxsfkWxopFil8mj4tIiKuBeAC/Wzgrx7u7z7MVMyiksXF+3HAHz5ft2BQvw6bJSrKKkYBDzo/OxioXlK/eM+3lkzj67qv29zRwC6DGNZnGN3LezyHyUY8ihxG9L/88ksef/xxHn/8caZNm8a6deuy7v+WW27JgQceyMknn8xhhx1GRUVFNpuvxKw3/gSY8NX6RTtNXTKV5Q3LWt0gGo6ya6/d2LnnLnVlobKbgfHA2qwbvgkBeM+5sTMmqdkOedr/HZjp+L5QUCxS+BQUi4iIawG4QH8c91OnW5oP7AasdrujIMng4n1P4OblDcsPnLrkf3y1fhE9yntw6IDD050jnW8A9l6dWH3E9CVvMX/tvDZ3tFESrauAYZgyOlmtG/7000+57bbbeOihh1i6dOk3/96pQ5gdtq5g+60r2KZ/BVv2jdC9SxmRshD1jSmWr2ri868TzFrQwMzP6vlsYSOpFmOHO+20E2PGjOGss86ia9eu2TRpNnA50C9N+vpPVn7cp731xp0jXdizz55s023bRSFCV2EyJje5+V0G4D3n1laYBFn752n/N2JmI+SdgmKRwqegWEREXLN8gR4FZgDbebjPJuB7wPs2O+a1DC7e57+1ZNrAmStnbLButnOkM5VbHMhna+bSWg3fb59rkmgN6TpkEaZebQj4NVlOl125ciXxeJzbb7+dVatWASYQHrFPF46NdWf/PToxaPNyKjqFIRyCTV0DhEKQTLN6dROfzG/gxWlrefLlVfzvw2/XPe+www5cffXVnHJK1svIX8YkjjqmMdV44XvL3i1vbb1xs41uFFwCPJfL7xGsv+e80h0zlfroPO3/IuDWfHdCQbFI4VNQLCIirlm+QO8DzAT6erzfEcCLNjvmtQwu3j94av6Tu6xoWJ71vjdKonULUAtMIId1w1OmTOGiiy5i5syZAPTtGWH0j3tx1tE92X6bDiYIbkyRaEpvMPq7KaEQhMMhIpEQREMk16d45d213DF5GY+9uIrmK4cTTjiBW265hQEDBmTT1BRmDetfgarVidXHtbfeGMyU8uF996JbtNtzmOB4ZrbnqEiCYjDJ2u4iPyWbUpi175Pz2QEFxSKFz1ZQHLbdcRERKRph8nOztRS/q1aVh6NZbRAOhdmhx44cP/jE1G69dr+7LFR2ECaL9/PkEBCPHz+eI488kpkzZxIKwXkn9mbqfdsx/uIt2X7rChrrUjSsayKRTBONhKjoFKaic9j82bHFo1OYis5llHcImxi6IUXD2ibSpDlon65Mrt6alyZuQ+X3OgPw2GOPccABB/DSSy9l1X1gNPAfYHq3aLcjDt7ykHeOGHAkvSp6t7rRgrXzeXLe40xd8r8j6pvq3wNuB/rl9TcbXA2Y9ft/ycO+w8DfgO/b7qSIyKZopFhEpIhYHrXqAHwMDPJwn2lgL2C6zY55LYMRrWde/PKFoz5f93lG+zNJtIbTvbz7c5gp0j/EZKzumG3bkskkF1xwAZMmTQJg6MAK/nRpfw6r7AaNKRoazXd8eTREqCJMYn0Tsz5v5L1P6/h4XgPzFjayYk0TyWSaDhVh+vWMsM2AcnbZpgO7bdeB/puVQxkkG9I0NaUJhaC8Y5hEQ4o/PLCU6yZ+RV1Dmg4dOjBp0iROP/30XE7xAsx6445p0jfMXjVri7eXvd1umarde+/Bjj12WhsOhccDNwN17Z6v4hkpbun3mHXnXluAySg/Lx+N1kixSOFTnWIRESl09cCneBsUL8bjEjoB1wW4ob6p/oj1bQRwzXp36MNeffZi805bzMAEMT2Ax8ixzE4ikeDMM8/koYceAuCYym5MunoAm/WL0ri2iTROMFwe4rP5DUx+YRWP/3cV731aR31j+zfE+/aIsP8enfnJYd354f7d6NqjjERdivp1KSJlIS792Wbss0snRl37OfMW1XPmmWdSX1/Pz372s2y7MhB4AHgzROjU7boPPWTrroMv/mD5+x1nrPiQpvR3c2s1phqZtmQqn6z8uMvwvnv9ZmCXQediSjg9DJTa3f5LMTcErvF4vwOBvwOHkcENBxERv2ikWESkiARg1KoKM8rklaeBH9vulNdaGdE6HPjL7NWztp62ZCoNTQ2tbr9REq2rMCP0NwH7umnXWWedxT333APAz47rxR2XDyAShvqGNOEwlHcq4/MvG7jlgSXc868VLF/1bXDZvUsZg7csZ9AWUXp2KyNaFqKuIc3iFUnmftnI/EWNJJLfXh/ssHUFvzq1L6OO7kl5RZiGerMouaJzGXPm1XPC2Pm8N6uOcDjM/fffz09/+tNcu5XGBLa3Ar9cl1x78vQlb4Xmrpnb5kabddyc4X2H07dDvzeBscBrm3peAN5z+XQF8Ns87Pcu4Byvd6qRYpHCp0RbIiLiWgAu0AcBHwBZ1dZpw/HAE7Y75bWNLt57A7esTaw57fWvX2fh+i9b3a48XM6uvXZjp547r3Xq7T6Iybx8Mi6/02+44QauucYMDJ57XC8mXrUVqaY0jYk00WiIsmiIe59azhW3f8XCJQkAunUu4+jKrhwb685eO3Vkiz5RKirCEA2Z1qTS0JhmbV2KuV828so763jsxVX8d/q3JYIr9+zMH8Zuyfd27UzjuibSKajoHObzhY0cdeFnfDinnk6dOvHiiy+y776uYv46zJToF4Ebl9Qv3nfq4qksqV/c5kZDug5hWN/hdI50eQIzgjq75c8D8J7Lt8sxZZXysd/xXu5QQbFI4VNQLCIirgXkAn08MM6D/bwCHAwkbXfIay0u3k9Jk75l5ooZfd9Z9jbJ1Ka7Gg6FGdp9e/bovWeqQ1mHe4DfAKdgpvd2cdue5557jqOOOop0Os2xsW5Mjm9NCEgk0lRUmBHfi29eyMTHlgGmJNP5I3vz8xN6M2RwBQDpxjTJpjTp9IZVmUIhCIdCRCJAeRgaUtS+u474fUv41yum/HS3zmH+OLY/o47vRaIuRVMTdOgc5uM59Rxy3lwWLkmw7bbb8uabb9K7d+8se/cdzSWq6oDfzV0zd+D0JW+xLrm21Q3KQmXs3HMXdu21W2M0HP2Tc/5XQmDec/k2Do8DWMwI/mmYGzueUFAsUvgUFIuIiGsBuUDvhikDtLuLfawBfgC8Z7sz+RCJ1wwE/ryiYflRr339Kkvrl7b63I2SaI0DdsYEKAO9aMvy5csZNmwY8+bNY6fBHai9axt6dSujoSFNh4oQK9amOPXK+fz7tTUAxIZ15uaLzchuy8RbmQqFoLxDGFLwwL9XUHXLQhYtNTcDfnvB5lxxzmYkGlKkmqCiaxnP16ziR7+aRyKZ5qyzzuLuu+/26tfwDma0cnhTuunyGSs+7PzB8vdJpBKtbtAx0onde+3B0O5Dl4ZD4euAO5NVsUavGhRwV2JuBnhpNXAI8JYXO1NQLFL4FBSLiIhrAQmKAbYD/o0pCZStOuCnwFO2O+G1SLwmDJzflG668b1l73b9cMUHpNKbLvDbp0MfhpskWh9i1mp/jSkZtJ+Xbbrooou49dZbqYiGeOGOIfxg7y7Ur00RjYaoa0xx3MXzmDLVjKJedHIfJly0BRUdwjTUpVwdNxyCaOcyZs2pZ9S1C3j9fZNY7Lfnb84VYzajcX0K0lDetYwrb17IjX8z05xfeOEFRowY4eUpeAK4BTivLrn+5LeXvR2avWoW6TZya/Uo78Feffemf+cBs4FLk1Wxopvi34prgOs93udsoBIzgu+KgmKRwqegWEREXAtQUAwwBJiEGQnK1GzgPMy6z6ISidfsBNz5dd3X33/961dZ1bhqk8/bRBKt5zFllkbhcc3mDz/8kOHDh9PQ0MCvTunLzZf3p2FNE+EwRMpDnHnV5/z92RUA/Pq8zbj655vT1JAmmfTue76iY5gVq5o46dJvg+/7bxjIqT/uRcPaJiKREHUNKfYbNZsP59Sz995789prrxGJeFpAoxH4E/AccMPyhmX7Tl0yla/Wtx2n9e88gL367k2P8h4vAxcnq2LveNmogLoRM8LupRcwZcQSbnaioFik8NkKij39chUREWlhLnAEJsj9oJ3nLgImYEZBiyogjsRryiPxmmsSqcQ7by5+/fv//vyZTQbE5eFyhvUZzvGDT1g7pOuQ6zDTz7fAZJYeTR6+sydMmEBDQwNb9o0yblRfUk4G6GinMiY+suybgPiS0/py9c83J1HnbUAM0FCXomfXMv4xfmuG7WjKKl/4+y/5+NM6yivCJBJpunSLcP2YzQCYOnUqTz3l+SSCcuAS4CHg/l4VvU8/YsCRCw7e8hC6Rbu1utGX677g6flP8vrXrx2IR1OAC8AVmEznXjqU/GS5FhHJiEaKRUSKSMBGilvqCOyPCXq3x9TTXQ98hgkmXgaW2G5kPkTiNR9+vnbBzm8sfp1N1R7eRBKtqzCllX4PbJuvds2ePZvddtuNuro6brxgcy4/b3Ma1jQRLQ8x74tGhp8xixWrmzh03648+6fBhFJpkk3t7/fLxQn2OmMWy1c3ceg+XXnqpq0JZxDOV3QMM3N2PT84ezbLVzdx5Pe78s8/DSbVmIYQhMIhDjxnDq+9v47KykpefvnlfI4ozMSMhu6aSqcu+2jlzC7vLXuXxlTry4dHDR1NsipmZ4jDjjuAn3u8z59iymflRCPFIoVPI8UiIlLM6oApwA2YjLNHAydhEkdNpkgDYsfOLy6cssmAeGCXQRw76Hj27bffcx3KOuwG3IbJxvs4eQyIAR588EHq6uro3b2MM37Yk1R9ihAQjob4zd2LWbG6iR5dy7jt0v5EykIZBcQAi1ckWb7aPHnulw1trs1tqaEuxU47duS3528BwL9fX8PTL60i2rGMVAoiFWF+PtJknn711Vd55528zlTeCbOm/YBwKHz0zj13ufv4wSemduixI+GQLp0cFwAPeLzP24EdbHdMREqPPtlFRER81qdDH44YcCQHb3nI+93Kux0JnA78CjNqfmC+j59MJnnssccA+FFld/r3ryCRSBMtDzHj4zoeet5Mm/7VKX0Yul0HGupTZDoJbOnKJM03+lMpWLk6w2gaSK5tYvRxvdhnl04AVN+/hGRjinAImuqbOGr/rmy1WZRUKsWjjz6a79MEZvr/FKC+Q1mHEfv22+/lYwYdy5ad+vtx7KBLY5ZGvOnhPnsBf8PMLBER8Y2CYhEREZ90jnShcosDOXrgMYs277TF2cA+mBJLs4Cz8el7eebMmXz44YcAHH9Qt28KC4fKw9z7zArqG9Js1ivCmON7k3KyTLcXFC9ckuCs6z/n9Ks//+a5ny1s5Ptnz+H6SV+zLoNs1U0pU67pktP6AvD6e+t57Z11RCvCJJugZ58oR+xn1vg+//zzNDVlHnC7EAHOx4ze/6tHeY+TDhtw+Oz21huXiLWYKc8LPNznvmh9sYj4TEGxiIhInpWHyxneZ6/mJFrXAEOBFZgEZNWYNda+eeWVV0ilUvTrFWHvnTuRakxTFoa1K5M89fJqAE4c0Z3Ntign4STWamtd8Io1TRw3dh4PPb+SlWs3DFTnL2rkd/cs5oxrP6c+g5rGybomjty/K9ttVQHAoy+tgrLmoec0h+3XBYAZM2bw2Wef+XnaemB+VzcCVwzsMmjssVsfv3KvvntTHi73sx1BMw+zJKLew33+H/Aj2x0TkdLhaT0DERER+a7jB5/4TRKtZFVsUSRewz2f3v0Epkau737xi1/cA5y523Yd2Kx3hMZEmvKKMO/PWMenCxpMmw/sDk2ZzZm+7R9LeW/WtzFROAx9e0ZYuqKJppTZxzOvrmbOFw3sPKRDm/tqSkGX7hGO/kE3/vDgEv47bQ11a5qIRiCdSLPH0A506RhmbV0D22233YnAY27Px98+uSvrbUYNHU04FL535567XL9Nt23PpbSvqV4BfokpweaFECaR19vAl7Y7JyLFr5Q/wEVERDwVidekG5saNvi3xqYGwoTCjU0No4HRjP8PjU0NnLLNqdbaecdef2HatGnstm1HKA+TbmyCSIj/zTDJwPr3jbL70A40ZTCym0rBc6+v+ebvfXtGePA3A9lxcAXzv0pw2z+W8vhLq9h3104M2iLDEdVUmoP36swfHlzCrM8bmftlAztv05FEMkX/vuUM3LycmZ/Vc+111zx6xVVXWDmHLX/PYULm7+P/880JKy+rKLVs1HcCu2CCYy8MwNSOPt52x0Sk+CkoFhER8dCDc7xOyOu9uV/OAWC7geV8kxw6lWbGHDPau8PgCnr3jNLY2P464FQ6zdoW64UHbR7lB3t2BqBPjwh/u3Yrxp3Zj602i9K5Y2arttKJNDts3YFOHcKsr08x+4tGdh7akXQCOnYMs3X/KDM/q+fFD15i6zmDbJ/OTRo1dLTtJthQBeyIqTvsheMwybz+YrtjIlLctKZYRESkxKxfXQfA5r2jkEoTCplAdMFXpg7vtgMqoKz95FoAkbIQ/Xp9e4/9nU/qGf3rz3nm1dXMW2j2t8PWFRkHxGCmUPfpUcbmfcx+5y9qhHDItKcMtuwTBWD10tW2T6VsqBE4C7PO2CvjUZkmEckzBcUiIiIlprHeBKs9upR9M1KcSpmEWWCmQBPOfObvGUf1/Ob/m1JpHnxuJSdcOp/hp8/iwDFzuPmBJd/ULs5EKpWmc8cw3TuXAZhtm69YwiG6Of9et2Z9xvsU33wJjMK7xFvdMfW7y2x3TESKl4JiERHZWHfMRe3dwIOY8iiVthsl3kmlzHTnaNQEviHMqHBjwkTIFdGQ+ccMnXZUTy78SZ/v/PvauhRvfrCeK27/isMumMuipYmM9xkpCxF1sk43t6u5sc3tbkr6UpJJslcDXObh/g4BfmG7UyJSvBQUi4hISz8E3gT+hpkG+VPgCsxF7r+BvWw3UNwrKzODbo0JpwYxEApBRdRcFtQ3pr5da5yBUAjiF23Bc38azJlH92RI/+8m1PpwTj2/v29JxvtMNqVpTDYH6S0uV9KQcILksqhSowTYH4GHPdzfrzGlzEREPKdvExERaTYamEjr3w1HAD8ALsdkhZVNKIQES//X6WJWrVrFyjXfTksuK4Ne3U2wvHh5ElJZRMWOA4d14cBhXVhXl+L9WfU89J+V3PvP5TQ4Qeyr766jKZWmrJ2p2WXhEKvXNbHKqXncu3sZpJzB66a0aTcwdPOhBXG+S9gvgD2B7T3YVzfgFuAo250SkeKjoFhERMBkeZ1E++v2OgO3Ah2AuO1GB002JXju/9mZ1tq5atWqz4CtFy5NQshJYBUNMWgLk8Bq1heNkHQScGUQG//jhZXc9dRyjjuwOz8/sTedO4bZb7dO7LdbJ6bPXM/0j01ir7qGNIkklLVTmamsDJasaGLRsiQAW29pEoIRAppgoTMN+5lnnrkrFAqd4/Z85FKn+LQ77/XuF1K8lgFnAy8CFR7s70jMDJa/2e6YiBQXBcUiIrIjZv1wNolsfgdMxUyrljZsqnYxwCkW2zRx30m8+eb/mLWg4du1w6EQu2zTAYCPP6tnyfIkvXtESCTbjooXL09ywfgvWVuXovbtdSxf3cRpR/agU4cwr7y7jlmff9v3nl3LzHrldk9aiJlz66lvSNGhIsS2W1VAU5pwKMT6uqZvslr/+obrzx53+bizbZzD1PgN60yXYF3iTL0GXA383qP9/Q54Hlhou2MiUjwUFIuIlLYocCfQI8vtyjCJdGrJavVpaQpa7eJofzMi/N6n9aQbU4RCQCLNPjt3IhSCr5YlefvjOg7/QTdoJyiORkN061L2Ta3iG/76Nbc8uISK8jBLVyY3eO5RB3Q1x2pPOMSUaWsB2H5gBYO3LCeRSBOJhvj8iwQLvjIjxUt7LwnMudU07jbdBByEGel1azNMYGxvqoWIFB0l2hIRKW2XAvvnuO33ga1sd0CyN2T3IQB8MLueRYsTRMpCJBMpdt22AztubUaLH31pFZS1H8H27FrGLZdsSXmLEeA161PfCYj3370zF4zs0+7+ImUhVi1P8MyrpgbxiH26UtG5zMyejoZ4+5M61tenKO9QzoDt9fIrECng58Bij/Z3OnC47U6JSPFQUCwiUrp2B650sX03YKDtTkj2hg4fSrgszLJVSd74cD3h8hBNKejYLcIJh3QH4PGXVvH55w3flD9qyzGV3fjXHwbz/d07f2ckuFvnMOce35tHfz+Ibp3bv+wo6xjm6ZrVzFvYSDgMJx7cHZqaR6tDPP/GGgAGDO1Pny172z6Vkrn5wEUe7SuEyWnQ0XanRKQ4KCgWESlNYaAadxeVSWC97Y5I9jbfejMG7mBGWR97cRUQMrWKG1OcflQPunQKs3x1E7f9YynhDpldKlR+rzMv3jGEO68c8M2/bbVZlFfv2pZbx25Jz67tL1kvC0Pd2iZuut+UbjpwWBf23q0TjQ0pIpEQS75OfBMU7xbbjVBYS3gLzMOAV/PddwV+abtDIlIcFBSLiJSmnwIjXO7jC2CW7Y5I9sJlYfY60pScfva1NcybX080GqKxMc1223Rg1NG9ALh98jLe+2A9FR0zu1wIhWDHIR2++XvHijDbbZV50uFIlzJuf3gp782qB6Dq9L6Ey0x27LIOYZ5+ZRVfLUsSLgsz/PBhtk+j5GYs5rPDC5cBQ2x3SEQKnxJtiYiUnu7A9R7s535gje3OFIIgJmE6+MIR/Psvz7Fq7VruenoFN/zfFpBooqkxzbhRfXn0xZV8tSzJ+RO+ZMpfhlARCbWbiRogGglt8P9NqTSR9tYmp6GiSxlvvb2O6//6NQAnHtKdI37Qjcb6FOEwNKxL8efJywA45OBDuPKHV9s+hZKbrzCB8cMe7KsH8GvgNNudEpHClpd5R+lMihqKiIjnklWxTJ52De6D4i+APTB1SCUHNusUn7X9N1WMJgE/69Mzwtv3b0f/zaIkGtNUdCnj/ieXc/o1CwA459he3HntViQb0zQ1tf0d35RK84cHl/LKO+u48Cd9GLF3l3bbU9EhzMLFCUb8fA4ffdbA5r0jvHHPdgzaIkpjQ5qKrhu2B/gh8KxX50N1iq14FDjBg/00AYcANZG4KsSJFLpQRiUK8nDcfOxUQbGIiB0ZBMWDgLeBXi4PdRFwq+3+Sm6i1bXN/7sd8A7Q+dzjejPx+q1oXNsEISjvGOYXv/2C253R2YtP7cNNl/Qn3ZSmMeHd93xFpzALv05w/CXz+N+H6ykLh3g8PohjRvSgYW0T0fIQq9Y2sfcZs5ltah7XYsr7pLxqQ2JspT8nXloagql17kW2tFeBgyLxmqTrPYmIVbaCYq0pFhEpLVfgPiCeAfzVdkfEE7OAPwLc9fRynnt5FeVdykilINmQ5qZLtuT4g0w26psfWMqZVy9g9boUFRlkkW5PWThERdcy3p5RxxHnz+V/H5qcbX8cuyXHHNqdhnVNhEIQrghz7V++bg6Im4DL8TAgFmvmAr/1aF8HACNtd0hECpfWFIuIlI7dAC/m7F6Lsk67EonXbHKoNVkV8+UWebrFlK41a9awzz778NFHH3H++C95ZbuO9O8Xpb4+RXl5iL//ZiAVv/6ch55fyX3PrOCD2fXcdPGWHLRvF0hCY2OKbCaIhcMQ7VhGY32K2/6+hKvu+IpVa5uIlMGtVf35+U/70LguBWko71bGY8+u4PZHlgLwy1/+suyPf/zjaxvvM+TD0ILt31mRugOT9G8vD/Z1JvCQ7Q6JSGFSUCwiUjquBDJPBbxp/wEet92RQteYauTB2fdv8G+nbHuab9O3Nj7+cVf/mNlnzuazhY2cec0Cnv7jYDqUm2zUHaIh7rthIIO2KGf8PYt555M6Rpw3h1HH9OLCk3qzxw6dIBqCxhTJJkil0t8EySEgFIZwKERZNASREA1rm3jqxZVU37eEV99dB8BmvSP85fIBHHtYDxrXNZFOQUWXMNPfW8eYG78gZfb3/jW/vma3ez69+zvnrRR+Z0WqAfO59BzuZy9unayKlUfiNY22OyUihUef5SIipWEf3Ce1SQBXAUocUWS2G7YdE+ITAHhx2lrOuvZzkimoKA+Z9cNp+N2vtuSpmwez/aAKUmm4+6nl7H3mbI68cC5/fmgJ78+qZ+36JjMtumOYis5llHcIk0rDslVJXpm+lutvX8S+o2Zz7MXzvgmIfxzrxqt3bcuxh5k1xM0B8cez6hl56XyWrWoCWAGc2rVrV9unSrz3AjDZg/3oc0lEcqaRYhGR0jAOKHO5j3uAabY7IvlxwYUXcPH/XfwH4FePvLCSdDrN364bSOdOYerrUjSta+KYg7txwB6d+Mujy5j0xHLmL2rkudfX8Nzra4hEQmzVL8qAzaJ071JGtCxEfWOKpauaWLCoka+Xb5gDad9dO3HJ6X058eDuEIKGNSbBV0XXMt79cD0nVs3js4WNYEYTTwc+tH2OJG+uA44GOrvYxwKNEotIrhQUi4gUv32AY1zuYzmmHqgUt4uBjsB5k6esYvHyudx93VYM2boDjeuaqF+XonuXMq44b3POOa43T9es4rGXVjF1xnqWr2ris4WNzYHsJg3pX86Bw7rwk8O6c9DwLkQ7hmlcnyKVMjWNyzqGeXrKSs654QuWrEiCCYjPAJ6xfWIkrz7GlAf7lYt9PG27EyJSuBQUi4gUPy9GieOY2sRS/H4OrAYurXl7HZVnz+Hmi7fkpCN6QAoaGlIk1zbRp3sZ54zswznH9eaLrxqZMbeeT+Y3MG9hghWrkySaoGNFiH49I2wzoIKdBleww9YV9OgVgTQkGlI0rEsRCkGHLmWsWZ3kxj9/xe/vW0zK5JZeiQmI/2n7hIgvJgCnAv1y2HY28KDtDohI4VJQLCJS3PYEfuRyH58Cf7LdEfHVOEzJnOovlyS6/OTy+Tz20iquOrsfu+7YEZqgsSFF2imbtGXfKAO2LOfwSoCQybDVLO38pwmaEmka1puItywcoqJziHRjmidfWMl1E7/mvVl1zVt9CJwFvGX7RIhvvgaqgd9nuV0jcAFm3bmISE4UFIuIFLeLcf9Zfz2wznZHxHcTgbeBW4F9H3lhJc+8sppTjuzBOcf2ZvhOHQlXhCGRJplMk6hru3RwKASRMpOEi7IQa1cm+c8ra7hj8jJenLq25VPvxATlCnJKzx2Y2QG7ZPj8dcBoTFZ8EZGcKSgWESleO+E+4/QrwMO2OyLWTAMOBH4BXLyuPrXlnU8s566nlnPA7p05JtaNA4d1YdsB5XTvFnGuKjYeKTbZq1ONaRYvT/Lh3Hr+88Ya/vnKaj6e19DyWP/D3ID5t+1OizXrgJMx2ah3bOe5/8OsQX7DdqNFpPApKBYRKV4XYpIm5SoFXOv8KaWrAbgJs2bzXODMVIrBte+so/addYRDMLh/OdtuVcE2/cvZom+U7l3CRMIh6hNplq9q4vOvG5nzRSOzFjR8Jws18DpmhPAfQDKrlkkxmgEcAFyEuak3FIg6P1sNvAfcC9yPeW2KiLimoFhEpDhthRlxceMp4L+2OyKBsQgzknsLcBRwIrB/Ks1mc74wQW+GUph16i8AjwCv2u6YBM5yzA253wLbAT2AJsxrcL7txolI8VFQLCJSnEZjLiRz1QDcYLsTEkirgIecR29gN2A4Zrr+VkBfoAsm43mj8/yvgHnAu5h1yjOcn4m0pRHzWhERySsFxSIixacbMMrlPv4BvGO7I+KvxNjKVn8Wra7d1D8vw8wm0IwCEREpWGHbDRAREc8dD2ztYvs6TM1QERERkaKnoFhEpLiEgZ+53Mf9wEzbHRERERHxg4JiEZHicgCwn4vt1wN/sN0JEREREb8oKBYRKS6j2bBKbLYeBj6y3QkRERERvygoFhEpEsmq2FbAj13sogGNEouIiEiJUVAsIlI8RuKuDNNTwIe2OyEiIiLiJwXFIiJFIFkViwKnuthFCvij7X6IiIiI+E1BsYhIcdgP2NPF9v8FXrfdCRERERG/KSgWESkOp+AuwdYdtjsgIiIiYoOCYhGRApesivUCjnGxi0+AZ233Q0RERMQGBcUiIoXvcGALF9vfBdTb7oSIiIiIDQqKRUQK309dbLsCeMB2B0RERERsUVAsIlLAklWxrYGDXOziKWCh7X6IiIiI2KKgWESksP0Q6JLjtmngHtsdEBEREbFJQbGISGE70cW276IyTCIiIlLiFBSLiBSoZFVsW2BfF7v4B5Cw3Q8RERERmxQUi4gUriOBDjluux543HYHRERERGyL2G6AiIjk7Mcutn0FmGW7AyIi+ZKsig0E+gIdgTpgSSRes8B2u0QkeBQUi4gUoGRVbBCwj4tdPGa7DyIiXktWxfoCpwHHA7sA3YEQJrHgqmRVbAbwJPD3SLzma9vtFZFg0PRpEZHCdAi5Z51eBTxvuwMiIl5KVsVGAVOBm4EDgB6YgBjnzx7A/kAcmJasip1tu80iEgwKikVECtMPXWz7CqAphCJSLMqA24C/AVtnuM1WwF+TVbE/J6timjkpUuL0ISAiUmCSVbE+mFGQXD1tuw+lrjxczqiho7/z78kSOb7X7bZ57KCfsxLxR+CCHLc9z/nz57Y7ISL2hNzv4rvS6bTtfomIFK1kVexo4J85br4W2B2Ya7sfUlii1bW2m5A3ibGVtpsguTsN+LsH+zkrEq+5x3ZnREpdKJSX8LRdGikWESk8h7nY9i3gM9sdKFWReE26samhzeeUl1WQrIrl5arA9vFzlU6nM2p3KE9XU4V63kpAD+AGj/Z1Q7Iq9s9IvGaZ7U6JiP8UFIuIFJBkVSwKxFzs4gVMFlax5ME5D7T583xPD7Z9/EJtt+3jyyaNJPM1xO0ZAJwM3G67UyLiPyXaEhEpLNsDO+S4bRr4r+0OiIh4IIQpu+SlY213SkTs0JpiEZECkqyKjQH+kuPmszHridfb7kcOwsCumFGhzTDZZpdgpoJ/ADTabmAmMp2GS56+n4Gcj29rnRfkf/p0Btctmj4dPN2BmcCWHu7zK2C3SLxmie3OiZQqrSkWEZFMHORi2zcpzIB4NHA+JqDf+HsrBczAlGK5nYAHx8mqWKh5ilYkXmOjCSEn6C0o+VornE0TNj5vyaoNVzEUSBbqXkAfzPtmCaZmeaHaDBMYe6kH5hwpKBYpMQqKRUQKRLIq1hkY7mIXhTZ1ugtwD3BCG89pHkG+GTgUk4l2ue2GbywSryn4KVSaBbah1m5qBHC0uANwOma97M5AV8xSilXAe8BDwD8I+A2lVvoV9XifZUC57Y6JiP8UFIuIFI6dgME5btsA/M92B7JQBtxLdmsGjwT+hQmiF9nugEgAbIUJevffxM86Y6YeHwmcjQmav7Ld4CyswXyueRnEJoE62x0TEf8p0ZaISOHYj9w/t+cAs2x3IAtnkVsSnf0wgXF/2x0QsWww8AybDog3FgP+RP7WsufDYmCpx/v8Gk2dFilJCopFRArHfi62nUrhTI/sBIxzsf33MMGAAmMpVYOBf2KWFmTqOGBP2w3Pwjq8n/3yViReU8jrrEUkR3mZPm0/H4Z4KTG2ckQkXvNCJs8NQDIUsaCUXiO21lUmq2IdgT1c7OI1Kw3PzQHAti73sTsmKPghmkotpWVrzGt/5yy3KwMOBN623YEsPISZ9u2Vh213aGMF/pUpAVNK12vZ0ppiEZHCsA0wJMdtk8A02x3IwoEe7WdPTHBwNJbXSm4q+ZKl7NM5K9Lro3IglU6ns04evXH26YDYGjNLYqcct891O1v+jcmqv68H+3oLs/RCREqQgmIRkcKwO7knlPkc+NR2B7Lg5YX5MOAJ4Bh8WCtYDFmmW1OM2aeTySRlZWU5bZvJTQ2fM1EPwgR1bt4/nXxsrxcSwCWYzPpuEm4lgEsi8ZoGF/sQkQKWl6A4MbYyo2H5NkyIVtdO8eMEJMZWjgTOdbGLy6LVtdP9aKuIlLRhLrZ9l8LKqNrD4/3tCzwO/JgAlmsSeyKRohkb2AoTEGc7ZboYvA5cBPzZxT4ujsRram13ZFM8uKZuz1zn0fLvK/y6DhcJirx8G0TiNSPcbJ+sik0H/HozjnTT3mRVrKdP7RSREuWMNrlJgPOW7T5kKbehu7YdADyKSSakRDpSTAZgpkzvYrshFv0FaMLUK++SxXbrgbGReI2bgDqv3F5T5yod/+Z6fDIwOVpdO9ftPkWCLKi3SEcCl+X7IImxlUMi8ZqRtjsrItKOnsD2LrbXbBbjIMwF3onAatuNEfFAc0CcTZbpYnUn5rPu15gEe+15Hrg6Eq8ppHwLvorEa4ZhZimNTxCbgo8zOUX8FsigOBKvGZIgNsyHackKiKXoZTH1SksBgmsboF+O264FZtruQJby+d10KPAPzOf/WtsdFXGhOSDezcN9FvTC8Ui85m3g6GRV7PuYOuf7A5tj1hs3YuoQvw48EYnXvGK7vYXEGbEe4QTHYzRyLMUmkEGxYyT5H91QUCxFL9OpV1oKEGg7kfuU4s+AhbY7EDBHAPcDP8XFWutWEi0VZYpm+S7L2ae3wGRW9zIgBkjZ7JRXIvGa1zHBL8mqWBegA1AfidfoRphLzjXFnASxk6LVtZNtt0fEK0EPivM2hdqZOu0mcY2IiF/2cLHtTMxaO9nQj4F7gdMwI0huFPTomuQml5JaHmWj7ocJiPewfQ4KgRMIKxj2WCRe80iC2Jhode0k220R8ULYdgNaE4nXDEmMrcxn0KpRYhEpFENdbPuB7cYH2EjgLvKT2EskH/oAT+EuG72IJyLxmol5vlYX8Y21keJkVWxuJF4zpJ2njSB/U6gVFGduerIqdqjtRkig6TWSJ8mqWEfcBcUzbPch4JpHis9BI74SbL0xNbf3td0QkRYeweS9ECloNqdPTwbGtfOckcAErw/c3tTpZFVsUiRe46Z2cVGJVteuwL8SWVKA9BrJq82dRy4SwCzbHSgAo4F64ALbDRFpRU9MSbEDbDdEgitZFcv2e7in26WETnLccdHqWs+v10X8ZDMoXtHeaHEkXjMsQWxIHjLctTdKrAy8IhIUQ8iu7mZLS4EvbHcgSyHsLO05HxMYX2L7BIhspBtmNO5A2w2R4EpWxaZEq2uzn7FVbZa5J8ZWjsBMyz83g5mcG4jEa8ZTHVJQLAXNdqKtKUB7I7L5GC1u75ga8RKRoBjsYtu5FF49XltBMcDFmMD4yhzaLCXGp+zTXTAlxDKqIuCBosg+Ldlz6g9PASYkiI2LxGvGZ7N9YmzlSGWjlkJmO9FWJiOyni7gT4ytHNbWHbBkVWyuaq+JSIDs6GLbeWidbLauAK623QgRoBPwEKaEmF/0eSFEq2snJKtiY7LcTAm3pKAFYaS47QbGa0YmiPV01ix6ob2p07rLJSJBspWLbT+13fgC9WtM/eLqtp5kuU6tFLcOmFraR9tuiJSmaHXtpASxEZF4TaaJaRUUS0GzOVI8IlpdOzdZFctkVNbLTNFaTywiBcGpaeomKJ5juw8FLI4Sb4kdUeAe4DjbDZGSd1mmT4zEa/ya4i+SF7ZHiiGzdcUjANfFwdubOg0QlPUQLRIeNPe/NXNbPKYX89TvxNjKIc656NnGOZkOrHDOhbW14Ru1dZjzZ2DbW0xavHeGOI+NtXzPTPFwFko+dAK2yHHbNIWXZCtobsOsMb7LdkOkZIQxr7ef2G6ISLS6dm6CjEqo5lWxXRMnxlY2X8c2Xyu21o8p0epaDdb5pCCC4ki8ZmRzdjyX2hwlziGVvacSYyvPBbKZqvLdfRCbi5kCPsmrDwOnMHtGCRdyynzY9rGHYF4fIzP8UP7mwyUdh2RVbDIw2Y+bHTm01bP2JsZWvuBBF8Ynxla2GSC29vu1+Rpxjj8Sc96zfu8kiE3H3HSbHMAAuSfQPcdt64DPbXegCEzCnMsHbTdESsIk4HTbjRBpYS6bvsGcV0G8Js7iWmd6tLr2sk1sPwKT3TvjPjl9mBCtrnU9OOinbK4LHdOdflq7DgtKUNwuj7LatfcitBIUO2/8cV7ciXP2MQ4YlyA2CfMCc/tB0DPjaTHe3LxoDjDHua0X7XzwjHQ+VC7LR3DsVVvdtNeLaUsZ1Sps/ffr+2sEvHnvOP2eCExMELssYLUW+wFdc9x2pfMQd8LA3zCB8RO2GyNF7Q7gbNuNELEp4NfEGV3rbJxvwhkZnphLgO/0YWKC2LnAmEIYOU6MrewZide8lenzk1Ux6wExBCAojlbXrkgQm57BBfkwXCTBymTqtJv959imnsAj+VqH4QRp5yaInRSUaeEZnpesSwFkcC6GAI8kiE3GfKh48sZLjK08NxKvmej1OWjR3inASbY/KILGuREx0ev3TiReM9754jkpIF88vYGyHLddROGVYwqqckzSoxOA52w3RorSrcDPbTcCaLLdAAmcnpk8ye1sy2K6Jo7Ea0a0qP88zOmXqyDfiZPeShAbE+RRY+f3mPHsRScgPjQI17m2SzI1y+TF6TbZVntTp78pxeRccOeV8yZ5y4/EBJF4zSPOnbdAS4yt7JkYW/mI1wHxRudiZCRes9w5/27bOzEfAfFG7R0BvOVFe4uFc4NrTh6/OIdE4jVvBeQ908/FtouBpO0OFJFOwMPAgbYbIkXnJuBC240Q2Zgz4pfp9UfON5KL9ZrYuV55y8s12ZF4zURnyVhQPZLFawYCNPATlKC43TdSJF4zxGVgkE0pprwGxS3uhvm2RiPob6LmO0tu1o5keT5cBZrOaLYvH6rfjBqbc1TSnJH5jKfkuOG8Z2wHxpu52HaJ5bYXo+6Y74p9bTdEisYE4GLbjRBpRTbXZDlNSy7Wa+LmKdN5av8jfgzg5dDnrGbwJatiw4OUDC0QQXEWWXdzuoOU4dRpP6dKTrSRyc95EwU1sHohyztLXsjpfDivp7yNZm9Kc2Ds5zGDJjG2ckS+R+Y35nxx2hyldxMUK8lWfvTBrC3ew3ZDpOD9FrjUdiNENsUZJc74O9fFlN5ivSY+N8/Xtb5eD7Un28EiJyAOwjK1b1hbU9xyvj2YrLsZjBKOxNxVzVa7d4P8WnPrXNhnfXfKmXP/zfQCF1NMziW3c5jPczI+lw8Op8Z18x2mbKb4ACbQTFbFJgInZXnorAPiFmttVmDW5+TS3hEJYucGeS1JviTGVg6JxGu8yLCdi0cSYyuHW5re4+YL+ysL7S0VmwNPA0cCM2w3RgrS1cAVthshsinOKGTGN+KTVbGcriuL+Zo434MnzjXhiCCU83Rm8WXc3yAGxBCARFstTKGd4DUSrxmWIDYkh6H29tYT+xlkjMv0ic6bftOlYqpDzR9aI7N5IUbiNeOpDgUmKHY+ELM5J3MxH2CtnZORmLtzGX1ARuI1IxPEMs5s7owSZzM1pNWECAliPTGvzWyyLI7Dg5rdBSjrUXLn/TOFFl+cODUBs7kr7dw8GQdcluk2Hsq1HBPAKgvtLSVbAU8BRwCzbTdGCsqlwK9tN0JkY7lcVzpyva4syWvijZOSuQzqbZeTHZbNjIJkVezQIAbEELygOBMjyCIoCNLUaWe0K6MXvhOoX9bW6JRzc2CCk2Y+4+nHHpW38ko2b6R2y+U4/ZqcIJZNVujxZJ55PNu1Eq2+tpzf7aTE2MrJyapYRr+/SLxmyKbuDIZCoVbrHKXT6XSG7T00CHccN+ZMycl4VN35spnQVl+cDNMZ34yIxGvGJYh5Vvs7Cz1cbKs1xfm3DSYwPhz4wnZjpCBcRMBma20kZbsB+ZasipVhbmr1wGSWrwPWAYsi8Zo62+1zYUhibGXGQeZGhgFDcpy1l1NFj1K7JnauTSZt8ljfDupkdb3jDOz0tJWoqjmRWBbnYEwQrzObBSYojlbXzs2wNFNWQTGZJQnwK0DMaIqIMxp6WaYv8mh17YrE2MoxQKYvzEAsznemW2TUlkwC4o3OyaQEMTIJjJ1AM9NpyZl+gE/I9E6Y8/s7NFkVyzRD4Qgs3xn0i7OmKZspOZOi1bVj2ntetLo2q5sRjnPxf7S4W47bpYBlPre1VO0EPA4cjcn4LdKa84BbbDeiHUUbFCerYptjfgdHA9thMsqHMWWoGoAFyarY68A9kXjNa7bbmy3n+sHXfCfOtU6us9dK5po4y0GdiVkmch2JhRmE2SYSa2vmZFAEItFWC+1e6Oew9qC9qdOTfbzDkuko46Rs2xStrp2exTTwvKe8z1BGdzSTVbEp2QTELc7JpCzOSaYfQJl+eGYVtDq/70z7WErlmbJJ2jA5k4C4mXPOD82iLTayt3fJcbtGNH3aT3sBj+JuZF+K21nAHbYbUaqSVbEDgdeBazHfod0wA0NhIIr5rN0JOAd4OVkVu852m4POCYjd3CguiWviHAZ1xmRZ89n3ga4WFWMyuh4thIAYCjAoBsg0jXqQpk47Mn3h5jpynWlfrGegzvB30yzjQGcTMvrAjsRrhmWS3j6fGRIz/cDwo45fUGS5rinr10m0unZFsiqW0XYelIXLRecct0tiRj7EPz/AfHbn+juT4nUacCcQcrsjyV6yKrYj5qbV4Aw3iQDXJqtiF9huexAlq2Jzk1Wxk1wGxFAC18S5DuqQ3RILGwMlGSfIdW4KBD4ghgBNnwZTmikdz+ipw8jsTRKkqdMAk5JVsUzOQ67rFjPaLhKvGdYy87clGY0AOqN/Oa/jjFbXrkiQUWZzyD27+abkNMW5rbXBpSabGsG5rmlyTCbzKUAj8PdGWjTH7dajoLiluUBXoG+ejzMCeAg4ETNaL/JT4G6gLE/7bwAqbHcy4H4D9M5hu2uSVbFHIvEa5WdwOCOYJ3k0w7IUrolzuqaMVtdOSRCbm8lAzMbVfPLNqRiT6TX8pBxvClgRqKAYsirNlMkdqvamTk/3M3FOIb0wfJDpaKcXa2enk9kNknbveiWrMlr33pyYaW6h3B0LqIxHxN2c5yxvnPg9yyLXoHgtJnmMGP/DBCbPkvs5zdSPgPuBU4GE7Y6LVT8B7iF/r7nfAfsBB9ruaFAlq2JDgR/muHk/4CjgXtv9CApnptryBNlNCd6UYr8mTlbF5rpMKjWZLLJz+8HJBZTp0seMcrwESdCmT0Nm64qHtDfVNcPpuUHJwFxSnIyDeVmb62YfGQZFGd8djcRrJibGVj6SGFtZMtOdvZRp/gAvSqpFq2tPCmXAg+liWZ+GHLerQyOVLXXEfA6MATLKxu7SSMx02SB+x4o/jscEU+V52v8DmDrHeo217fu4G0mvtN2BIIrEa8Ynxla+ZWFJUSFxe/1qJaN0a5wSqhnNqivEgBiC+WGa6YuovQvmTAKRksjgG0DZjAC6HsnPph6akzygLVm9ZiLxmpGReM0LibGVcxJjK8crQM5MluepmN/HboJiTZ/+VnMg/Degyqdjngn80XbHxYqjgL+Tv2nNNXy7BMnrUeimfJ0US3Zxuf32tjsQVJF4zbBIvOatbJY6lRi316+BqeXrDDS+kMlznXXUBRcQQwCnT2dRmqm9n7c3dXpuUItHN3MCtOZ+DqH9qZuBKLWUgYymoGaZfc8rw2g7yJpMDiUPnJHxccC4dPybvk0Bpge5ZptF2dx9Lubzl+uNywaKuLRKDpIt/v8mYDP8CY5/gZnKfrntEyC+OQR4GFPuJx9mYKZlr3f+nq+1ysWiv8vtt7DdgaCLxGsmOsvF8vpdXIDXxIGOMTKVbekl4CTbbc5V4IJixxTauSiOxGtGtraw3Jme295FdeCmTjujYyOAYUWeYTijvkXiNSMSxDK6M+WhNj9knZs2ma4/bbNvzefBCZInY173fpYIC7KM1+4W+fnKNShO5rhdsdp4yvQ4oA+mTE6+XQaswyT7keJ2AObaomue9r8Ic8P/a9sdLSBuR9LzdXPDc84IXTZlBoENgs0hmOvPrEd+I/GaFxLEtvEyT08JXRMH3SOZZpp2nIt3SWt9FeSguN2F3ImxlSOdYtcbC1rW6bb6MAQYl8uHUCmw8EGYyZ3FMXhcs9YJskcCExPEJmPq8hXzCGh7Mk31X+znKNeUkgqKN7Tx+UgD52Fuvhzrw/FvwATGf7B9IiRv9gIeJ3/J+NYBpwAf2e5ogXGbQ6CD7Q7km3Nj+dvv0urQGCehUjajg2BGE7MOylsqpmviYriGczJNZ3UdHonXjE/grnKMLYEMij0ozdTmLzAIU6eL6Y2frUK/4+dkKx4eide8lY/9NwfICWJzgctaufEj0hY/kkkVkk2dj0bgDOAZTI3hfLsZM+U12wtNCb7dgafIX8mvJDAKeNl2RwuQ22UkJVnuKlpdO8m5Qf9CpqOEzuy+EbkEg6V8TRxkmWaa3oTxFOA06iAm2gIyzij7ndG6xNjKnhkEXVaDjMTYypGReM0cvfkLV7S6dnqyKrZNsiqWt5srkXjNkEi85pHE2MoX2su2LrIRBcUbam3kfA2mpvD7PrXjdkypJikeOwFPk9+1p2OBR213tEC5TTiYr+zhgeeMIB+arIplM+KXdRCla+LiE4nXjEyMrfR0RqUfAhsUk8EC9VZKM2XyS7A2SuxMSXnE1vHFO9Hq2rnR6trhyapYXsv0ROI1IyLxmjmF+AHjps+22yBFpa2bBIsxU6jn+NCOMky95BNsnxDxxI7Av4CBeTzGjfibxbzYll64LU1X0onMnMA440zCkXjNiAyqeHxD18TFyxnUyddykrwIclCc6WjuxhfP7U7zsDUdNcc1GhJw0eraCcmqWK9kVeyyLO+oZsX5gNGd1NKiDNLeSLTz88+A44CvfGhLOaZcz5G2T4q4MhT4JzA4j8e4B7iyjZ+H8T5oK7bPnPbe+9KOaHXtlCyvbTK6qa1r4pKQdbUWmwK5phi+WbeZSWmmEcA3U63bm36R4bRszzkZsbN+8ztZiac7jzYX7juFtf3O1pw3zoew3wv1c0qM4NxNnQBMSBAbCYzIx1Qgp/TBdNtr4vMtWRWbotFioPhqhtqSyXTyDzClbp4BuuS5PR0xZXt+BNTaPTWSgyGYKdPb5PEYzwM/t93RIuB2pFiMyWQ+Nbrd5V66Ji5cyarYZZF4TUbBbiRec66TdKsgko4FNih2TCaL0kyJsZWZJAOw9YvJap2FMyV3UpGXm2nPpGh1bcGldXdmIkx2MjiOxNy4GeHUKvbCeFxmeJSCkWtQnGvW6mKV6XmsBU4D/kH+E+x0Ax4Djgb+Z+/USJa2wgTE2+fxGG9jMk3X2+5sEVB+BW9kcy2aybW4rokLULIqNsZJwrYii5saExNjK4cXwu8uyNOnIcMAtkUw3O7Iko2p084dsYxHDZNVseHR6toJhfACykUJlNH5RrS6dnK0unZMtLp2Gycx1xi3sxWcNTvZ1IwrWiUwmpzr+j4FxRvKZkroU5g1dH5cTPfBlPHZzcZJkaxtDjwJ7JzHYyzA5EZZbruzIjlqcx2prokLU3NADCY7eabX8s6AUEEs/Qt0UOxk+M1k+mzzhXGbiYhsTZ1ur10btfGkYp8am4WiyrjsJOaaFK2uHRMKhULJqthwF6/JYk+6pfeAket6uKDPAvJbtiPu9wJ5TaDXwpbAE8C2vp4RyVZvzA2M7+XxGKswZUwKrr5ngEVtN0C+Q9fEBaZlQNxCNgnYxhfCYE6gg2JHJncihjmlmNo74bZGKDN6ITj1k0uhJm2mv4fAv4HciFbXTo9W145xknRlO028qM8NWUzVSoytLObR4lyDYl0IbiiX5EG/dx5+GIIZgRzg1wmRrHTHBMT75fEYjZip+7an0hfbdGO3iciK7Xz4ob3vb10TF5BWAmKi1bVzs6y+EvikakURFEfiNc3rNttk8c2V6Yin2/YVSqCUUcATidcMK4X6vNHq2hXR6trLsvlwKYFpw9ncGS6U130ucl1TWEGJlxLZSK5rs8fRIpFjnu2Mmbq9mU/Hk8x0xdQIrszzcS7ElHfKRhjvZ4UUW7Zmt7kBiq1EVa6yueZo7/tb18QForWAuIVJmWYmd67ps65j7adCmGKX6ahie1Onrd1tymAEu5nb9RKFUg9sMpnfMRqJyepc9KLVtRMSxM71MCFXwYpW105JxzN++rm4fI04pa4yef/Mxf0XdTbW5rhdR0zpnzof2xpkbsrMnI95bfixZOF7mBHjH6I1pUHQCZMlPN83Ia/Bv5svpaajy+1LPnu1swY4m/dAm9eyuiYuHO0ExKZS0NjKy4CMak1H4jXjnWzUgVwiEvig2CnNNNkZDW69I+38HHtTp/1UEKOHWZTbAm8CnpFkeGeytWzXTtCUyUXx9Gh1rZu1iNmUPShqyar23/dgkjgkiI3INeW/s/Qio5s0yapYxmtoPLI6x+06YkZIFBQbbkpbNQGjMBdYfnzG7ov5HDgWWOPD8WTTOgIPAEfl+Ti3AzfY7mwRK3e5fckHxWSfJCko19sFcU1c6KLVtZMTZFVGcyIBraAS+KDYMR33d+kLYV1Czne1nDt5hTRVpN1yW/BNwDMu19JMTsCT0R2sdtb1rsjwDT8iQcxNlkRlV/zWFDJ/348j9y/ibL7w/f4cyTUo7gJ08LmtQea23vN6TA3jfwN7+9Deg4GHMK9/3djwXwXwd8yNiXx6Avg/250tcp1dbl/SZbESYyvPjcRrMr5Rn6yKTfdwFLCUrokL3RhgTiZPjMRrRiSIjQzievFCWFMMLi9Ek1WxyTZTuWc63x53gX+hjS5m/Dt1mbUum/PSVpuyWeOaUVHzVticOh20L5BsXiMjclmrkhhbOSzTIvSWPkdW5rhd80ixGG6mTzdbDpwAfOxTm38I3I3WhvstCvwN87vOp1eAM9Ga1bxJVsVCmDXhbpTsTanE2MpxWdSibdbu97auiYtPtkm3IvGaRxJjKwM3vb0ggmLnZLu582R7Kkemi9CHONN0s5IYWzkim5pvQeD8TjNeQxWJ17yVbWCczR3OZFVsSltp/532ZhQYR+I15zpTtnOR0fSTPNV6DlRQHK2uXZHla2R8Nu8f5wM5my98G58jq3LcLor7tXTFxO1IcbMvgOOBhT61+2Tgzz4dS8w10STgp3k+zseY362mx+dXBSZzuBu5ztYpSImxlT0TYyvPTYytnJPpDeONZPKdrWviIhStrp2QZazmZgApLwpl+jS4W2tpe4h+ChkGO5F4zcQEsemZ1mVLjK0cmen04ACaQBZTVyPxmrcSxC5rbyq1E+yMy2bKD5mtW85oyrfT1kcStJu1b+N2T8wiyZbnAVokXjMyQezcbNrsg2xfIxMTxHpm8BoZAWR8vp3SEDbOy7IctysHellob1B5MVLc7CPgROBZoIcPbf8ZJuHaxT4cq9Tdhlk/nk+LMa8fL26slOH9dZxXN5CCoAL3yZZy/Qy2YYiL7L5DgGFuphwnq2KXZTibStfExWsM8EImT4zEa851km7ZHrj8tk22G5CFKeQQFNueOt2i7RlrDv6ASa213Rk1PbeQ74ZFq2vnJohNyCZ4dTLXnYsJUOey4R3HYZgP9axGaZNVsUkZviknkcWdLefDfCTm99jqjRnndzk+y+yOGd/oSVZlnNSsuc3DMOe1+UuoJzAk13XdbjivkcuyuWMdideMT8cZ76wRn86G67SHASNz+OJ3kzzNja9z3C4E9LPU5iDy+kL/Dcxo4mOYDMX59ivMuuarfDhWqboJ+Hmej7EWMyV0hu3OtqGYguLOuH9/LrHdiUw5N3mtjL45s+0yvUbQNXGRilbXTskkOXILExNjK4cHIE4DCigozrJES0vW70BEq2unZ5mZDScIGJ8gNgVzUT8dcycv29T4QTchWRUbkU2Q4nzwe7leJKOAx8manW2ANgIYkY5vespzLr9LJ4jPZorKdLKYGt3ql0p1yEppLKdUVdaBbJYzBVrl3FizNdvkKxfbaqT4W16OFDd7DhgN3I8/36VXYoKqwE05KwI3kv+R+BTm9VJru7MlpC/uE20V0kixTSdl+kRdExe9y8hwPXgkXjMkWRVzXWXGKwUTFEPmJVo2YnvqdLMJ5JAevsWb3Y8amb5zapyNAd6ycfxkVSyrO1S5BmiQWwDcimxHLbNJEhZUVl4jzvoYv8swteTm7qmC4m/la/TrH5iZFH6t+/0dJjC+zafjlYLrgMt9OM7/EZzrkVLRF/fXuW5uTJaEbK+jHLomLlLZzvBzZoBOyXSKfD4VRKKtFrIa9Q3I1GnAjHRnkzQoF9kscHfWVAZCtLp2erIq5nvNsmRVbEyOb0Jr9dWSVbFDc3hNF/yFmPMaGW7h0CdZ/gxZSu4lQfpbbHfQpPO477/gT1DV7FbgLB+PV8wuB6714Ti/Af5ku7MlaDMP9jHPdieCKlkVm+4ExFlfR+mauLjlkHQr2yzneVFoQXG2F/fWp05v5LJMMxjnKOPpK0HjfED6FvQkq2In5Zo4ycmKPDzPv8tNtXlMLgkJnPbaWhPrGb8D41y/7D22hNyznw603PYgSeR5/+Pxb1pzCJPfoGA/7wPiEsy06Xy7C7jadmdLlBefgYtsdyKInJwdh7r8jtQ1cXHLeJZdJF4zzEWSOM8UVFDsXNxn8wYK1AiZM+J0aD4+BJpHPfNUqscXTvu3yeeHZIs7m65eG84XwaHJqljeX2PJqthcp80531V17toV7GujRT+aXyN560uyKjYlWRXbJgABMZiSLbmWZepju/EBks+R4maXA3f61J8IcB+mlrFk75dAtQ/HeRo4P4/7z0f26WIyyOX2jZhs4eJwvh8PjVbXZpppulW6Ji5uzmBXxtfITlnNTCuw5EUhfphmVBbHyYQXiKnTLTltGp4gNt6LREDO9ISTWlzAZ9rnwBXNds7PXOf8jMuxRl6rnHIBni3md36XJzkZpsdnUU4pqzbTRsbFLJ2UrIpNzGFdfqA4r5FDC+E14lYkXtOQrIp9CWyXw+abY5LMrLPdjxx4HcQmfWr3BZibEcf5cKwK4EHgWOC/PvWvGJwH/NGH47wJnIEJrApJvmdV+MltULwKrSkGTIJPzLWIpwGsromL3hiyW/89EYtLFAsxKM70rk+g7w5Fq2svSxCbhKmnm3UKeeeN3/wh1fJNP53MXoBW78ZkcH4mOOfnXEya/Zza69yBnATkbX25M+o82SkVNcJt0Om0eTLeBcPN7WwZxJ+bTeKvLNeG+GKj10hOyc+cvuX9NeLSFzlu1w/oRuEFxSkKtyxMAjgdeAo4xIfjdQMewYwYT7Xd+QJwJnC7D8eZhZm6messD3EpWRWL4H769GLcJTssOM53fcuHLwmQdE1cnLKt2hKJ14xIEBtna3AiZOOgsqHE2MqemDdtc/H07wQrzoV7c+1YX7O0JcZWjojEazIqxh0KhfLymnKmVIzAzBIY0sY5ak7V3/xhbiWYc5I2DHMePZ02f+dDt8XUnuYyA7612Tmnw2j7y2A6MNfWecyhPyOc/jS/TjboW4sv/JxfI+m0HzNxN2jzBODSHDZtAvbFUmZ3l95w2u6V8/EvQzRAb+BZYG+fjvcl5u76Rz72sdCMBB4Aonk+zmLM59AHPvSpE/A2sL2H+7wOuN6HtudFJF4DQLIq1g/4GHcjgP+KxGt+ZLtPebqsCqygXxNL8Sqtd5rkJAhBsUhQWAiKzyH3taojgUd9bbA3Cj0oBtgKeAFvA5a2zAIOBz7zuZ+F4MfAw0CHPB9nHfAj/JvOrqB4Iy2C4r0wU9jd5M75cyRek8814SKyCbZCiYJKtCUiUoIWuNjW7Zq6YuHXmuKWPgeOx4zi+mE74J+YYFy+dSRmhDjfAXEKUypL67uDYQjur3E/tt0JEfGPgmLJhNZaiNizAKjLcdudbDc+IPwd3v/WTEwirCU+HW9n4Em8qc9aDEYA/8AknMu3X+J/xYsy5yHftbMH+/jUdidExD8KiiUTGa3J8btur0iJWAQsz3Hb7dAyGbCbuOst4ERyrzedre8Bj6FsqpWYILWrD8e6Hn8SePnBxqyKfHAbFK8H5tjuhIj4R0GxZCLTkeKSytIo4pM15L5OdBtMhuJSZ2ukuFktJiu1X+V59gcewqw5LUX7AY8DPXw41iTMOtxikbLdALeczNM7uNzNYswNSREpEQqKpU2JsZU9s0iPH/gMxSKFJhKvSQHzcty8L1pjCsEY/XoaU7PRL4cD91GYpRfdGI6ZQt7bh2M9AfzCdoflO7YEBrjcx+xIvGat7Y6IiH8UFEt7Mqot5lBQLJIfuZbaieJ+xKQY2B4pbnYP8Csfj3cCcBel812/GyYg7ufDsV4HRmFqU0uw7ID7GTIqbyZSYkrtDrK0ITG2srmmLpg6ryM2VR+uDVpTLJIfbrKgDqMwyzJ5yeaa4o3dAnTHvym3Z2BKBRV7aZntgaeA/j4c6yPgJPxbJy7Z2dODfbxruxMi4i8FxdLS+CyD4I0pKBbJj08x61HLc9h2D9uND4CgjBQ3ux7ohclY7IefY9amj7Pd8TwZjAmIt/bhWF9iRuD9KrXVljJ0Hbcpe7jcvgmNFIuUnFKZUiV5lqyKTY5W1yrRlkh+fA58neO2O+FPSZogC8Ka4o39Crjfx+NdClxpu9N5sBUmIN7eh2OtBn5CcQdMQbuBlJVkVSyKmUbvxnKUeVqk5CgoFq/4XZ9RpGRE4jWrgE9y3HwAMNR2HywL4oV+CjgHswbWL7/Bv9FpP/THBMS7+nCsRuAU4DXbnc6zQl8jvTXuZwx8Aiy13RER8ZeCYnEtWRWbEq2uVVAskl8zctwujFlXXMqCtKa4pQbgVOB5H495CyYYL3T9MDcUvFg/mokxwDO2Oy3t2hn3pcjec7L+i0gJUVAsXrjMdgNESsA7Lrbdz3bjLQvyBe564KfAmz4dLwT8BROMF6pemHJIw3063jhM5nAJvn082MdbtjshIv5TUCyuJKtiw6PVtUqwJZJ/75P72ti9Ke2EPEEOigFWACcCM306XhmmVNMxtjueg26YbOrf9+l4NwO/t91pyZjboDiBuxuQIlKgFBRLTpJVsSnJqtg2CohFfPMZsDDHbbcFtrHdAYuCHhSDyWZ8HDDPp+NVAA8AB9nueBY6A4/42Oa/A2Ntd7oNyj69ob6Y6dNuLEBJtkRKkj5MJWPJqthcYAowOVpdO8V2e0RKSSReszJZFfsIGJjD5h0wo8W5JusqdEFdU7yxT4FjgeeAzX04XhdMkHkkwZ8y2gETxB/u0/H+A5xLMJO0yabthllr7sb7kXjNWtsdERH/KSiWli5LVsV6Ov8/jA3rDk9XySUR66aRe1BwIGbkqxQVwkhxs/cwU6mfAbr7cLw+mPW5R5B7Mrd8iwJ/A37s0/GmYTJN19vuuAWFcgNpU37gwT7esN0JEbEjL0FxOq0bqwWqZRD8nZHgdNx280RK3jQX2+4HlGNKy5SaQgqKwZT9OQV4DDNCmm8DgKcxN1xm2+78RsLAJOBkn473KeamxDLbHbekkIPiAzzYx/9sd0JE7NCaYhGRwvEesDrHbbcDdrHdAUsK8UL/WeAsck+ulq0hmJq/uUzPz5fmTNmjfDreIuAEzLpSKSz9cV+e60vgQ9sdERE7FBSLiBSOz4GPctw2gplCXYoKdfrSw8B5PrZ/J+Bx3K/L9MptwM98OtYqzAixgqLCtB+mVJcb70biNcttd0RE7FBQLCJSICLxmhTupveNsN0HSwpxpLjZXcAvfTzeMGAy/qxnbsstwPk+HasBM139dct9zlaZ8xBvPttqbHdCROxRUCwiUlhecbHtPsAWtjtgQaGtKd7YbcDVPh6vEngI6GSpv+OBi3w83nmY6eqFKGS7AQHQEYi53EcaeNV2R0TEHgXFIiKF5S1gTY7b9sKbDK2FppBHipv9BrjZx+MdCdyHSc7mp2uAcT4ebxxwj899FG/tAQx1uY/5wAe2OyIi9igoFhEpLPNxVzrnSNsdsKBQ1xRv7BLgTh+PdwIm87Nf1wqXAtf72L848Hsfj1cI/Ers5qXDcf8afVP1iUVKm4JiEZECEonXpIFaF7s4COhmux8+SlMcI8XNfo5JwOWXM4E/+HCcC4EJPvbrHkwQLhsqtBtIZZga2269ZLsjImKXgmIRkcLj5gJuECZTaykptAv9tjRhShT5uQb2l8ANedz/OcAffezPs5h1xFL4dsJ9KaZ63N1oFJEioKBYRKTwvAV87WL7Y213wEdpCnNKaFsagJPxN1vuVeRnZPV0TC1ivxJGvYLJNN3g0/HyKYyyT/8Q9+ve3wdm2e6IiNiloFhEpMBE4jXLgDdc7OJISmcKdZriGilutgZTV3eaj8ecAFzg4f5OBu7Gv8DuXWAkpiZxMQhR2tmny4Afe7CfF51ydyJSwhQUi4gUpudcbDsIOMB2B3xSjCPFzZZiRv39zJr7J2C0B/s5AZPdOuJTu+c6x3Qzw0KCZTdMXW030sC/bXdEROxTUCwiUphewqyFy9WJtjsgnliIGS371KfjhYCJmBHXXB0NPABEfWrzYkxAPNen4xWyQkpKdxzuX0NzMctRRKTEKSgWESlMs4F3XGx/JNDbdid8UMwjxc0+A47BlOvyQwSTvfmwHLY9FJM9u8Kntq7GBMTv+nS8QlcoQXE5cLwH+3kxEq+ps90ZEbFPQbGISAFySjO5mUK9ObkFNX4oxjXA+fYJJkhY4tPxOmGC2/2z2KYSeATo7FMbG4EzgFd9Op74Zz9gZw/286TtjohIMCgoFhEpXM8AbhLEnGK7A63wcrSq2OoUt+Vt/E0k1RN4jMxK4uwNPAr08PF8nA885ePx/FbK2ad/6sE+vsBkIxcRUVAsIlLA3gNmuNj+IGAb250QT9VgAob1Ph1vM8xo2/ZtPGd34HGgr4/nYRxwl4/Hs6FUs0/3wpuycs9F4jVrbXdGRIJBQbGISIGKxGuSmNHiXHUGTrLdjzxrwt1oeiH6N3AaZvqwHwZiRmQHbuJnOzg/6+9j/38H/N7H44m/jsHcjHFrsu2OiEhwKCgWESlsT+Au6DsVk7RGissTmNJJft0Q2B4T/PZr8W/bAv/ElADzy0TgCh+PJ/4704N9zEFrzUWkBQXFIiKF7W3gfRfb7wwcbLsTeVSKI8XNHgDO8/F4e2CmSXcCBgD/wgTGfvkHcIGPxytGCdsNaMf38KbG+hOReI1fSwxEpAAoKBYRKWDOFOrHXe7mbNv9yKM0pZ3N+k7gIh+Ptz9mdPhp2l5n7LVngLMonaRq+RL098poTEkwN5KYzOkiIt9QUCwiUvgex9360aOAIbY7kSelPFLc7FbgSh+PdzCZZaT2yiuYTOqlVm82TGldx/XBZFd3axruaryLSBEqpQ9TEZFiNRN4w8X2nYBRtjuRJ6U+UtzsRudRbN7HJItbbbshlpRS9umT2XDNeq4eiMRrSv1GmYhsREGxiEiBi8Rr0sBDLndzBtDFdl/yIIWC4mZXAjfZboSH5gLHA1/ZbojkXRRvlnmswCShExHZgIJiEZHi8DSw3MX2g4ATbHciDzRSvKGxwO22G+GBRcBxmCzCUvwOwyRyc+ufkXjNQtudEZHgUVAsIlIEIvGaRbirWQxwPlBmuy8eS6E1xRu7ELjLdiNcWI4ZIXaTdV02LajvlfM92Eca+JvtjohIMCkoFhEpHve63H5v4CDbnfCYRoq/K40p1fSA7YbkYB1mbembthtSpIIYFA8DDvVgP9MwSdlERL5DQbGISPGoBd51uY//s90Jj2lN8aYlMeVtJttuSBYSwOnAC7YbEhBlFN/Mjk35JWZNsVt3R+I1KtklIpukoFhEpEhE4jUJ4D6Xuzkc2Md2XzykoLh1jcCZmPXoQZfCJFpSkqQNFXv26e3xJtfBlxTWDSAR8ZmCYhGR4vIPYJmL7SMU12ix1hS3rQ5T4/ffthvSjvOBv9tuhPjuF0BnD/ZzfyRe4yYRoYgUOQXFIiLFZSHwqMt9HAfsarsjHtFIcfua1+m+aLshrbgYmGi7EeK7QZjp8m6to7ATy4mIDxQUi4gUnzsx6y9zVQH8ynYnPKJEW5lZDZwI1NhuyEauA/5guxFixflAdw/280QkXjPLdmdEJNgUFIuIFJ/puJ8O+xNgR9sd8YCmT2duJabU0Wu2G+K4CbjediNKTFDeK/0xa8i96E8x1OUWkTxTUCwiUpxucbl9J2Cs7U54QKPE2VkOHAu8brkdf6Y4Xn/5FKJ4r+N+AfT2YD8vROI1Kt8lIu0q1g9TEZFSV4P7qbA/BXax3RGXmgjO6FehWAr8GHu1gP8GXGD7JBSAYs08PQA416N93WS7MyJSGBQUi4gUpxQQd7mPjsAVtjviktYU52Yp8CP8D4wfwgRE+p2VrkuAXh7s51WCmzxORAJGQbGISPF6DvfTYEdS2HWLtaY4d80jxlN9Ot5kYBSQtN1xsWYb4ByP9vX7SLxG730RyYiCYhGR4tUE/N7lPiLAtbY74oJGHN1ZjBkx/l+ej/M4pvxOo+0Oi1VXAF082M8bwDO2OyMihUNBsYhIcfsn7keLjwQOt92RHGlNsXuLgaMxgUY+PAWcBjTY7qhYvYm0B+Z14IXxGiUWkWwoKBYRKW4p4EYP9nMDZtS4EGm02L2lwDF4n5X6GeBUoM52BwtQPhJt2XyvXAeUe7Cf19EosYhkSUGxiEjxexb3maj3As7wqb1eXphrpNg7zcm33L6Wmj2LqYe9znbHxLoRmJsuXvhtJF7TZLtDIlJYFBSLiBS/NHA97oPNa4GePrRXF7TB1VzHeIrL/fwbBcRiRDAzUbwY+f4v5rUlIpIVBcUiIqXhv5j1xW4MBC613ZEsJdFIsddWAscD/8px+39hspqvtd0RCYQzgX092E8K+HUkXqPlEiKSNQXFIiKl49e4z+57IbCz7Y6IdWswge0DWW73qLOdRogFoA9wjUf7ejISr3nZdodEpDApKBYRKR3TgXtd7qMzMIH8JPnJB03Fzp96zCjfrRk+/15MUq162w2XwLgcMwPFrXrMFGwRkZwoKBYRKS2/xawLdeOHwCm2OyKB0ARcBFzZzvNuAc5CdYi9VIb313F+3kQaDlzg0b7uAt71se0iUmQUFIuIlJb5wM0e7OdGoK/tzmQgabsBJeJGYDTfnRadwqxD/xUqjeW1QpmtsSllwO+BCg/2tQQYb7tDIlLYFBSLiJSeW4FPXO5jICYbtUizvwGHAx84f/8COBGI226YBM6ZwEEe7SuOea2JiORMQbGISOlZgzfJbc4DDrbdmXYo87S/XgMqgdOB/YEnbDdIAmdL4Dce7etD4A7bHRKRwqegWESkNE3GfT3PMuCPQBfbnWmDpuz6byVwP7DAdkMkkMYDW3i0r6tQJnMR8YCCYhGR0pTGrPVc73I/uwBX2+5MG7SmWCQ4jsbMIvDCU85DRMQ1BcUiIqXrQ+APHuznYrxbH+g1jRRLsSrD+2Rb+Vxu0JvMy3e1Zw0wLo9tFZESo6BYRKS0jQdmutxHBPgz0MN2ZzZBdYqlWOUj+3Q+g+I4MNijfU3AfbJAEZFvKCgWESlta/GmXM72QLXtzmyCEm2J2DcSU6faC+/hTVk5EZFvKCgWEZH/AHd5sJ+zgVNtd2YjGikWsWtr4DaP9pUCLgLqbHdKRIqLgmIREQG4HG+yBd8KDLXdmRY0UixiTxS4E+jn0f4mAjW2OyUixUdBsYiIACzFJMxyqxdwL1DhYh9eju5qpFgkc/Ue7+8GYIRH+/oMU4JJRMRzEdsNEBGRwHgM+DvuS6bsC/wV+Jfz9yZMUqA0GwapKefR/O9pIIEJrL2ikWIpVmV4P7ixN6aMWQXfJvJqPk6a72a8Djn/1lJzm3bA2wzRlwDLPe6viAigoFhERDZUBcSAgS73c5rzsE1BsRSrfGSf/o3tTrXiXuAJ240QkeKl6dMiItLS18CFFE99X02fFilsn2Fu1omI5I2CYhER2djTwO22G+ERjRSLFK408Etgie2GiEhxU1AsIiKbcgXwru1GeEAjxSKF6za+zU0gIpI3CopFRGRT1gDnAOtsN8QljRSLFKb3gCttN0JESoOCYhERac10TP3iQqagWIpVhPwk2wqCOuBczM05EZG8U1AsIiJt+RPwiO1GuKCgWIpVMV/DXQVMtd0IESkdxfyBKiIi3jgfmGW7ETnSmmKRwvI0cLPtRohIaVFQLCIi7VkGnIGZ0lhoiqW0lEgpWACMsd0IESk9CopFRCQTbwJjbTciB0nbDRCRjCSAUcBXthsiIqVHQbGIiGTqDmCS7UZkSSPFIoXhKuC/thshIqVJQbGIiGTjV8ArthuRBY0US7Eqo3iyTz8M/N52I0SkdCkoFhGRbKzHrC9eYLshGdJIsRSrYgmI3wXOs90IESltCopFRCRb84BTMAFy0GmkWCS4lgCnA6tsN0RESpuCYhERycVrmFJNQaeRYpFgagJ+BnxouyEiIgqKRUQkV/cCv7bdiHZopFgkmC4HnrLdCBERUFAsIiLuXAfcZ7sRIlJQ/grEbTdCRKSZgmIREXEjjUmSM8V2Q1qhkWIpVhHbDcjRf4Bf2G6EiEhLCopFRMStOkzirfdsN2QTtKZYilUhXsN9iEms1WC7ISIiLRXqXUYREQmWJcDxmBHjwbYb04KCYilWab59fac2+n9a/D3dys/SGz1vPdDFeeTD55jPiMVWz5qIyCYoKBYREa/MBY4Dngc283jfScyIdDnmIj7VyqP5Yr/J+XOZ7ZMikifvAPvw7eu9OeBNsuF7oPn/m39Gi+c3v5cagJ2A+8lPULwKOBGYZfukiYhsioJiERHx0nvASOBfQDcP91sH/AqoAaKYi/pki0fz39MbPepsnxCRPFkNTPNoXzsCdwND8tDOBuBUYKpP50VEJGsKikVExGuvYNYYPwp08GifXYFrnf2+aruDIkXkIOBBYPM87LsJGA08Y7uTIiJtKcQkDSIiEnzPAGcAjR7ucyvM1OwzbHdOpEj8FHia/ATEYLJMP2i7kyIi7VFQLCIi+TIZM0rkZVmkTsC9wOW2OydS4MYBD5C/xFpVwF9sd1JEJBMKikVEJJ8eAH7Gt0mAvHIj8Fego+0OihSYjsAkYDwQytMxrgOqbXdURCRTCopFRCTf7gHG4H1gfDbwLLC17Q6KFIitMe+Zn+XxGL8BrrfdURGRbCgoFhERP/wVOBfvA+MDgf8CI2x3UCTgDgVexrxn8uXXwNW2Oyoiki0FxSIi4pe7MCNUTW53tJGtMYm9LrbdQZGAGospkzYoj8e4CpMhXkSk4CgoFhERP90NnIW3WakByoGbgPuAHrY7KRIQ/YCHgDjmPZIvVcBvbXdWRCRXCopFRMRvfwdOB+rzsO/TgReB3Wx3UsSyGGa69Ml5PEYTcAFKqiUiBU5BsYiI2PAIpkbqujzs+3uYwPhE250UsSAEXAo8B+yYx+PUA2cCd9jusIiIWwqKRUTElieBE4BVedh3H0yd5JvIXx1WkaDZGvgnMAHokMfjrAJ+gim5JiJS8BQUi4iITc8DPwaW5mn/FwMvAd+33VGRPDsFeB34YZ6PswA4CnjadodFRLyioFhERGyrwVxkf5Gn/e+FmU59HfkdPROxYXNMLfAHgC3yfKx3MKWdXrfdaRERLykoFhGRIJgGHA58lKf9d8CUi3kZ+IHtzop45ETgVcza3nx7DBMQf2q70yIiXlNQLCIiQTETc9H9ch6PsQ9m1Lga6Gm7wyI56o8ZHZ4MbOPD8a4HRgLLbHdcRCQfFBSLiEiQfIlZE3lfHo8RBS7BTAE93naHRbJ0JvAG/owOL8Mk1LoOSNvuuIhIvigoFhGRoFmPueC/HEjl8Tg7YKaEPgRsa7vTIu3YEZOx/R5gKx+O9w4wAlM+TUSkqCkoFhGRoBqPGcldlOfjnIwZefsVUGG70yIbqcDUHX4dk6ndD38HDgbetd15ERE/KCgWEZEgewo4CKjN83H6ADc7xzncdqdFHIdisrNPAHr4cLwGTBmzM4CVtjsvIuIXBcUiIhJ0nwCHAX/w4Vh7A89h1jRvb7vjUrK2wUyTfh6THM4PszCl0fx4n4mIBIqCYhERKQTNI1gjgYU+HO904H+YBEPKUi1+6QJcgXntnQmEfDru48CBwEu2T4CIiA0KikVEpJA8iqkz/KwPx+qOqW38JvAzoNx256VohYHTMK+13wK9fTpuArgMOAF/bjaJiASSgmIRESk0c4EfYZIP1flwvKHAJOBVTPBQZvsESFE5DDNC+3dgZx+P+zFm/fwE2ydARMQ2BcUiIlKIUkAcM+Vzqk/H3AszUv0aZnq1iBsx4BnMuuGYz8f+O1AJ/Nf2SRARCQIFxSIiUsimYgLjGzFTQf2wDyYR171A1PYJkILzA0y94f9iElv5aSlwNia79BLbJ0JEJCgUFIuISKGrA67ElK95x8fjngH80nbnpWAcjCkx9jKm3rBfSbSa/QcTkN9t+0SIiASNgmIRESkWNZgpob/Hv1Hj84DOtjsugVUBHIsJSF8EjsH/a691mPX3R2HWEYuIyEYUFIuISDFZC4wDRgDTfDje1phEXCIt9QUuBN4AnsDMYrDhFcyNojjQZPukiIgEVcR2A0RERPKgFpO86FLn0SlPx4lgAiARMMnYTsXU097SYjvWAb8BbsK/WRMiIgVLQbGIiBSrOuB64J9ANXBQHo6RxoxOS+nqCxyJqTN8EPavrV4ExgLvWm6HiEjBsP3BLSIikm9vY6ZTnwdcA2zm4b5XYOomS2kpB/YHTsKsE7Y5Ktzsa+DXwJ8xN2tERCRDCopFRKQUpIA7MHVhrwVG4U3232mYYCTfKoCBmFHJMmAlMB9Y7cOxxYgA38MkzvoRsIvtBjnSmPJg12FeEyIikiUFxSIiUkrmA6OBhzCjavu63N995HdUbi/gTOAQTFDcvDY6AXwFvA7cD/wrj20oZR0wgfAPMdmbd8f/UkpteRNzk+c/thsiIlLIFBSLiEgpegFTL/bnmGzVuUx/fQd4PE/t6wP8DjOivanv6iiwFfAT5/ECJqHYu/k7ZSWjH7APcDhmjfBOthu0CYuA8cBfgEbbjRERKXQKikVEpFQlgFuBx4BLgHOArhlum3S2qc9Du7YHHiW76bmHYhIsnQU8nafzVawqgB2BH2DWnu+Dt+vOvVQH/BVTi/sL240RESkWCopFRKTUfQlcDNwJ/B+mpE7nNp7fCFwA/DcPbRmAyZa9XQ7b9sJMCz8GEyBL6wYDe2PKdu2PCYqjthvVhjTm5s1v0WwAERHPKSgWERExPgLGAH/EBMZHAEOBLs7PVwCvYUbpXsnD8cOY6bC5BMTNOgF/A4YDi305a4WhP7AHZjT4B5hR+G62G5Wh/wATgJdsN0REpFgpKBYREdnQTOBKTPmmrTEjsGCCzHxm9z0Ok9DJra2AKzCj3qWoIzAIGIJJVBYDdsWs0y4kLwM3oSRqIiJ5p6BYRERk05qAOc4j38LAhR7u70zM6OIiH9puQ0dMkNsf2AKzDnswZpR9ELA532bqLjQvA39Aa8NFRHyjoFhERMS+HYD9PNxfD+AwTP3aQhHGJL3qiBmd7wX0xmSD3hIzAr6F8/+bOX3sbrvRHnoO+BPwrO2GiIiUGgXFIiIi9u0FlHu8z++T36C4D6Z2cnfMqHoCSDk/CwFlmORVFZh6v80Bbzdnmx6YoLcb3wa4zX92onBHerOxHngS+DPwqu3GiIiUKgXFIiIi9vXPwz4H5KmtlZjs2zFMYFzW4mfpFv8fytPxi8EXwMOYpGgzbTdGRKTUKSgWERGxLx/lgDrmYZ9VwI20fv2gQLhtb2JG7x8DlthujIiIGAqKRURE7KvLwz7XeLy/UzHlqCQ7izEZpO/HJNFKu9qbiIh4TkGxiIiIfXPzsE8vs2Z3x4wQS2YaMWuEH8EExF/abpCIiLROQbGIiIh9UzEju1093GeNh/s6DJNUS9r2DiZx1pPA+7YbIyIimVFQLCIiYt8C4AXgeA/3918P2xfz/YwUjg8wZZSeAqYBSdsNEhGR7CgoFhERCYZq4MdsmM05V7cCqz1s29Y2TkhAJYB3gecxwfBbzr+JiEiBUlAsIiISDG8AfwL+z4P93O5x20qhZnBblmOC3+eAKZjRYRERKRIKikVERILjcmAocFSO288BTgfqPW6X15msgy4BfAK8AryIKaWkZFkiIkVKQbGIiEhw1AMnAXcBP8ly27eBU/A263SzGcAxdk9NXqWA2cB0TCD8GvARmhYtIlISFBSLiIgEyzrgZEyirCpgm3aevxy4E/gdsCpPbXoSuAwI2T45HqnD3Dx4BzPd/H/Ax8B62w0TERH/KSgWEREJpomYOrc/wkyn3gHoh0nEtRwT1L0IPAHMy3NbpgKTMaPYhaYR+AoT9L6NCYTfw5yzBtuNExER+xQUi4iIBNcK4D7nUQ50B8LAWsyIsp/+D9gV2NH2SWnDKmARMAsz5ftD57EAcy5FRES+Q0GxiIhIYWgEllg8/iLgSGAScJjFdqzHlJv6EjPaOw8TAM/HjJ4vQdOgRUQkCwqKRUREJFPzMVO5TwHOBvYEunmw3yRmKnMdJqBdCSzFTHteCnzuPJYAC4GvMYFxk+0TIiIihU9BsYiIiGSjCfg78A9gF0wisI5AB6ACM827+RHGJOcKYwLfJCajc3PwW4eZBr4WU/ZpFSYgrnMejbY7KyIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIgXs/wFdGBMYBmcpKAAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAyMS0xMS0wNFQxMDo1MDo1NiswMDowMLpog8EAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMjEtMTEtMDRUMTA6NTA6NTYrMDA6MDDLNTt9AAAAAElFTkSuQmCC")' let ChangenowLogo = 'url("data:image/jpeg;base64,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");' let GuardarianLogo = 'url(data:image/png;base64,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);' -let ProviderImages = { ChangenowLogo, GuardarianLogo } +let ProviderImages = { + MajesticbankLogo, + ChangenowLogo, + GuardarianLogo, +} // export let ProviderImages = { ChangenowLogo, GuardarianLogo } export { ProviderImages as default } diff --git a/packages/mymonero-web-components/src/Components/Shared/ProviderCard.js b/packages/mymonero-web-components/src/Components/Shared/ProviderCard.js index f0e39d2b..132d8ca8 100644 --- a/packages/mymonero-web-components/src/Components/Shared/ProviderCard.js +++ b/packages/mymonero-web-components/src/Components/Shared/ProviderCard.js @@ -49,6 +49,13 @@ export class ExchangeServiceProviderCard extends LitElement { left: 6px; top: 16px; } + div.majesticbank-logo { + background-image: url("data:image/png;base64,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"); + width: 120px; + background-size: contain; + background-repeat: no-repeat; + background-position: center; + } div.changenow-logo { //background-image: url("/src/assets/img/ChangeNow120x69.jpg"); background-image: url("data:image/jpeg;base64,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"); @@ -82,7 +89,7 @@ export class ExchangeServiceProviderCard extends LitElement { max-width: 100% !important; margin-left: 10px !important; } - .changenow-logo, .guardarian-logo { + .majesticbank-logo, .changenow-logo, .guardarian-logo { width: 100% !important; height: 69px !important; background-position: top !important; @@ -182,8 +189,15 @@ export class ExchangeServiceProviderCard extends LitElement { } render() { + // Previously the provider-card had the following attributes: + // @click=${this.handleClickEvent} ontouchstart=${this.handleClickEvent} + // This was in addition to the event listeners in createRenderRoot + // However, the event listeners in createRenderRoot should be sufficient + // Since there was no clear reason for the doubling of event listeners they were removed + // The previous solution had the unfortunate side effect of causing the event to fire twice which created two instances of the same things + // This in turn resulted in duplicate API calls being made later on return html` -
+