private async Task DepositDemoAssets(ClientWalletEntity wallet)
{
try
{
var asset = await _marketDataService.GetDefaultBaseAsset(wallet.Client.TenantId);
var assets = await _marketDataService.GetAssetsByTenant(wallet.Client.TenantId);
var eur = assets.FirstOrDefault(x => x.Symbol == "EUR");
if (asset != null)
{
await _cashInOutProcessor.ChangeBalance(wallet,
asset,
10000,
"Deposit demo amount");
}
if (eur != null)
{
await _cashInOutProcessor.ChangeBalance(wallet,
eur,
10000,
"Deposit demo amount");
}
}
catch (Exception ex)
{
_logger.LogError(ex, $"Cannot register demo deposit: {ex.Message}");
}
}
public async Task <ClientWalletEntity> RegisterOrGetDefaultWallets(ClientIdentity client)
{
var existWallet = await _walletsWriter.TryGetAsync(ClientWalletEntity.GetPartitionKey(client.TenantId), ClientWalletEntity.GetRowKey(client.ClientId));
if (existWallet != null)
{
return(existWallet);
}
bool result;
do
{
var walletId = GenerateWalletId();
var entity = ClientWalletEntity.Generate(client.TenantId, client.ClientId);
entity.WalletId = walletId;
entity.Type = TradingWalletType.Trading;
entity.Client = client;
var indexById = ClientWalletIndexByIdEntity.Generate(entity.Client.TenantId, walletId, entity.Client.ClientId);
result = await _walletsByIdWriter.TryInsertAsync(indexById);
if (result)
{
await _walletsWriter.InsertOrReplaceAsync(entity);
return(entity);
}
_logger.LogInformation("Cannot insert new wallet with id={WalletId}. ClientId={clientId}, TenantId={TenamtId}", entity.WalletId, entity.Client.TenantId, entity.Client.ClientId);
} while (true);
}
public async Task <ClientWalletList> GetWalletsByClient(JetClientIdentity clientId)
{
_logger.LogInformation("Request wallets for Broker/Brand/Client: {brokerId}/{clientId}",
clientId.BrokerId, clientId.ClientId);
clientId.BrokerId.AddToActivityAsTag("brokerId");
clientId.ClientId.AddToActivityAsTag("clientId");
_logger.LogInformation("Request to get wallets. clientId: {clientText}", JsonSerializer.Serialize(clientId));
using var activity = MyTelemetry.StartActivity($"Use DB context {DatabaseContext.Schema}")?.AddTag("db-schema", DatabaseContext.Schema);
await using var ctx = new DatabaseContext(_dbContextOptionsBuilder.Options);
var list = await ctx.ClientWallet.Where(e => e.BrokerId == clientId.BrokerId && e.ClientId == clientId.ClientId)
.ToListAsync();
if (!list.Any())
{
using var _ = MyTelemetry.StartActivity($"Create a new wallet");
var wallet = new ClientWallet()
{
IsDefault = true,
IsInternal = false,
EnableEarnProgram = true,
Name = "spot",
WalletId = GenerateDefaultWalletId(clientId.ClientId),
CreatedAt = DateTime.UtcNow,
BaseAsset = Program.Settings.BaseAssetSymbol,
EnableUseTestNet = Program.Settings.EnableUseTestNetByDefault
};
wallet.WalletId.AddToActivityAsTag("walletId");
var entity = new ClientWalletEntity(clientId.BrokerId, clientId.ClientId, wallet);
await ctx.UpsetAsync(new [] { entity });
list.Add(entity);
_logger.LogInformation("Created default wallet. Wallet: {walletJson}", JsonSerializer.Serialize(entity));
}
foreach (var clientWalletEntity in list.Where(e => string.IsNullOrWhiteSpace(e.BaseAsset)))
{
clientWalletEntity.BaseAsset = Program.Settings.BaseAssetSymbol;
}
await UpdateCache(clientId.ClientId, clientId.BrokerId, list);
return(new ClientWalletList()
{
Wallets = list.Select(e => new ClientWallet()
{
IsDefault = e.IsDefault, Name = e.Name,
WalletId = e.WalletId, CreatedAt = e.CreatedAt, BaseAsset = e.BaseAsset,
EnableUseTestNet = e.EnableUseTestNet, IsInternal = e.IsInternal, EnableEarnProgram = e.EnableEarnProgram
}).ToList()
});
}
public async Task ChangeBalance(ClientWalletEntity wallet,
Asset asset,
decimal amount,
string comment)
{
var operationId = Guid.NewGuid().ToString("N");
var request = new CashInOutOperation
{
BrokerId = wallet.Client.TenantId,
AccountId = (ulong)wallet.Client.ClientId,
WalletId = (ulong)wallet.WalletId,
AssetId = asset.Symbol,
Description = comment,
Volume = amount.ToString(CultureInfo.InvariantCulture),
Id = operationId
};
_logger.LogInformation($"CashInRequest: {request.ToJson()}");
var response = await _matchingEngineClient.CashOperations.CashInOutAsync(request);
_logger.LogInformation(
"ME operations {MeOperation}, Id: {OperationId}. Status: {MeStatus}, Reason: {MeReason}; BrokerId: {TenantId}; AccountId: {AccountId}; WalletId: {WalletId}; Asset: {AssetSymbol}; Volume: {Volume}",
"CashInOut",
operationId,
response.Status.ToString(),
response.StatusReason,
wallet.Client.TenantId,
(ulong)wallet.Client.ClientId,
(ulong)wallet.WalletId,
asset.Symbol,
amount);
if (response.Status != Status.Ok)
{
throw new MatchingEngineException(response.Status.ToString(),
response.StatusReason,
"CashInOutAsync",
"CashOperations",
request,
response);
}
}
public async Task <CreateWalletResponse> CreateWalletAsync(CreateWalletRequest request)
{
using var _ = MyTelemetry.StartActivity($"Create a new wallet");
request.Name.AddToActivityAsTag("wallet-name");
request.ClientId.ClientId.AddToActivityAsTag("clientId");
request.ClientId.BrokerId.AddToActivityAsTag("brokerId");
_logger.LogInformation("Request to create wallet. Request: {requestText}", JsonSerializer.Serialize(request));
if (string.IsNullOrEmpty(request.ClientId?.ClientId) ||
string.IsNullOrEmpty(request.ClientId?.BrokerId) ||
string.IsNullOrEmpty(request.Name) ||
string.IsNullOrWhiteSpace(request.BaseAsset))
{
_logger.LogError("Cannot create wallet. BadRequest.");
return(new CreateWalletResponse()
{
Success = false,
ErrorMessage = "Bad request"
});
}
var index = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
var wallet = new ClientWallet()
{
IsDefault = false,
IsInternal = false,
EnableEarnProgram = true,
Name = request.Name,
WalletId = $"{Program.Settings.WalletPrefix}{request.ClientId.ClientId}-{index}",
CreatedAt = DateTime.UtcNow,
BaseAsset = request.BaseAsset,
EnableUseTestNet = Program.Settings.EnableUseTestNetByDefault
};
wallet.WalletId.AddToActivityAsTag("walletId");
var entity = new ClientWalletEntity(request.ClientId.BrokerId, request.ClientId.ClientId, wallet);
await using var ctx = new DatabaseContext(_dbContextOptionsBuilder.Options);
await ctx.ClientWallet.AddAsync(entity);
await ctx.SaveChangesAsync();
var list = await ctx.ClientWallet
.Where(e => e.ClientId == request.ClientId.ClientId && e.BrokerId == request.ClientId.BrokerId)
.ToListAsync();
await UpdateCache(request.ClientId.ClientId, request.ClientId.BrokerId, list);
_logger.LogInformation("Wallet created. Wallet: {walletJson}", JsonSerializer.Serialize(entity));
return(new CreateWalletResponse()
{
Success = true,
Name = request.Name,
WalletId = wallet.WalletId,
CreatedAt = wallet.CreatedAt
});
}
