public PriceLockResult GetPriceLock(Guid priceLockId)
{
var result = new PriceLockResult();
using (X42DbContext dbContext = new X42DbContext(databaseSettings.ConnectionString))
{
var priceLock = dbContext.PriceLocks.Where(p => p.PriceLockId == priceLockId).FirstOrDefault();
if (priceLock != null)
{
result.DestinationAddress = priceLock.DestinationAddress;
result.DestinationAmount = priceLock.DestinationAmount;
result.FeeAddress = priceLock.FeeAddress;
result.FeeAmount = priceLock.FeeAmount;
result.RequestAmount = priceLock.RequestAmount;
result.RequestAmountPair = priceLock.RequestAmountPair;
result.PriceLockId = priceLock.PriceLockId.ToString();
result.PriceLockSignature = priceLock.PriceLockSignature;
result.Status = priceLock.Status;
result.PayeeSignature = priceLock.PayeeSignature;
result.TransactionId = priceLock.TransactionId;
result.ExpireBlock = priceLock.ExpireBlock;
result.SignAddress = priceLock.SignAddress;
result.Success = true;
}
else
{
result.ResultMessage = "Pricelock not found.";
result.Success = false;
}
}
return(result);
}
public async Task <IActionResult> UpdatePriceLock([FromBody] PriceLockResult priceLockData)
{
xServer.Stats.IncrementPublicRequest();
if (xServer.Stats.TierLevel == ServerNode.Tier.TierLevel.Three)
{
var priceLockResult = await priceFeature.UpdatePriceLock(priceLockData);
return(Json(priceLockResult));
}
else
{
return(ErrorHelpers.BuildErrorResponse(HttpStatusCode.BadRequest, "Tier 3 requirement not meet", "The node you requested is not a tier 3 node."));
}
}
public async Task <bool> UpdatePriceLock(PriceLockResult priceLockData)
{
bool result = false;
if (Guid.TryParse(priceLockData.PriceLockId, out Guid validPriceLockId))
{
// Create price lock if it doesn't exist.
var priceLock = networkFeatures.GetPriceLockData(validPriceLockId);
if (priceLock == null)
{
var priceLockCreateRequest = new CreatePriceLockRequest()
{
DestinationAddress = priceLockData.DestinationAddress,
ExpireBlock = priceLockData.ExpireBlock,
RequestAmount = priceLockData.RequestAmount,
RequestAmountPair = priceLockData.RequestAmountPair
};
var createResult = await CreatePriceLock(priceLockCreateRequest, validPriceLockId.ToString());
if (!createResult.Success)
{
return(false);
}
}
// Update payment information.
if (!string.IsNullOrEmpty(priceLockData.TransactionId) && !string.IsNullOrEmpty(priceLockData.PayeeSignature))
{
var paymentSubmit = new SubmitPaymentRequest()
{
PayeeSignature = priceLockData.PayeeSignature,
PriceLockId = priceLockData.PriceLockId,
TransactionId = priceLockData.TransactionId
};
var submitPaymentResult = await SubmitPayment(paymentSubmit);
if (!submitPaymentResult.Success)
{
result = true;
}
}
}
return(result);
}
/// <inheritdoc />
public PriceLockResult CreatePriceLock(CreatePriceLockRequest priceLockRequest)
{
var result = new PriceLockResult();
var t3Nodes = this.xServerPeerList.GetPeers().Where(n => n.Tier == (int)TierLevel.Three).OrderBy(n => n.ResponseTime);
foreach (var t3Node in t3Nodes)
{
string xServerURL = Utils.GetServerUrl(t3Node.NetworkProtocol, t3Node.NetworkAddress, t3Node.NetworkPort);
var client = new RestClient(xServerURL);
client.UseNewtonsoftJson();
var createPriceLockRequest = new RestRequest("/createpricelock", Method.POST);
var request = JsonConvert.SerializeObject(priceLockRequest);
createPriceLockRequest.AddParameter("application/json; charset=utf-8", request, ParameterType.RequestBody);
createPriceLockRequest.RequestFormat = DataFormat.Json;
var createPLResult = client.Execute <PriceLockResult>(createPriceLockRequest);
if (createPLResult.StatusCode == HttpStatusCode.OK)
{
result = createPLResult.Data;
if (result.Success)
{
return(result);
}
}
else
{
var errorResponse = JsonConvert.DeserializeObject <ErrorResponse>(createPLResult.Content);
if (errorResponse != null)
{
result.ResultMessage = errorResponse.errors[0].message;
}
else
{
result.ResultMessage = "Failed to access xServer";
}
result.Success = false;
}
}
if (t3Nodes.Count() == 0)
{
result.ResultMessage = "Not connected to any tier 3 servers";
}
return(result);
}
public async Task <PriceLockResult> CreatePriceLock(CreatePriceLockRequest priceLockRequest, string validPriceLockId = "")
{
var result = new PriceLockResult();
var fiatPair = FiatPairs.Where(f => (int)f.Currency == priceLockRequest.RequestAmountPair).FirstOrDefault();
if (fiatPair != null)
{
var averagePrice = fiatPair.GetPrice();
if (averagePrice != -1)
{
var price = Math.Round(priceLockRequest.RequestAmount / averagePrice, 8).Normalize();
var fee = Math.Round(price * priceLockFeePercent / 100, 8).Normalize();
var feeAddress = networkFeatures.GetMyFeeAddress();
var signAddress = networkFeatures.GetMySignAddress();
if (price < 42000000)
{
var expirationBlock = Convert.ToInt32(networkFeatures.BestBlockHeight + Convert.ToInt32(priceLockRequest.ExpireBlock));
if (!string.IsNullOrEmpty(validPriceLockId))
{
expirationBlock = Convert.ToInt32(priceLockRequest.ExpireBlock);
}
using (X42DbContext dbContext = new X42DbContext(databaseSettings.ConnectionString))
{
var newPriceLock = new PriceLockData()
{
DestinationAddress = priceLockRequest.DestinationAddress,
DestinationAmount = price,
FeeAmount = fee,
SignAddress = signAddress,
FeeAddress = feeAddress,
ExpireBlock = expirationBlock,
RequestAmount = priceLockRequest.RequestAmount,
RequestAmountPair = priceLockRequest.RequestAmountPair,
Status = (int)Status.New
};
if (!string.IsNullOrEmpty(validPriceLockId))
{
newPriceLock.PriceLockId = new Guid(validPriceLockId);
}
var newPriceLockRecord = dbContext.Add(newPriceLock);
if (newPriceLockRecord.State == EntityState.Added)
{
string signature = await networkFeatures.SignPriceLock($"{newPriceLock.PriceLockId}{newPriceLock.DestinationAddress}{newPriceLock.DestinationAmount}{newPriceLock.FeeAddress}{newPriceLock.FeeAmount}");
if (!string.IsNullOrEmpty(signature))
{
newPriceLock.PriceLockSignature = signature;
dbContext.SaveChanges();
result.DestinationAddress = newPriceLock.DestinationAddress;
result.DestinationAmount = newPriceLock.DestinationAmount;
result.FeeAddress = newPriceLock.FeeAddress;
result.SignAddress = newPriceLock.SignAddress;
result.FeeAmount = newPriceLock.FeeAmount;
result.RequestAmount = newPriceLock.RequestAmount;
result.RequestAmountPair = newPriceLock.RequestAmountPair;
result.PriceLockId = newPriceLock.PriceLockId.ToString();
result.PriceLockSignature = newPriceLock.PriceLockSignature;
result.ExpireBlock = newPriceLock.ExpireBlock;
result.Status = (int)Status.New;
result.Success = true;
List <ServerNodeData> tier3Nodes = dbContext.ServerNodes.Where(s => s.Active && s.Tier == (int)TierLevel.Three).ToList();
await networkFeatures.RelayPriceLock(newPriceLock, tier3Nodes, networkCancellationTokenSource.Token);
}
else
{
result.ResultMessage = "Problem with node, Failed to sign price lock.";
result.Success = false;
}
}
}
}
else
{
result.ResultMessage = "Price not valid, max cap exceeded.";
result.Success = false;
}
}
else
{
result.ResultMessage = "Node could not create price lock because insufficient price data.";
result.Success = false;
}
}
else
{
result.ResultMessage = "The supplied pair does not exist.";
result.Success = false;
}
return(result);
}
