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"));
}
