public async Task <IActionResult> GetBalances([FromQuery] int take, [FromQuery] string continuation)
{
if (take <= 0)
{
ModelState.AddModelError(nameof(take), "Must be greater than zero");
}
ModelState.IsValidContinuationToken(continuation);
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResponseFactory.Create(ModelState)));
}
var padedResult = await _balanceService.GetBalances(take, continuation);
return(Ok(PaginationResponse.From(padedResult.Continuation, padedResult.Items.Select(p => new WalletBalanceContract
{
Address = p.Address,
Balance = MoneyConversionHelper.ToContract(p.Balance, p.AssetId),
AssetId = p.AssetId,
Block = p.UpdatedAtBlockHeight
}).ToList().AsReadOnly())));
}
public async Task <IActionResult> BuildClaim([FromBody] BuildClaimTransactionRequest request)
{
if (request == null)
{
return(BadRequest(ErrorResponse.Create("Unable to deserialize request")));
}
var addressValid = _addressValidator.IsAddressValid(request.Address);
if (!addressValid)
{
return(BadRequest(ErrorResponse.Create("Invalid address")));
}
var built = await _transactionBuilder.BuildClaimTransactions(request.Address);
var aggregate = await _operationRepository.GetOrInsert(request.OperationId,
() => OperationAggregate.StartNew(request.OperationId,
fromAddress: request.Address,
toAddress: request.Address,
amount: built.availiableGas,
assetId: Constants.Assets.Gas.AssetId,
fee: 0,
includeFee: false));
if (aggregate.IsBroadcasted)
{
return(Conflict());
}
if (!built.tx.Claims.Any())
{
return(Accepted(new BuiltClaimTransactionResponse
{
ClaimedGas = MoneyConversionHelper.ToContract(built.availiableGas, Constants.Assets.Gas.AssetId),
AllGas = MoneyConversionHelper.ToContract(built.unclaimedGas, Constants.Assets.Gas.AssetId),
TransactionContext = TransactionSerializer.Serialize(built.tx, TransactionType.ClaimTransaction)
}));
}
return(Ok(new BuiltClaimTransactionResponse
{
ClaimedGas = MoneyConversionHelper.ToContract(built.availiableGas, Constants.Assets.Gas.AssetId),
AllGas = MoneyConversionHelper.ToContract(built.unclaimedGas, Constants.Assets.Gas.AssetId),
TransactionContext = TransactionSerializer.Serialize(built.tx, TransactionType.ClaimTransaction)
}));
}
public async Task <IActionResult> GetObservableSingleOperation(Guid operationId)
{
if (!ModelState.IsValid ||
!ModelState.IsValidOperationId(operationId))
{
return(BadRequest(ErrorResponseFactory.Create(ModelState)));
}
var result = await _observableOperationRepository.GetById(operationId);
if (result == null)
{
return(new StatusCodeResult((int)HttpStatusCode.NoContent));
}
BroadcastedTransactionState MapState(BroadcastStatus status)
{
switch (status)
{
case BroadcastStatus.Completed:
return(BroadcastedTransactionState.Completed);
case BroadcastStatus.Failed:
return(BroadcastedTransactionState.Failed);
case BroadcastStatus.InProgress:
return(BroadcastedTransactionState.InProgress);
default:
throw new InvalidCastException($"Unknown mapping from {status} ");
}
}
return(Ok(new BroadcastedSingleTransactionResponse
{
Amount = MoneyConversionHelper.ToContract(result.Amount, result.AssetId),
Fee = MoneyConversionHelper.ToContract(result.Fee, result.AssetId),
OperationId = result.OperationId,
Hash = result.TxHash,
Timestamp = result.Updated,
State = MapState(result.Status),
Block = result.UpdatedAtBlockHeight
}));
}
