public override async Task Execute()
{
var currentState = await _state.GetAsync();
var state = currentState != null ? currentState.State : default;
var trace = await _job.TraceDepositsAsync(state, async assetId => await _assets.GetAsync(assetId));
var operationHashes = new HashSet <string>();
var deposits = new List <BlockchainAction>();
foreach (var action in trace.actions)
{
// to be able to enroll fake transfers properly
// we keep block number increased by one order of magnitude
action.BlockNumber *= 10;
// changes made by our operations are accounted by API service,
// so here we enroll external deposits only
if (operationHashes.Contains(action.TransactionHash))
{
continue;
}
else if (await _operations.GetOperationIndexAsync(action.TransactionHash) != null)
{
operationHashes.Add(action.TransactionHash);
}
else
{
deposits.Add(action);
}
}
// filter out actions with invalid Azure symbols
deposits = deposits
.Where(a =>
{
var containsInvalidSymbols =
!Validators.ValidateAzureKey(a.ActionId) ||
!Validators.ValidateAzureKey(a.Address) ||
!Validators.ValidateAzureKey(a.AssetId) ||
!Validators.ValidateAzureKey(a.TransactionHash);
if (containsInvalidSymbols)
{
_log.Warning("Invalid Azure symbols and/or length in action", context: a);
}
return(!containsInvalidSymbols);
})
.ToList();
await _depositWallets.EnrollIfObservedAsync(deposits);
_chaosKitty?.Meow($"{nameof(Execute)}_Enroll");
await _state.UpsertAsync(trace.state);
_chaosKitty?.Meow($"{nameof(Execute)}_UpdateState");
}
public async Task GetAssetbyID_Database_test(int id)
{
using var connection = Database_init();
var options = new DbContextOptionsBuilder <mmpproject2Context>().UseSqlite(connection).Options;
using var context = new mmpproject2Context(options);
var repo = new AssetRepository(options);
var asset = await repo.GetAsync(id);
var assetActual = context.Assets.Where(x => x.Id == id).Single();
Assert.Equal(asset.Id, assetActual.Id);
Assert.Equal(asset.Quantity, assetActual.Quantity);
}
public async Task <ActionResult> Transfer(TestingTransferRequest request)
{
var caps = _api.GetCapabilities();
if (!caps.IsTestingTransfersSupported.HasValue ||
!caps.IsTestingTransfersSupported.Value)
{
return(StatusCode(501));
}
var asset = await _assets.GetAsync(request.AssetId);
if (asset == null)
{
return(BadRequest(BlockchainErrorResponse.Create("Unknown asset")));
}
var amount = 0M;
try
{
amount = Conversions.CoinsFromContract(request.Amount, asset.Accuracy);
}
catch (ConversionException)
{
return(BadRequest(BlockchainErrorResponse.Create("Invalid amount format")));
}
if (amount < 0 || !_api.AddressIsValid(request.FromAddress) || !_api.AddressIsValid(request.ToAddress))
{
return(BadRequest(BlockchainErrorResponse.Create("Invalid address(es) and/or negative amount")));
}
var result = await _api.TestingTransfer(
request.FromAddress,
request.FromPrivateKey,
request.ToAddress,
asset,
amount);
return(Ok(result));
}
public async Task <ActionResult <PaginationResponse <WalletBalanceContract> > > Get(int take, string continuation)
{
if (take <= 0)
{
return(BadRequest(BlockchainErrorResponse.Create("'take' must be grater than zero")));
}
if (!Validators.ValidateAzureContinuation(continuation))
{
return(BadRequest(BlockchainErrorResponse.Create("'continuation' must be null or valid Azure continuation token")));
}
IEnumerable <DepositWalletBalanceEntity> balances;
if (_api.CanGetBalances)
{
// to be able to enroll fake transfers properly
// we keep block number increased by one order of magnitude
var lastConfirmedBlock = await _api.GetLastConfirmedBlockNumberAsync() * 10;
var depositWallets = await _depositWallets.GetWalletsAsync(take, continuation);
var addresses = depositWallets.items.Select(w => w.Address).ToArray();
continuation = depositWallets.continuation;
balances = (await _api.GetBalancesAsync(addresses, async assetId => await _assets.GetAsync(assetId)))
.Select(b => new DepositWalletBalanceEntity(b.Address, b.AssetId)
{
Amount = b.Amount,
BlockNumber = lastConfirmedBlock
});
}
else
{
(balances, continuation) =
await _depositWallets.GetBalanceAsync(take, continuation);
}
var result = new List <WalletBalanceContract>();
foreach (var balance in balances)
{
// blockchain may return unknown assets,
// filter out such items
var accuracy = (await _assets.GetAsync(balance.AssetId))?.Accuracy;
if (accuracy == null)
{
continue;
}
result.Add(new WalletBalanceContract
{
Address = balance.Address,
AssetId = balance.AssetId,
Balance = Conversions.CoinsToContract(balance.Amount, accuracy.Value),
Block = balance.BlockNumber
});
}
return(PaginationResponse.From(continuation, result));
}
