/// <summary>
/// Look up balances for a list of accounts.
/// </summary>
/// <param name="accountIds">a list of account ids</param>
/// <param name="keyLevel">the key level</param>
/// <returns>a list of balances</returns>
public Task <IList <Balance> > GetBalances(IList <string> accountIds, Level keyLevel)
{
var request = new GetBalancesRequest
{
AccountId = { accountIds }
};
return(gateway(authenticateOnBehalfOf(keyLevel)).GetBalancesAsync(request)
.ToTask(response =>
{
IList <Balance> balances = new List <Balance>();
foreach (GetBalanceResponse getBalanceResponse in response.Response)
{
switch (getBalanceResponse.Status)
{
case RequestStatus.SuccessfulRequest:
balances.Add(getBalanceResponse.Balance);
break;
case RequestStatus.MoreSignaturesNeeded:
throw new StepUpRequiredException("Balance step up required.");
default:
throw new RequestException(getBalanceResponse.Status);
}
}
return balances;
}));
}
public async Task<float> Balance(string accountId)
{
var request = new GetBalancesRequest { Ids = { accountId } };
var repsonse = await accountsReadClient.GetBalancesAsync(request, HttpContext.CreateHeadersWithFlowId());
var balance = repsonse.Balances.Single();
return balance.Balance;
}
public async Task <APIResult <long[]> > GetBalances(IEnumerable <string> addresses, long threshold)
{
GetBalancesRequest getBalancesRequest = new GetBalancesRequest(addresses.ToArray(), threshold);
var response = await genericWebClient.RequestAsync <GetBalancesResponse>(getBalancesRequest);
return(response?.RePackage(r => r.Balances));
}
public override Task <GetBalancesResponse> GetBalances(GetBalancesRequest request, ServerCallContext context)
{
var balances = request.Ids.Select(id => accountsRepository.Get(id))
.Where(account => account != null)
.Select(account => new AccountBalance {
Id = account.Id, UserId = account.UserId, Balance = account.Balance
});
return(Task.FromResult(new GetBalancesResponse {
Balances = { balances }
}));
}
public async Task <long[]> GetBalances(IEnumerable <string> addresses, long threshold)
{
GetBalancesRequest getBalancesRequest = new GetBalancesRequest(addresses.ToArray(), threshold);
var response = await genericClient.RequestAsync <GetBalancesResponse>(getBalancesRequest);
if (response == null)
{
throw new NullReferenceException(nameof(response));
}
return(response.Balances);
}
/// <summary>
///
/// </summary>
/// <param name="threshold">The confirmation threshold, should be set to 100.</param>
/// <param name="addresses"></param>
/// <param name="tips"></param>
/// <returns></returns>
public GetBalancesResponse GetBalances(long threshold, List <string> addresses, List <string> tips)
{
List <string> addressesWithoutChecksum = new List <string>();
foreach (var address in addresses)
{
addressesWithoutChecksum.Add(address.RemoveChecksum());
}
GetBalancesRequest getBalancesRequest = new GetBalancesRequest(threshold, addressesWithoutChecksum, tips);
return(Request <GetBalancesRequest, GetBalancesResponse>(getBalancesRequest));
}
/// <summary>
/// Look up balances for a list of accounts.
/// </summary>
/// <param name="accountIds">a list of account ids</param>
/// <param name="keyLevel">the key level</param>
/// <returns>a list of balances</returns>
public Task <IList <Balance> > GetBalances(IList <string> accountIds, Level keyLevel)
{
var request = new GetBalancesRequest
{
AccountId = { accountIds }
};
return(gateway(authenticationContext(keyLevel)).GetBalancesAsync(request)
.ToTask(response => (IList <Balance>)response.Response
.Where(res => res.Status.Equals(RequestStatus.SuccessfulRequest))
.Select(res => res.Balance)
.ToList()));
}
public async Task <GetBalancesResponse> GetBalancesAsync(GetBalancesRequest request)
{
try
{
var balance = await _balanceCache.GetBalancesAsync();
return(balance);
}
catch (Exception ex)
{
_logger.LogError(ex, "Cannot get FTX balance");
throw;
}
}
public override async Task <GetDataToProcessResponse> Get(GetDataToProcessRequest request, ServerCallContext context)
{
var paymentsAndLoansRequest = new GetPartRequest {
Part = request.Part, TotalParts = request.TotalParts, Timestamp = request.Timestamp
};
var paymentsAndLoans = await paymentsClient.GetPartAsync(paymentsAndLoansRequest, context.RequestHeaders.SelectCustom());
var paymentAccounts = paymentsAndLoans.Payments.Select(p => p.AccountId).Distinct();
var accountsRequest = new GetBalancesRequest {
Ids = { paymentAccounts }
};
var balances = await accountsClient.GetBalancesAsync(accountsRequest, context.RequestHeaders.SelectCustom());
return(new GetDataToProcessResponse
{
Payments = { paymentsAndLoans.Payments },
Loans = { paymentsAndLoans.Loans },
Balances = { balances.Balances }
});
}
public GetBalancesResponse GetBalances(GetBalancesRequest request, IAuthContext authContext)
{
var balanceRepo = _unitOfWork.GetRepository <Balance>();
var balances = balanceRepo.GetList(x => x.AccountId.ToString() == request.AccountId);
GetBalancesResponse response = new GetBalancesResponse();
response.Items = new List <GetBalancesResponseItem>();
foreach (Balance blc in balances)
{
response.Items.Add(new GetBalancesResponseItem()
{
Amount = blc.Amount,
BalanceType = BalanceType.GetInstance(blc.BalanceType).Text,
Currency = CurrencyType.GetInstance(blc.CurrencyType).Text
});
}
return(response);
}
public async Task<BalanceDTO[]> Balance(string[] ids)
{
var request = new GetBalancesRequest { Ids = { ids } };
var response = await accountsReadClient.GetBalancesAsync(request, HttpContext.CreateHeadersWithFlowId());
return response.Balances.Select(b => mapper.Map<BalanceDTO>(b)).ToArray();
}
public ActionResult <GetBalancesResponse> GetBalances([FromQuery] GetBalancesRequest request)
{
GetBalancesResponse response = _accountDataService.GetBalances(request, _authContext);
return(Ok(response));
}
public Task <GetBalancesResponse> GetBalancesAsync(GetBalancesRequest request)
{
throw new NotImplementedException();
}
