public async Task <ActionResult <PolicyQuoteViewModelGet> > GetPolicyQuote()
{
if (!IdentityProviderStore.GetUserAndIssuer(User, Request.Headers, out var identity))
{
return(Unauthorized("Incorrectly formatted token"));
}
logger.LogInformation($"Get PolicyQuote for user { ((identity == null) ? "/" : identity.ToString())} ...");
FeeQuote feeQuote = feeQuoteRepository.GetCurrentFeeQuoteByIdentity(identity);
if (feeQuote == null)
{
logger.LogInformation($"There are no active policyQuotes.");
return(NotFound());
}
var policyQuoteViewModelGet = new PolicyQuoteViewModelGet(feeQuote, callbackIPAddressesArray)
{
Timestamp = clock.UtcNow(),
};
return(await FillFeeQuoteViewModelWithInfo(policyQuoteViewModelGet));
}
public async Task <ActionResult <SubmitTransactionResponseViewModel> > SubmitTxsAsync(
SubmitTransactionViewModel[] data,
[FromQuery]
string defaultCallbackUrl,
[FromQuery]
string defaultCallbackToken,
[FromQuery]
string defaultCallbackEncryption,
[FromQuery]
bool defaultMerkleProof,
[FromQuery]
bool defaultDsCheck)
{
if (!IdentityProviderStore.GetUserAndIssuer(User, Request.Headers, out var identity))
{
return(Unauthorized("Incorrectly formatted token"));
}
var domainModel = data.Select(x =>
x.ToDomainModel(defaultCallbackUrl, defaultCallbackToken, defaultCallbackEncryption, defaultMerkleProof, defaultDsCheck)).ToArray();
var result =
new SubmitTransactionsResponseViewModel(
await mapi.SubmitTransactionsAsync(domainModel,
identity));
return(await SignIfRequiredAsync(result, result.MinerId));
}
public async Task <ActionResult <SubmitTransactionResponseViewModel> > SubmitTxsRawAsync(
[FromQuery] string callbackUrl,
[FromQuery] string callbackEncryption,
[FromQuery] string callbackToken,
[FromQuery] bool merkleProof,
[FromQuery] bool dsCheck
)
{
if (!IdentityProviderStore.GetUserAndIssuer(User, Request.Headers, out var identity))
{
return(Unauthorized("Incorrectly formatted token"));
}
// callbackUrl is validated as part of domainObject - no special validation here
byte[] data;
using (var ms = new MemoryStream())
{
await Request.Body.CopyToAsync(ms);
data = ms.ToArray();
}
byte[][] transactionAsBytes;
try
{
// This is not very efficient, since we will reparse bytes into NBitcoin.Transaction later again
transactionAsBytes = HelperTools.ParseTransactionsIntoBytes(data);
}
catch (Exception)
{
var problemDetail = ProblemDetailsFactory.CreateProblemDetails(HttpContext, (int)HttpStatusCode.BadRequest);
problemDetail.Title = "Unable to parse incoming stream of transactions";
return(BadRequest(problemDetail));
}
var request = transactionAsBytes.Select(
t =>
new SubmitTransaction
{
RawTx = t,
CallbackUrl = callbackUrl,
CallbackEncryption = callbackEncryption,
CallbackToken = callbackToken,
MerkleProof = merkleProof,
DsCheck = dsCheck
}).ToArray();
var result =
new SubmitTransactionsResponseViewModel(
await mapi.SubmitTransactionsAsync(request, identity));
return(await SignIfRequiredAsync(result, result.MinerId));
}
public async Task <ActionResult <SubmitTransactionResponseViewModel> > SubmitTxAsync(SubmitTransactionViewModel data)
{
if (!IdentityProviderStore.GetUserAndIssuer(User, Request.Headers, out var identity))
{
return(Unauthorized("Incorrectly formatted token"));
}
var domainModel = data.ToDomainModel(null, null, null, false, null, false);
var result =
new SubmitTransactionResponseViewModel(
await mapi.SubmitTransactionAsync(domainModel, identity));
return(await SignIfRequiredAsync(result, result.MinerId));
}
public async Task <ActionResult <QueryTransactionStatusResponseViewModel> > QueryTransactionStatus(string id)
{
if (!IdentityProviderStore.GetUserAndIssuer(User, Request.Headers, out _))
{
return(Unauthorized("Incorrectly formatted token"));
}
if (!uint256.TryParse(id, out _))
{
var problemDetail = ProblemDetailsFactory.CreateProblemDetails(HttpContext, (int)HttpStatusCode.BadRequest);
problemDetail.Title = "Invalid format of TransactionId";
return(BadRequest(problemDetail));
}
var result =
new QueryTransactionStatusResponseViewModel(
await mapi.QueryTransaction(id));
return(await SignIfRequiredAsync(result, result.MinerId));
}
public async Task <ActionResult <SubmitTransactionResponseViewModel> > SubmitTxsAsync(
SubmitTransactionViewModel[] data,
[FromQuery]
string defaultCallbackUrl,
[FromQuery]
string defaultCallbackToken,
[FromQuery]
string defaultCallbackEncryption,
[FromQuery]
bool defaultMerkleProof,
[FromQuery]
string defaultMerkleFormat,
[FromQuery]
bool defaultDsCheck)
{
if (!IdentityProviderStore.GetUserAndIssuer(User, Request.Headers, out var identity))
{
return(Unauthorized("Incorrectly formatted token"));
}
var domainModel = data.Select(x =>
x.ToDomainModel(defaultCallbackUrl, defaultCallbackToken, defaultCallbackEncryption, defaultMerkleProof, defaultMerkleFormat, defaultDsCheck)).ToArray();
SubmitTransactionsResponseViewModel result;
try
{
result =
new SubmitTransactionsResponseViewModel(
await mapi.SubmitTransactionsAsync(domainModel,
identity));
}
catch (BadRequestException ex)
{
logger.LogError($"Error while submiting transactions. {ex.Message}.");
var problemDetail = ProblemDetailsFactory.CreateProblemDetails(HttpContext, (int)HttpStatusCode.BadRequest);
problemDetail.Title = ex.Message;
return(BadRequest(problemDetail));
}
return(await SignIfRequiredAsync(result, result.MinerId));
}
public async Task <ActionResult <SubmitTransactionResponseViewModel> > SubmitTxRawAsync(
[FromQuery]
string callbackUrl,
[FromQuery]
string callbackToken,
[FromQuery]
string callbackEncryption,
[FromQuery]
bool merkleProof,
[FromQuery]
string merkleFormat,
[FromQuery]
bool dsCheck)
{
if (!IdentityProviderStore.GetUserAndIssuer(User, Request.Headers, out var identity))
{
return(Unauthorized("Incorrectly formatted token"));
}
byte[] data;
using (var ms = new MemoryStream())
{
await Request.Body.CopyToAsync(ms);
data = ms.ToArray();
}
var request = new SubmitTransaction
{
RawTx = data,
CallbackUrl = callbackUrl,
CallbackToken = callbackToken,
CallbackEncryption = callbackEncryption,
MerkleProof = merkleProof,
MerkleFormat = merkleFormat,
DsCheck = dsCheck
};
var result = new SubmitTransactionResponseViewModel(await mapi.SubmitTransactionAsync(request, identity));
return(await SignIfRequiredAsync(result, result.MinerId));
}
public async Task GetBySchemeAsync_should_filter_by_scheme_casing(DbContextOptions <ConfigurationDbContext> options)
{
using (var context = new ConfigurationDbContext(options))
{
var idp = new OidcProvider
{
Scheme = "SCHEME3", Type = "oidc"
};
context.IdentityProviders.Add(idp.ToEntity());
context.SaveChanges();
}
using (var context = new ConfigurationDbContext(options))
{
var store = new IdentityProviderStore(context, FakeLogger <IdentityProviderStore> .Create(), new NoneCancellationTokenProvider());
var item = await store.GetBySchemeAsync("scheme3");
item.Should().BeNull();
}
}
public async Task <ActionResult <FeeQuoteViewModelGet> > GetFeeQuote()
{
if (!IdentityProviderStore.GetUserAndIssuer(User, Request.Headers, out var identity))
{
return(Unauthorized("Incorrectly formatted token"));
}
logger.LogInformation($"Get FeeQuote for user { ((identity == null) ? "/" : identity.ToString() )} ...");
FeeQuote feeQuote = feeQuoteRepository.GetCurrentFeeQuoteByIdentity(identity);
if (feeQuote == null)
{
logger.LogInformation($"There are no active feeQuotes.");
return(NotFound());
}
var feeQuoteViewModelGet = new FeeQuoteViewModelGet(feeQuote)
{
Timestamp = clock.UtcNow(),
};
feeQuoteViewModelGet.ExpiryTime = feeQuoteViewModelGet.Timestamp.Add(TimeSpan.FromMinutes(quoteExpiryMinutes));
var info = blockChainInfo.GetInfo();
feeQuoteViewModelGet.MinerId = await minerId.GetCurrentMinerIdAsync();
feeQuoteViewModelGet.CurrentHighestBlockHash = info.BestBlockHash;
feeQuoteViewModelGet.CurrentHighestBlockHeight = info.BestBlockHeight;
logger.LogInformation($"Returning feeQuote with ExpiryTime: {feeQuoteViewModelGet.ExpiryTime}.");
return(await SignIfRequiredAsync(feeQuoteViewModelGet, feeQuoteViewModelGet.MinerId));
}
