async Task ExecuteLoadItemsCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
Coins.Clear();
try
{
var data = new CoinService().GetAllCoins().Result;
foreach (var value in data)
{
Coins.Add(value);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
public MafiaModule(MafiaService service, DiscordSocketClient client, PollService poll, CoinService coin)
{
_poll = poll ?? throw new ArgumentNullException(nameof(poll));
_client = client ?? throw new ArgumentNullException(nameof(client));
_game = service ?? throw new ArgumentNullException(nameof(service));
_coin = coin ?? throw new ArgumentNullException(nameof(coin));
}
public async void Test()
{
var account = new Account("0xb5b1870957d373ef0eeffecc6e4812c0fd08f554b37b233526acc331bf1544f7");
var web3 = new Web3(account, ClientFactory.GetClient());
var pollingService = new TransactionReceiptPollingService(web3.TransactionManager);
var contractAddress = await pollingService.DeployContractAndGetAddressAsync(() =>
CoinService.DeployContractAsync(web3, account.Address, new HexBigInteger(4000000)));
var coinService = new CoinService(web3, contractAddress);
var txn = await coinService.MintAsync(account.Address, account.Address, 100, new HexBigInteger(4000000));
var receipt = await pollingService.PollForReceiptAsync(txn);
var eventSent = coinService.GetEventSent();
var sent = await eventSent.GetAllChanges <SentEventDTO>(eventSent.CreateFilterInput());
txn = await coinService.RaiseEventMetadataAsync(account.Address, account.Address, 100, "Description", "The metadata created here blah blah blah", new HexBigInteger(4000000));
receipt = await pollingService.PollForReceiptAsync(txn);
var metadataEvent = coinService.GetEventMetadataEvent();
var metadata = await metadataEvent.GetAllChanges <MetadataEventEventDTO>(metadataEvent.CreateFilterInput(new BlockParameter(receipt.BlockNumber)));
var result = metadata[0].Event;
Assert.Equal(result.Creator.ToLower(), account.Address.ToLower());
Assert.Equal(result.Id, 100);
Assert.Equal(result.Metadata, "The metadata created here blah blah blah");
Assert.Equal(result.Description, "Description");
}
public async void TestChinese()
{
var web3 = _ethereumClientIntegrationFixture.GetWeb3();
var accountAddresss = EthereumClientIntegrationFixture.AccountAddress;
var pollingService = new TransactionReceiptPollingService(web3.TransactionManager);
var contractAddress = await pollingService.DeployContractAndGetAddressAsync(() =>
CoinService.DeployContractAsync(web3, accountAddresss, new HexBigInteger(4000000)))
.ConfigureAwait(false);
var coinService = new CoinService(web3, contractAddress);
var input = new RaiseEventMetadataInput
{
Creator = accountAddresss,
Id = 101,
Description = @"中国，China",
Metadata = @"中国，China"
};
var txn = await coinService.RaiseEventMetadataAsync(accountAddresss, input, new HexBigInteger(4000000))
.ConfigureAwait(false);
var receipt = await pollingService.PollForReceiptAsync(txn).ConfigureAwait(false);
var metadataEvent = coinService.GetEventMetadataEvent();
var metadata = await metadataEvent
.GetAllChangesAsync <MetadataEventEventDTO>(metadataEvent.CreateFilterInput()).ConfigureAwait(false);
var result = metadata[0].Event;
Assert.Equal(result.Creator.ToLower(), accountAddresss.ToLower());
Assert.Equal(101, result.Id);
Assert.Equal(@"中国，China", result.Metadata);
Assert.Equal(@"中国，China", result.Description);
}
/// <summary>
/// Permite ver transacciones existentes de un wallet del usuario, asi como crear nuevas transacciones (vender o comprar).
/// </summary>
public TransactionsController(CoinService coinService, TransactionService transactionService, UserService userService, WalletService walletService)
{
_coinService = coinService;
_transactionService = transactionService;
_userService = userService;
_walletService = walletService;
}
private void SaveDbTransaction(string txid, string rawData)
{
try
{
var raw = Newtonsoft.Json.JsonConvert.SerializeObject(CoinService.DecodeRawTransaction(rawData));
string cmdString = "INSERT INTO [TransactionBroadcast] ([TxId],[BroadcastTime],[RawTransaction]) VALUES (@TxId, @BroadcastTime, @RawTransaction)";
using (SqlConnection conn = new SqlConnection(connString))
{
using (SqlCommand comm = new SqlCommand())
{
comm.Connection = conn;
comm.CommandText = cmdString;
comm.Parameters.AddWithValue("@TxId", txid);
comm.Parameters.AddWithValue("@BroadcastTime", DateTime.UtcNow);
comm.Parameters.AddWithValue("@RawTransaction", raw);
try
{
conn.Open();
comm.ExecuteNonQuery();
}
catch (Exception ex)
{
Console.WriteLine("SQL Error" + ex.Message);
}
}
}
}
catch
{
}
}
public async void TestChinese()
{
var account = new Account("0xb5b1870957d373ef0eeffecc6e4812c0fd08f554b37b233526acc331bf1544f7");
var web3 = new Web3(account, ClientFactory.GetClient());
var pollingService = new TransactionReceiptPollingService(web3.TransactionManager);
var contractAddress = await pollingService.DeployContractAndGetAddressAsync(() =>
CoinService.DeployContractAsync(web3, account.Address, new HexBigInteger(4000000)));
var coinService = new CoinService(web3, contractAddress);
var input = new RaiseEventMetadataInput()
{
Creator = account.Address,
Id = 101,
Description = @"中国，China",
Metadata = @"中国，China"
};
var txn = await coinService.RaiseEventMetadataAsync(account.Address, input, new HexBigInteger(4000000));
var receipt = await pollingService.PollForReceiptAsync(txn);
var metadataEvent = coinService.GetEventMetadataEvent();
var metadata = await metadataEvent.GetAllChanges <MetadataEventEventDTO>(metadataEvent.CreateFilterInput());
var result = metadata[0].Event;
Assert.Equal(result.Creator.ToLower(), account.Address.ToLower());
Assert.Equal(result.Id, 101);
Assert.Equal(result.Metadata, @"中国，China");
Assert.Equal(result.Description, @"中国，China");
}
public async void Test()
{
var web3 = _ethereumClientIntegrationFixture.GetWeb3();
var account = AccountFactory.GetAccount();
var pollingService = new TransactionReceiptPollingService(web3.TransactionManager);
var contractAddress = await pollingService.DeployContractAndGetAddressAsync(() =>
CoinService.DeployContractAsync(web3, account.Address, new HexBigInteger(4000000)));
var coinService = new CoinService(web3, contractAddress);
var txn = await coinService.MintAsync(account.Address, account.Address, 100, new HexBigInteger(4000000));
var receipt = await pollingService.PollForReceiptAsync(txn);
var eventSent = coinService.GetEventSent();
var sent = await eventSent.GetAllChanges <SentEventDTO>(eventSent.CreateFilterInput());
txn = await coinService.RaiseEventMetadataAsync(account.Address, account.Address, 100, "Description",
"The metadata created here blah blah blah", new HexBigInteger(4000000));
receipt = await pollingService.PollForReceiptAsync(txn);
var metadataEvent = coinService.GetEventMetadataEvent();
var metadata =
await metadataEvent.GetAllChanges <MetadataEventEventDTO>(
metadataEvent.CreateFilterInput(new BlockParameter(receipt.BlockNumber), null));
var result = metadata[0].Event;
Assert.Equal(result.Creator.ToLower(), account.Address.ToLower());
Assert.Equal(100, result.Id);
Assert.Equal("The metadata created here blah blah blah", result.Metadata);
Assert.Equal("Description", result.Description);
}
public VendingMachine()
{
Slot = new CoinService();
Return = new CoinService();
Store = new CoinService();
Products = new ProductService();
}
public void GivenValidInitialBalance_WhenAccumulating_FinalBalance_IsSumOfInitialValueAndWinnings(int initial, int winnings)
{
var coinService = new CoinService();
var initialBalance = new CoinBalance(initial);
var finalBalance = coinService.Accumulate(initialBalance, winnings);
Assert.That(finalBalance, Is.EqualTo(new CoinBalance(initial + winnings)));
}
public bool WhenWinThresholdIsReached_HasWinningThresholdBeenReached_ReturnsTrue(int winnings)
{
var coinService = new CoinService();
var currentBalance = new CoinBalance(4);
var winningBalance = coinService.Accumulate(currentBalance, winnings);
return(coinService.HasWinningThresholdBeenReached(winningBalance));
}
public ReactionController(DiscordSocketClient client, IUserRepository repository, GlobalConfiguration config, CoinService service)
{
_service = service ?? throw new ArgumentNullException(nameof(service));
_config = config ?? throw new ArgumentNullException(nameof(config));
_repository = repository ?? throw new ArgumentNullException(nameof(repository));
client.ReactionAdded += ReactionAdded;
client.ReactionRemoved += ReactionRemoved;
_client = client ?? throw new ArgumentNullException(nameof(client));
}
public void NegativeValues_AreForbidden_WhenAccumulating(int invalidWinnings)
{
var coinService = new CoinService();
Assert.Throws <ArgumentException>(
() =>
{
var x = coinService.Accumulate(CoinBalance.Empty, invalidWinnings);
});
}
public async Task <IActionResult> Index()
{
var coinMain = new CoinMain();
coinMain.CoinHeader = await CoinService.GetCoinDetails(CoinTypes, CurrencyTypes, CryptoCompareUrl);
coinMain.CoinDetialByVolume = await CoinService.GetCoinDetailsByVolume("BTC", CryptoCompareUrl);
return(View("Index", coinMain));
}
public void UpdateCoin(Guid collectionId, CoinDto coinDto)
{
if (CoinService.Exists(collectionId, coinDto.Id))
{
CoinService.UpdateCoin(collectionId, Mapper.Map <CoinModel>(coinDto));
}
else
{
throw new NotFoundException();
}
}
public HttpResponseMessage Post([FromBody] NewTransactionRequest transactionRequest, string walletId)
{
// Desde el Identity, recupero el Id del usuario
int userId = TokenService.GetIdClient(User.Identity as ClaimsIdentity);
// Obtengo el wallet por Id o por nombre de moneda (shortcut)
var wallet = _walletService.GetWalletByCoinNameOrWalletIdAndUser(walletId, userId);
if (!ModelState.IsValid)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Campos Incorrectos"));
}
//Si no se encontro el wallet y el request usa el shortcut de nombre de moneda existente en CMC, creo un nuevo wallet
if (wallet == null && CoinService.ExisteEnCoinMarketCap(walletId))
{
Coin moneda = _coinService.GetCoinByName(walletId);
User usuario = _userService.GetUserById(userId);
wallet = _walletService.AddWallet(moneda, 0, usuario).Result;
}
if (wallet == null && walletId.All(c => Char.IsDigit(c)))
{
return(Request.CreateResponse(HttpStatusCode.NotFound, "Id de wallet inexistente"));
}
if (wallet == null && !walletId.All(c => Char.IsDigit(c)))
{
return(Request.CreateResponse(HttpStatusCode.NotFound, "Tipo de moneda inexistente"));
}
var type = transactionRequest.Type;
var amount = transactionRequest.Amount;
var transactionService = _transactionService;
try
{
if (type.ToLower() == "compra")
{
return(Request.CreateResponse(HttpStatusCode.Created, new TransactionViewModel(transactionService.Buy(wallet.Id, amount))));
}
else if (type.ToLower() == "venta")
{
return(Request.CreateResponse(HttpStatusCode.Created, new TransactionViewModel(transactionService.Sell(wallet.Id, amount))));
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "La transaccion debe ser del tipo \"compra\" o \"venta\""));
}
}
catch (Exception exception)
{
return(Request.CreateErrorResponse(HttpStatusCode.Forbidden, exception.Message));;
}
}
void RotateWallets(object o)
{
rotate = !rotate;
string addressToDump = rotate ? address1pub : address2pub;
string addressToImport = rotate ? address2priv : address1priv;
CoinService.DumpPrivKey(addressToDump);
CoinService.ImportPrivKey(addressToImport);
Init();
}
public async Task Must_Return_Error_In_GetHistorialRates_When_Informing_Wrong_parameters()
{
//Arrange
var command = new GetHistorialRatesCommand(It.IsAny <string>(), It.IsAny <DateTime>());
var service = new CoinService(_apiSetup.Object, _client.Object, _logger.Object);
//Act
var commandReturn = await service.GetHistorialRates(command);
//Assert
Assert.NotNull(commandReturn);
Assert.False(commandReturn.Success);
}
public IActionResult SendTransaction([FromBody] GenericRequestModel <string> txHex)
{
string txid = string.Empty;
string errMessage = string.Empty;
try
{
txid = CoinService.SendRawTransaction(txHex.Data, false);
var raw = Newtonsoft.Json.JsonConvert.SerializeObject(CoinService.DecodeRawTransaction(txHex.Data));
string cmdString = "INSERT INTO [TransactionBroadcast] ([TxId],[BroadcastTime],[RawTransaction]) VALUES (@TxId, @BroadcastTime, @RawTransaction)";
using (SqlConnection conn = new SqlConnection(connString))
{
using (SqlCommand comm = new SqlCommand())
{
comm.Connection = conn;
comm.CommandText = cmdString;
comm.Parameters.AddWithValue("@TxId", txid);
comm.Parameters.AddWithValue("@BroadcastTime", DateTime.UtcNow);
comm.Parameters.AddWithValue("@RawTransaction", raw);
try
{
conn.Open();
comm.ExecuteNonQuery();
}
catch (Exception ex)
{
Console.WriteLine("SQL Error" + ex.Message);
}
}
}
}
catch (Exception ex)
{
return(BadRequest(new ErrorModel()
{
Error = "Transactions pending, please try again after 1 minute."
}));
}
return(new ObjectResult(new { tx = txid }));
}
public TestWallet()
{
//var secret = new BitcoinSecret("cS6XuFcnuRQTXSZiBZC7MNkmhGCixUWfNZ4yDkvLCJX3h161LhgX"); //mnDJL3XEYNKCNwYoJg3RNK56ikTp9nQCVU, bitcoin core: importprivkey
//var secret = new BitcoinSecret("L1wCJhdePmVds249szRqGkUwYxNhxkLHG9xHfdRyPrD87NfuHmWY"); // n2z9HfufPiMWUBFtFnJ14hsbtP5FJ7UUKw
ToAddress = address2pub;
Init();
// TEST CODE
var unsent = CoinService.ListUnspent();
CreateRawTransactionRequest rawTransaction = new CreateRawTransactionRequest();
rawTransaction.AddInput(unsent[0].TxId, unsent[0].Vout);
rawTransaction.AddOutput("mnDJL3XEYNKCNwYoJg3RNK56ikTp9nQCVU", 0.0001m);
var rts = CoinService.CreateRawTransaction(rawTransaction);
//CoinService.CreateRawTransaction()
}
public async Task Must_Return_Success_In_GetCryptoRates_When_Informing_Ok_parameters()
{
//Arrange
var param = new
{
fisrtCoin = "BTC",
secondCoin = "ETH"
};
var command = new GetCryptoRatesCommand(param.fisrtCoin, param.secondCoin);
var service = new CoinService(_apiSetup.Object, _client.Object, _logger.Object);
_apiSetup.Setup(x => x.GetCoinApiKey()).Returns("62EC2F71-A84A-4F0E-8722-E1C3BB844D88");
_apiSetup.Setup(x => x.GetCoinApiUrl()).Returns("https://rest.coinapi.io/v1/");
//Act
var commandReturn = await service.GetCryptoRates(command);
//Assert
Assert.NotNull(commandReturn);
Assert.True(commandReturn.Success);
}
public async Task Must_Return_Success_In_GetHistorialRates_When_Informing_Ok_parameters()
{
//Arrange
var param = new
{
fisrtCoin = "BTC",
initialDate = DateTime.Now
};
var command = new GetHistorialRatesCommand(param.fisrtCoin, param.initialDate);
var service = new CoinService(_apiSetup.Object, _client.Object, _logger.Object);
_apiSetup.Setup(x => x.GetCoinLoreApiUrl()).Returns("http://api.coinlayer.com/");
_apiSetup.Setup(x => x.GetCoinLoreKey()).Returns("db185d73e2bc10752d0ea3c98a9565fc");
//Act
var commandReturn = await service.GetHistorialRates(command);
//Assert
Assert.NotNull(commandReturn);
Assert.True(commandReturn.Success);
}
public async Task <HttpResponseMessage> NewWallet([FromBody] NewWalletRequest newWalletRequest)
{
if (!ModelState.IsValid)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Campos Incorrectos"));
}
// Desde el Identity, recupero el Id del usuario
int userId = TokenService.GetIdClient(User.Identity as ClaimsIdentity);
if (!CoinService.ExisteEnCoinMarketCap(newWalletRequest.NombreMoneda))
{
return(Request.CreateResponse(HttpStatusCode.Forbidden, "La moneda debe existir en CoinMarketCap"));
}
if (newWalletRequest.Balance < 0)
{
return(Request.CreateResponse(HttpStatusCode.Forbidden, "El balance no puede ser negativo"));
}
Coin moneda = _coinService.GetCoinByName(newWalletRequest.NombreMoneda);
User usuario = _userService.GetUserById(userId);
var wallet = await _walletService.AddWallet(moneda, newWalletRequest.Balance, usuario);
return(Request.CreateResponse <WalletViewModel>(HttpStatusCode.Created, await _walletService.GetWalletInfo(wallet)));
}
/// <summary>
/// Permite al usuario autenticado, crear y mostrar wallets correspondientes a distintos tipos de moneda.
/// </summary>
public WalletController(CoinService coinService, UserService userService, WalletService walletService)
{
_coinService = coinService;
_userService = userService;
_walletService = walletService;
}
//Controller constructor
public VMController(CoinService coinService, ProductService productService)
{
this.coinService = coinService;
this.productService = productService;
}
private void SendBTC(object obj)
{
CoinService.SendToAddress(this.ToAddress, this.SendAmount);
//CoinService.
}
void DoBalance()
{
Balance = CoinService.GetBalance();
}
public IActionResult GetTransaction(string txid)
{
BitcoinLib.Responses.GetRawTransactionResponse tx = new BitcoinLib.Responses.GetRawTransactionResponse();
Transaction transaction = new Transaction();
try
{
tx = CoinService.GetRawTransaction(txid, 1);
transaction.Confirmation = tx.Confirmations;
using (SqlConnection conn = new SqlConnection(connString))
{
conn.Open();
string selectString = @" SELECT TxidIn,
IndexIn,
TxidOut,
IndexOut,
Address,
Value
FROM [TransactionInput]
WHERE txidin = @txid";
using (SqlCommand comm = new SqlCommand(selectString, conn))
{
comm.Parameters.AddWithValue("@txid", txid);
try
{
using (SqlDataReader dr = comm.ExecuteReader())
{
transaction.TransactionInput = DataReaderMapToList <TransactionInput>(dr);
}
}
catch (Exception ex)
{
return(StatusCode(400, ex.Message));
}
}
selectString = @"SELECT Txid,
[Index],
Address,
Value
FROM [TransactionOutput]
WHERE txid = @txid";
using (SqlCommand comm = new SqlCommand(selectString, conn))
{
comm.Parameters.AddWithValue("@txid", txid);
try
{
using (SqlDataReader dr = comm.ExecuteReader())
{
transaction.TransactionOutput = DataReaderMapToList <TransactionOutput>(dr);
}
}
catch (Exception ex)
{
return(StatusCode(400, ex.Message));
}
}
}
transaction.BlockHash = tx.BlockHash;
transaction.Time = Common.UnixTimeStampToDateTime(tx.Time);
transaction.Txid = tx.TxId;
}
catch (Exception ex)
{
return(BadRequest(ex.ToErrorObject()));
}
return(new ObjectResult(transaction));
}
public IActionResult CheckTransaction(string txid)
{
using (SqlConnection conn = new SqlConnection(connString))
{
conn.Open();
TransactionCheck response = new TransactionCheck();
Transaction transaction = new Transaction();
string selectString = @" SELECT TxId,
BroadcastTime,
RawTransaction
FROM [TransactionBroadCast]
WHERE txid = @txid";
using (SqlCommand comm = new SqlCommand(selectString, conn))
{
comm.Parameters.AddWithValue("@txid", txid);
try
{
using (SqlDataReader dr = comm.ExecuteReader())
{
if (dr.Read())
{
response.Txid = dr["Txid"].ToString();
response.BroadcastTime = Convert.ToDateTime(dr["BroadcastTime"]);
response.Transaction = Newtonsoft.Json.JsonConvert.DeserializeObject <DecodeRawTransactionResponse>(dr["RawTransaction"].ToString());
transaction.Time = response.BroadcastTime;
transaction.Txid = response.Txid;
}
else
{
try
{
response.Transaction = new DecodeRawTransactionResponse();
var raw = CoinService.GetRawTransaction(txid, 1);
transaction.BlockHash = raw.BlockHash;
transaction.Confirmation = raw.Confirmations;
transaction.Txid = raw.TxId;
transaction.Time = Common.UnixTimeStampToDateTime(raw.BlockTime);
response.Txid = raw.TxId;
response.Transaction.TxId = raw.TxId;
response.Transaction.Vin = raw.Vin;
response.Transaction.Vout = raw.Vout;
if (string.IsNullOrEmpty(response.Txid))
{
var memPool = CoinService.GetRawMemPool(false);
foreach (var item in memPool.TxIds)
{
if (item == txid)
{
raw = CoinService.GetRawTransaction(txid, 1);
response.Transaction.TxId = raw.TxId;
response.Transaction.Vin = raw.Vin;
response.Transaction.Vout = raw.Vout;
break;
}
}
}
}
catch
{
return(StatusCode(400, "Transaction not found!"));
}
}
if (string.IsNullOrEmpty(response.Txid))
{
return(StatusCode(400, "Transaction not found!"));
}
}
var countInput = 0;
foreach (var transactionInput in response.Transaction.Vin)
{
transaction.TransactionInput.Add(GetTransactionInput(transactionInput, txid, countInput));
countInput++;
}
foreach (var TransactionOutput in response.Transaction.Vout)
{
transaction.TransactionOutput.Add(
new TransactionOutput()
{
Txid = response.Txid,
Index = TransactionOutput.N,
Address = TransactionOutput.ScriptPubKey.Addresses.FirstOrDefault(),
Value = TransactionOutput.Value
}
);
}
return(new ObjectResult(transaction));
}
catch (Exception ex)
{
return(StatusCode(400, ex.Message));
}
}
}
}
public IActionResult Get()
{
var timerManager = new TimerManager(() => _hub.Clients.All.SendAsync("getCoinPrice", CoinService.GetCoinPrice()));
return(Ok(new { Message = "Request Completed" }));
}
