public async void GetSendAmount_Valid_Test() { //Arrange string address = "NPvfpRCmDNcJjCZvDuAB9QsFC32gVThWdh"; var addr = NBitcoin.BitcoinAddress.Create(address, NeblioTransactionHelpers.Network); var txinfo = new GetTransactionInfoResponse() { Vin = new List <Vin>() { new Vin() { Value = 10000, Addr = address } }, Vout = new List <Vout>() { new Vout() { Value = 5000, ScriptPubKey = new ScriptPubKey() { Hex = addr.ScriptPubKey.ToHex() } } } }; var amount = NeblioTransactionHelpers.GetSendAmount(txinfo, address); //Assert Assert.Equal(0.00005, amount); }
public override async Task <string> SendCapitulationRequest(GameTypes type, string address, string password = "") { if (!Players.ContainsKey(address)) { return(await Task.FromResult("Player address is not in the list of players!")); } try { var dto = new ChessGameDto() { GameId = Id.ToString(), GameState = string.Empty, Type = GameDtoTypes.ChessGame, LastGameRecordTxId = string.Empty, CapitulationRequest = true, }; dto.Players = new Dictionary <string, ChessPlayer>(); if (Players.TryGetValue(Player1Address, out var pl1)) { pl1.FigureType = FigureTypes.White; } if (Players.TryGetValue(Player1Address, out var pl2)) { pl2.FigureType = FigureTypes.Black; } foreach (var pl in Players) { dto.Players.TryAdd(pl.Key, pl.Value); } var moveString = JsonConvert.SerializeObject(dto); var tkData = new SendTokenTxData() { Amount = 1, Symbol = TokenSymbol, SenderAddress = Player1Address, ReceiverAddress = Player2Address, Id = TokenId }; tkData.Metadata.TryAdd("GameId", Id.ToString()); tkData.Metadata.TryAdd("GameData", moveString); tkData.Password = password; var res = await NeblioTransactionHelpers.SendNTP1TokenAPI(tkData, 30000); return(await Task.FromResult(res)); } catch (Exception ex) { log.Error("Chess Game - Cannot write move!", ex); return(await Task.FromResult("ERROR")); } }
/// <summary> /// Load Utxos for the address /// </summary> /// <returns></returns> public async Task LoadUtxos() { //Utxos.Clear(); var ux = await NeblioTransactionHelpers.GetAddressUtxosObjects(Address); // add new ones foreach (var u in ux) { var utx = new NeblioBuilderUtxo(u); await utx.LoadInfo(); if (!Utxos.TryGetValue(u.Txid, out var ut)) { Utxos.TryAdd(utx.Utxo.Txid + ":" + utx.Utxo.Index.ToString(), utx); } } // remove old ones if (ux.Count > Utxos.Count) { foreach (var u in Utxos) { if (!ux.Contains(u.Value.Utxo)) { Utxos.TryRemove(u.Key, out var ur); } } } }
public async Task LoadPrivateKeyCorrectTest() { var secret = NeblioTransactionHelpers.IsPrivateKeyValid(FakeDataGenerator.DefaultDto.AliceKeystr); Assert.NotNull(secret); Assert.Equal(FakeDataGenerator.DefaultDto.AliceKeystr, secret.ToString()); }
/// <summary> /// Find and parse origin data /// </summary> /// <param name="lastmetadata"></param> /// <returns></returns> public override async Task ParseOriginData(IDictionary <string, string> lastmetadata) { var nftData = await NFTHelpers.LoadNFTOriginData(Utxo, true); if (nftData != null) { ParseCommon(nftData.NFTMetadata); ParsePrice(lastmetadata); await ParseDogeftInfo(lastmetadata); ParseSoldInfo(lastmetadata); SourceTxId = nftData.SourceTxId; NFTOriginTxId = nftData.NFTOriginTxId; ParseSpecific(nftData.NFTMetadata); Used = nftData.Used; AddUsedTags(); MintAuthorAddress = await NeblioTransactionHelpers.GetTransactionSender(NFTOriginTxId); IsLoaded = true; } }
public void GetNeblioTransaction_PasswordNotFilled_Error_Test() { //Arrange string address = "NPvfpRCmDNcJjCZvDuAB9QsFC32gVThWdh"; GetAddressInfoResponse addressObject = Common.FakeDataGenerator.GetAddressWithNeblUtxos(address, 10, 1000000); string password = ""; SendTxData sendTxData = new SendTxData() { ReceiverAddress = address, SenderAddress = address, Amount = 100, CustomMessage = "test", Password = password }; string Key = "A1eqrHg6TNBF8IGRhAsOHaLykDRRb56oF65J+DssDC9gThelreGQSubhvl3O7ZvHJ168W/mfzRlSItzMcdRaJw=="; var AccountKey = new EncryptionKey(Key) { IsEncrypted = true }; string message = "Cannot send token transaction. Password is not filled and key is encrypted or unlock account!"; var exception = Assert.Throws <Exception>(() => NeblioTransactionHelpers.GetNeblioTransactionObject(sendTxData, AccountKey, addressObject.Utxos)); Assert.Equal(message, exception.Message); }
public async void ValidateOneTokenNFTUtxo_Valid_Test() { var address = "NPvfpRCmDNcJjCZvDuAB9QsFC32gVThWdh"; var tokenId = "La58e9EeXUMx41uyfqk6kgVWAQq9yBs44nuQW8"; var transactionId = string.Empty; int index = 1; int amount = 1; GetAddressInfoResponse addressObject = Common.FakeDataGenerator.GetAddressWithNeblUtxos(address, 10, 1000000); var tuNFT = Common.FakeDataGenerator.GetFakeNeblioTokenUtxo(address, tokenId, randomIndex:false, index: index, amount:amount); addressObject.Utxos.Add(tuNFT); transactionId = tuNFT.Txid; var tu = Common.FakeDataGenerator.GetFakeNeblioTokenUtxo(address, tokenId, randomIndex: false, index: index, amount: 100); addressObject.Utxos.Add(tu); addressObject.Utxos = addressObject.Utxos.OrderBy(u => u.Blockheight).Reverse().ToList(); var u = addressObject.Utxos.FirstOrDefault(); var result = await NeblioTransactionHelpers.ValidateOneTokenNFTUtxo(address, tokenId, transactionId, index, addressObject, (double)u.Blockheight); Assert.Equal(index, result); }
/// <summary> /// Load info about the Utxo /// </summary> /// <returns></returns> /// <exception cref="Exception"></exception> public async Task LoadInfo() { if (string.IsNullOrEmpty(Utxo.Txid)) { throw new Exception("Cannot load Info. Utxo txid is empty."); } TokenInfo.Clear(); TotalTokens = 0; if (Utxo.Tokens.Count > 0) { foreach (var tok in Utxo.Tokens) { var ti = await NeblioTransactionHelpers.GetTokenMetadata(tok.TokenId); if (ti != null) { TokenInfo.Add(ti); TotalTokens += (int)tok.Amount; } } } TxInfo = await NeblioTransactionHelpers.GetTransactionInfo(Utxo.Txid); }
public void SendNeblioTransaction_CannotSignTransaction_Error_Test() { //Arrange var res = Common.FakeDataGenerator.GetKeyAndAddress(); string address = res.Item1.ToString(); string key = res.Item2.ToString(); var AccountKey = new EncryptionKey(key); // to load to the API which are requested during sign procedure - wrong not spendable coins GetAddressInfoResponse addressObject = Common.FakeDataGenerator.GetAddressWithNeblUtxos(address, 10, 1000000); // to load to the Send tx command as input utxos - fake actual spendable utxos on the address GetAddressInfoResponse addressObject1 = Common.FakeDataGenerator.GetAddressWithNeblUtxos(address, 10, 1000000); SendTxData sendTxData = new SendTxData() { ReceiverAddress = address, SenderAddress = address, Amount = 100, CustomMessage = "test", Password = "" }; var k = NeblioTransactionHelpers.GetAddressAndKey(AccountKey); var key1 = k.Item2; string message = "Exception during signing tx"; var transaction = NeblioTransactionHelpers.GetNeblioTransactionObject(sendTxData, AccountKey, addressObject1.Utxos); var exception = Assert.ThrowsAsync <Exception>(async() => await NeblioTransactionHelpers.SignAndBroadcastTransaction(transaction, key1)); Assert.Contains(message, exception.Result.Message); }
public void SendNeblioTransaction_CorrectInputsInTx_Test() { //Arrange var res = Common.FakeDataGenerator.GetKeyAndAddress(); string address = res.Item1.ToString(); string key = res.Item2.ToString(); var AccountKey = new EncryptionKey(key); GetAddressInfoResponse addressObject = Common.FakeDataGenerator.GetAddressWithNeblUtxos(address, 10, Convert.ToInt32(1 * NeblioTransactionHelpers.FromSatToMainRatio)); SendTxData sendTxData = new SendTxData() { ReceiverAddress = address, SenderAddress = address, Amount = 1, CustomMessage = "test", Password = "" }; foreach (var u in addressObject.Utxos) { u.Index = 2; } var transaction = NeblioTransactionHelpers.GetNeblioTransactionObject(sendTxData, AccountKey, addressObject.Utxos); Assert.Equal(10, transaction.Inputs.Count); Assert.Equal(2, (int)transaction.Inputs[0].PrevOut.N); Assert.Equal(NBitcoin.uint256.Parse(addressObject.Utxos.FirstOrDefault().Txid), transaction.Inputs[0].PrevOut.Hash); }
public async Task <TxDetails> LoadTxDetails(string txid, NeblioAccount account) { var tinfo = await NeblioTransactionHelpers.GetTransactionInfo(txid); string sender = await NeblioTransactionHelpers.GetTransactionSender(txid, tinfo); bool fromAnotherAccount = true; bool fromSubAccount = true; if (sender == account.Address) { sender = "Main Account"; fromAnotherAccount = false; fromSubAccount = false; } else if (account.SubAccounts.TryGetValue(sender, out var sacc)) { if (!string.IsNullOrEmpty(sacc.Name)) { sender = sacc.Name; } else { sender = sacc.BookmarkFromAccount.Name; } fromAnotherAccount = false; fromSubAccount = true; } string rec = await NeblioTransactionHelpers.GetTransactionReceiver(txid, tinfo); string receiver = string.Empty; var recbkm = account.IsInTheBookmarks(rec); if (rec == account.Address) { receiver = "Main Account"; } else if (recbkm.Item1) { receiver = recbkm.Item2.Name; } if (string.IsNullOrEmpty(receiver)) { receiver = NeblioTransactionHelpers.ShortenAddress(rec); } var time = TimeHelpers.UnixTimestampToDateTime((double)tinfo.Blocktime); return(new TxDetails() { FromAnotherAccount = fromAnotherAccount, FromSubAccount = fromSubAccount, Info = tinfo, Receiver = receiver, Sender = sender, Time = time, }); }
public void SendNeblioTransaction_Data_Null_Test() { string message = "Data cannot be null!"; var exception = Assert.Throws <Exception>(() => NeblioTransactionHelpers.GetNeblioTransactionObject(null, null, new List <Utxos>())); Assert.Equal(message, exception.Message); }
public void SendNeblioTransaction_Key_Null_Test() { SendTxData txData = new SendTxData(); string message = "Account cannot be null!"; var exception = Assert.Throws <Exception>(() => NeblioTransactionHelpers.GetNeblioTransactionObject(txData, null, new List <Utxos>())); Assert.Equal(message, exception.Message); }
public void ValidateNeblioAddress_Valid_Test() { string address = "NPvfpRCmDNcJjCZvDuAB9QsFC32gVThWdh"; var result = NeblioTransactionHelpers.ValidateNeblioAddress(address); Assert.Equal(address, result); }
public void IsEnoughConfirmationsForSend_Error_Test() { int confirmations = 1; var result = NeblioTransactionHelpers.IsEnoughConfirmationsForSend(confirmations); Assert.Equal(confirmations.ToString(), result); }
public void IsEnoughConfirmationsForSend_Valid_Test() { int confirmations = 10; var result = NeblioTransactionHelpers.IsEnoughConfirmationsForSend(confirmations); Assert.Contains(">", result); }
public void GetAddressFromPrivateKey_InValid_Test() { string privateKey = "TondMadekiw2kRcyeQsRtm1oQCucN8yU9rstqy2rtrW6y2JDRe2222222"; var result = NeblioTransactionHelpers.GetAddressFromPrivateKey(privateKey); Assert.Empty(result); }
public void CalculateFee_Valid_Test() { double fee = NeblioTransactionHelpers.CalcFee(2, 2, "Test", false); double expectedFee = 10000; //Assert Assert.Equal(expectedFee, fee, 15); }
public void GetAddressFromPrivateKey_Valid_Test() { string privateKey = "TondMadekiw2kRcyeQsRtm1oQCucN8yU9rstqy2rtrW6y2JDRe29"; string address = "NPvfpRCmDNcJjCZvDuAB9QsFC32gVThWdh"; var result = NeblioTransactionHelpers.GetAddressFromPrivateKey(privateKey); Assert.Equal(address, result); }
/// <summary> /// Public constructor which loads the NBitcoin objects /// </summary> public CryptographyTestDto() { AliceSecret ??= NeblioTransactionHelpers.IsPrivateKeyValid(AliceKeystr); AliceBitcoinAddress ??= AliceSecret.PubKey.GetAddress(ScriptPubKeyType.Legacy, NeblioTransactionHelpers.Network); BobSecret ??= NeblioTransactionHelpers.IsPrivateKeyValid(BobKeystr); BobBitcoinAddress ??= BobSecret.PubKey.GetAddress(ScriptPubKeyType.Legacy, NeblioTransactionHelpers.Network); BobAddress ??= BobBitcoinAddress.ToString(); }
public async Task GetPartner() { var rec = await NeblioTransactionHelpers.GetTransactionSender(Utxo, TxDetails); if (!string.IsNullOrEmpty(rec)) { Partner = rec; } }
public void CalculateFee_MoreThan4kb_Test() { //Arrange string message = "Cannot send transaction bigger than 4kB on Neblio network!"; //Assert + Action var exception = Assert.Throws <Exception>(() => NeblioTransactionHelpers.CalcFee(100, 20, "Test custom message", false)); Assert.Equal(message, exception.Message); }
public void SendNeblioTransaction_InvalidAddress_Test() { SendTxData txData = new SendTxData(); EncryptionKey encryptionKey = new EncryptionKey("Test"); string message = "Cannot send transaction. cannot create receiver address!"; var exception = Assert.Throws <Exception>(() => NeblioTransactionHelpers.GetNeblioTransactionObject(txData, encryptionKey, new List <Utxos>())); Assert.Equal(message, exception.Message); }
public async Task GetNeblioAddressFromKeyCorrectTest() { var encryptionKey = new EncryptionKey(FakeDataGenerator.DefaultDto.AliceKeystr); var address = NeblioTransactionHelpers.GetAddressAndKey(encryptionKey, ""); Assert.NotNull(address.Item1); Assert.NotNull(address.Item2); Assert.Equal(FakeDataGenerator.DefaultDto.AliceKeystr, address.Item2.ToString()); Assert.Equal(FakeDataGenerator.DefaultDto.AliceAddress, address.Item1.ToString()); }
public void Privatekey_Valid_Test() { string privateKey = "TondMadekiw2kRcyeQsRtm1oQCucN8yU9rstqy2rtrW6y2JDRe29"; var key2 = NeblioTransactionHelpers.IsPrivateKeyValid(privateKey); //Assert Assert.NotNull(key2); Assert.Equal(key2.ToWif(), privateKey); }
public async Task <NewTransactionDTO> LoadInfoFromAPI() { if (string.IsNullOrEmpty(WalletName)) { return(null); } if (string.IsNullOrEmpty(Address)) { return(null); } if (string.IsNullOrEmpty(TxId)) { return(null); } try { var txd = await NeblioTransactionHelpers.TransactionInfoAsync(null, TransactionTypes.Neblio, TxId, Address); if (txd != null) { var dto = new NewTransactionDTO(); dto.AccountAddress = Address; dto.WalletName = WalletName; dto.Type = TransactionTypes.Neblio; dto.TxId = TxId; dto.TransactionDetails = txd; VinTokens = dto.TransactionDetails.VinTokens; VoutTokens = dto.TransactionDetails.VoutTokens; Amount = dto.TransactionDetails.Amount; Confirmations = dto.TransactionDetails.Confirmations; Direction = dto.TransactionDetails.Direction; From = dto.TransactionDetails.From; To = dto.TransactionDetails.To; TimeStamp = dto.TransactionDetails.TimeStamp; Metadata = dto.TransactionDetails.Metadata; if (dto.TransactionDetails != null) { DetailsLoaded?.Invoke(this, dto); } return(dto); } } catch (Exception ex) { attempts--; //log.Error("Cannot load tx details: ", ex); } return(null); }
/// <summary> /// this function will decrypt the NFT if it is possile /// It needs the owner Private Key to create shared password which the combination of the sender public key. /// </summary> /// <param name="secret">Owner Private Key</param> /// <param name="decryptEvenOnSameAddress">Set true when you have preset the partner address manually - for example encryption on same address. </param> /// <returns>true if success</returns> public async Task <bool> Decrypt(NBitcoin.BitcoinSecret secret, bool decryptEvenOnSameAddress = false) { if (runningDecryption) { return(false); } if (Decrypted) { return(false); } if (string.IsNullOrEmpty(Partner)) { return(false);//throw new Exception("Cannot decrypt without loaded Partner address."); } var add = secret.PubKey.GetAddress(NBitcoin.ScriptPubKeyType.Legacy, NeblioTransactionHelpers.Network); if (Partner == add.ToString() && !decryptEvenOnSameAddress) { IsReceivedMessage = false; Partner = await NeblioTransactionHelpers.GetTransactionReceiver(Utxo); if (string.IsNullOrEmpty(Partner)) { return(false);//throw new Exception("Cannot decrypt without loaded Partner address."); } } else { IsReceivedMessage = true; } runningDecryption = true; if (await LoadSharedKeyForEncrypt(secret)) { Description = await DecryptProperty(Description, secret, "", Partner, sharedkey : SharedKey); Name = await DecryptProperty(Name, secret, "", Partner, sharedkey : SharedKey); Text = await DecryptProperty(Text, secret, "", Partner, sharedkey : SharedKey); ImageLink = await DecryptProperty(ImageLink, secret, "", Partner, sharedkey : SharedKey); Link = await DecryptProperty(Link, secret, "", Partner, sharedkey : SharedKey); } else { Console.WriteLine("Cannot decrypt NFT. Shared key not found."); } Decrypted = true; runningDecryption = false; return(true); }
public async Task LoadTokensFromTokenAccounts(List <NeblioQTWalletTokenAccountDetails> tokacc) { Tokens.Clear(); foreach (var t in tokacc) { var tdetails = await NeblioTransactionHelpers.TokenMetadataAsync(TokenTypes.NTP1, t.TokenId, string.Empty); tdetails.ActualBalance = t.Balance; Tokens.Add(t.TokenId, tdetails); } }
public async void GetAddressNeblUtxo_Valid_Test() { string address = "NPvfpRCmDNcJjCZvDuAB9QsFC32gVThWdh"; double amount = 0.015; GetAddressInfoResponse addressObject = Common.FakeDataGenerator.GetAddressWithNeblUtxos(address, 10, 1000000); var u = addressObject.Utxos.FirstOrDefault(); //ACT var Utxos = await NeblioTransactionHelpers.GetAddressNeblUtxo(address, 0.0001, amount, addressObject, (double)u.Blockheight); //Assert Assert.Equal(2, Utxos.Count); }
public override async Task <string> GetDetails() { var tok = await NeblioTransactionHelpers.TokenMetadataAsync(Type, Id, string.Empty); ActualBalance = tok.ActualBalance; MaxSupply = tok.MaxSupply; Symbol = tok.Symbol; Name = tok.Name; IssuerName = tok.IssuerName; Metadata = tok.Metadata; ImageUrl = tok.ImageUrl; MetadataAvailable = tok.MetadataAvailable; return(await Task.FromResult("OK")); }