public static async Task <(bool, string)> GetCode(string txid, EncryptionKey key)
{
var msg = CreateMessage(txid);
var signed = await ECDSAProvider.SignMessage(msg, key.GetEncryptedKey());
return(signed);
}
public static async Task <(bool, string)> GetCode(string txid, NBitcoin.BitcoinSecret key)
{
var msg = CreateMessage(txid);
var signed = await ECDSAProvider.SignMessage(msg, key);
return(signed);
}
/// <summary>
/// Create Sub Account Address and Private Key
/// The Account Private key is encrypted with use of main account private key
/// </summary>
/// <param name="mainSecret">Main Account Private Key</param>
/// <param name="name">Name of the Sub Account</param>
/// <returns></returns>
public async Task <(bool, string)> CreateAddress(BitcoinSecret mainSecret, string name)
{
if (!string.IsNullOrEmpty(Address))
{
return(false, "Account already contains address.");
}
try
{
Key privateKey = new Key(); // generate a random private key
PubKey publicKey = privateKey.PubKey;
BitcoinSecret privateKeyFromNetwork = privateKey.GetBitcoinSecret(NeblioTransactionHelpers.Network);
var address = publicKey.GetAddress(ScriptPubKeyType.Legacy, NeblioTransactionHelpers.Network);
Address = address.ToString();
Secret = privateKeyFromNetwork;
// todo load already encrypted key
AccountKey = new Security.EncryptionKey(privateKeyFromNetwork.ToString());
AccountKey.PublicKey = Address;
//ESKey = SymetricProvider.EncryptString(SecurityUtils.ComputeSha256Hash(mainSecret.PrivateKey.ToString()), privateKeyFromNetwork.ToString());
EKey = ECDSAProvider.EncryptStringWithPublicKey(privateKeyFromNetwork.ToString(), mainSecret.PubKey);// TODO: some preprocessor directive for run just in old version under .NETStandard2.1
//EKey = mainSecret.PubKey.Encrypt(privateKeyFromNetwork.ToString());// TODO: some preprocessor directive for run just in old version under .NETStandard2.1
Name = name;
return(true, Address);
}
catch (Exception ex)
{
//todo
return(false, ex.Message);
}
}
public async Task WrongSignatureTest()
{
var sign = await ECDSAProvider.VerifyMessage(FakeDataGenerator.DefaultDto.BasicMessage,
FakeDataGenerator.DefaultDto.AliceBasicMessageWrongSignature,
FakeDataGenerator.DefaultDto.AliceSecret.PubKey);
Assert.False(sign.Item1);
}
public async Task ECDSA_EmptyCipherFailTest()
{
string message = "Input parameters cannot be empty or null.";
var decryptedMessage = await ECDSAProvider.DecryptMessage("", FakeDataGenerator.DefaultDto.AliceSecret);
Assert.False(decryptedMessage.Item1);
Assert.Equal(message, decryptedMessage.Item2);
}
public async Task ECDSA_SharedSeceredEncryptionCorrectTest()
{
var sharedSecret = await ECDSAProvider.GetSharedSecret(FakeDataGenerator.DefaultDto.BobAddress,
FakeDataGenerator.DefaultDto.AliceSecret,
FakeDataGenerator.DefaultDto.BobSecret.PubKey);
Assert.True(sharedSecret.Item1);
Assert.Equal(FakeDataGenerator.DefaultDto.AliceBobEDCHSharedKey, sharedSecret.Item2);
}
public async Task ECDSA_SharedSeceredEncryptionEmptyKeyFailTest()
{
var sharedSecret = await ECDSAProvider.GetSharedSecret("", key : "",
FakeDataGenerator.DefaultDto.BobSecret.PubKey);
Assert.False(sharedSecret.Item1);
string message = "Input parameters cannot be empty or null.";
Assert.Equal(message, sharedSecret.Item2);
}
/*
* public static async Task<(bool,(OwnershipVerificationCodeDto,byte[]))> GetQRCode(string txid, EncryptionKey key)
* {
* var signature = await GetCode(txid, key);
* if (signature.Item1)
* {
* var dto = new OwnershipVerificationCodeDto();
* dto.TxId = txid;
* dto.Signature = signature.Item2;
* var dtos = JsonConvert.SerializeObject(dto);
* if (dtos != null)
* {
* QRCodeData qrCodeData = qrGenerator.CreateQrCode(dtos, QRCodeGenerator.ECCLevel.Q);
* var qrCode = new BitmapByteQRCode(qrCodeData);
* var g = qrCode.GetGraphic(20);
* return (true, (dto, g));
* }
* }
* return (false, (null, null));
* }
*/
public static async Task <OwnershipVerificationResult> VerifyOwner(OwnershipVerificationCodeDto dto)
{
var msg = CreateMessage(dto.TxId);
var res = await NFTHelpers.GetNFTWithOwner(dto.TxId);
if (res.Item1)
{
//var ownerpubkey = await NFTHelpers.GetPubKeyFromProfileNFTTx(res.Item2.Owner);
/*var ownerpubkey = await NFTHelpers.GetPubKeyFromLastFoundTx(res.Item2.Owner);
* if (!ownerpubkey.Item1)
* return new OwnershipVerificationResult()
* {
* Owner = res.Item2.Owner,
* Sender = res.Item2.Sender,
* NFT = res.Item2.NFT,
* Message = msg,
* VerifyResult = "Cannot get owner pubkey. He probably did not allow this function."
* };*/
var r = await ECDSAProvider.VerifyMessage(msg, dto.Signature, res.Item2.Owner);
if (r.Item1)
{
return(new OwnershipVerificationResult()
{
Owner = res.Item2.Owner,
Sender = res.Item2.Sender,
NFT = res.Item2.NFT,
Message = msg,
VerifyResult = "Verified. This is owner. Signature is valid."
});
}
else
{
if (r.Item2 != null)
{
return new OwnershipVerificationResult()
{
Owner = res.Item2.Owner,
Sender = res.Item2.Sender,
NFT = res.Item2.NFT,
Message = msg,
VerifyResult = "Not Owner of NFT or provided signature is no longer valid."
}
}
;
}
}
return(new OwnershipVerificationResult()
{
VerifyResult = "Not Valid input."
});
}
/// <summary>
/// Sign custom message with use of account Private Key
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public async Task <(bool, string)> SignMessage(string message)
{
if (IsLocked())
{
await InvokeAccountLockedEvent();
return(false, "Account is locked.");
}
var key = AccountKey.GetEncryptedKey();
return(await ECDSAProvider.SignMessage(message, Secret));
}
public async Task ECDSA_EncryptDecryptMessageCorrectTest()
{
var encryptedMessage = await ECDSAProvider.EncryptMessage(FakeDataGenerator.DefaultDto.BasicMessage,
FakeDataGenerator.DefaultDto.AliceSecret.PubKey);
Assert.True(encryptedMessage.Item1);
var decryptedMessage = await ECDSAProvider.DecryptMessage(encryptedMessage.Item2,
FakeDataGenerator.DefaultDto.AliceSecret);
Assert.True(decryptedMessage.Item1);
Assert.Equal(FakeDataGenerator.DefaultDto.BasicMessage, decryptedMessage.Item2);
}
private string DecryptEncryptedKey(BitcoinSecret mainSecret)
{
string key = string.Empty;
if (!string.IsNullOrEmpty(ESKey))
{
key = SymetricProvider.DecryptString(SecurityUtils.ComputeSha256Hash(mainSecret.PrivateKey.ToString()), ESKey);
}
else if (!string.IsNullOrEmpty(EKey))
{
key = ECDSAProvider.DecryptStringWithPrivateKey(EKey, mainSecret.PrivateKey); // TODO: some preprocessor directive for run just in old version under .NETStandard2.1
}
return(key);
}
public async Task CreateSignatureTest()
{
var sign = await ECDSAProvider.SignMessage(FakeDataGenerator.DefaultDto.BasicMessage,
FakeDataGenerator.DefaultDto.AliceSecret);
Assert.True(sign.Item1);
Assert.Equal(FakeDataGenerator.DefaultDto.AliceBasicMessageSignature, sign.Item2);
var signb = await ECDSAProvider.SignMessage(FakeDataGenerator.DefaultDto.BasicMessage,
FakeDataGenerator.DefaultDto.BobSecret);
Assert.True(signb.Item1);
Assert.Equal(FakeDataGenerator.DefaultDto.BobBasicMessageSignature, signb.Item2);
}
public async Task CorrectSignatureTest()
{
var alicever = await ECDSAProvider.VerifyMessage(FakeDataGenerator.DefaultDto.BasicMessage,
FakeDataGenerator.DefaultDto.AliceBasicMessageSignature,
FakeDataGenerator.DefaultDto.AliceSecret.PubKey);
Assert.True(alicever.Item1);
var bobver = await ECDSAProvider.VerifyMessage(FakeDataGenerator.DefaultDto.BasicMessage,
FakeDataGenerator.DefaultDto.BobBasicMessageSignature,
FakeDataGenerator.DefaultDto.BobSecret.PubKey);
Assert.True(bobver.Item1);
}
private async Task <bool> LoadSharedKeyForEncrypt(NBitcoin.BitcoinSecret secret)
{
if (string.IsNullOrEmpty(SharedKey))
{
var sharedkey = await ECDSAProvider.GetSharedSecret(Partner, secret);
if (sharedkey.Item1)
{
SharedKey = sharedkey.Item2;
return(true);
}
else
{
return(false);
}
}
else
{
return(true);
}
}
/// <summary>
/// Function will check if the requested action exists and if the signature match
/// </summary>
/// <param name="admin"></param>
/// <param name="signature"></param>
/// <param name="message"></param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public static async Task <IAdminAction> VerifyAdminAction(string admin, string signature, string message)
{
if (string.IsNullOrEmpty(admin) || string.IsNullOrEmpty(signature))
{
throw new Exception("You must fill the admin address and signature for this action.");
}
if (VEDLDataContext.AdminAddresses.Contains(admin))
{
if (VEDLDataContext.Accounts.TryGetValue(admin, out var acc))
{
if (VEDLDataContext.AdminActionsRequests.TryRemove(message, out var areq))
{
var res = await ECDSAProvider.VerifyMessage(message, signature, acc.Secret.PubKey);
if (res.Item1)
{
return(areq);
}
}
}
}
return(null);
}
public static async Task <VerifyNFTTicketDto> LoadNFTTicketToVerify(OwnershipVerificationCodeDto dto, string eventId, List <string> allowedMintingAddresses)
{
if (string.IsNullOrEmpty(dto.TxId))
{
throw new Exception("Utxo id must be provided.");
}
if (string.IsNullOrEmpty(dto.Signature))
{
throw new Exception("Signature id must be provided.");
}
if (string.IsNullOrEmpty(eventId))
{
throw new Exception("Event Id must be provided.");
}
if (allowedMintingAddresses == null || allowedMintingAddresses.Count == 0)
{
throw new Exception("You must provide list of allowed minting addresses.");
}
var msg = CreateMessage(dto.TxId); // create verification message ASAP because of time relation
var txi = await NeblioTransactionHelpers.GetTransactionInfo(dto.TxId);
var Time = TimeHelpers.UnixTimestampToDateTime((double)txi.Blocktime);
bool isYesterdayOrOlder = DateTime.Today - Time.Date >= TimeSpan.FromDays(1);
if (isYesterdayOrOlder)
{
throw new Exception("This ticket was used earlier than today. Or it is not used at all.");
}
var metadata = await NeblioTransactionHelpers.GetTransactionMetadata(NFTHelpers.TokenId, dto.TxId);
if (metadata.TryGetValue("NFT", out var isnft))
{
if (isnft != "true")
{
throw new Exception("This is not NFT");
}
}
if (metadata.TryGetValue("Type", out var type))
{
if (type != "NFT Ticket")
{
throw new Exception("This is not NFT Ticket");
}
}
if (metadata.TryGetValue("EventId", out var nfteventId))
{
if (nfteventId != eventId)
{
throw new Exception("Event Id on the ticket does not match the requested.");
}
}
if (metadata.TryGetValue("Used", out var used))
{
if (used != "true")
{
throw new Exception("This NFT Ticket is not used.");
}
}
else
{
throw new Exception("This NFT Ticket is not used.");
}
var tx = Transaction.Parse(txi.Hex, NeblioTransactionHelpers.Network);
var outDto = new VerifyNFTTicketDto();
if (tx != null && tx.Outputs.Count > 0 && tx.Inputs.Count > 0)
{
var outp = tx.Outputs[0];
var inpt = tx.Inputs[0];
if (outp != null && inpt != null)
{
var scr = outp.ScriptPubKey;
var add = scr.GetDestinationAddress(NeblioTransactionHelpers.Network);
var addi = inpt.ScriptSig.GetSignerAddress(NeblioTransactionHelpers.Network);
if (add != addi)
{
throw new Exception("This ticket was not used on this address.");
}
var pubkey = inpt.ScriptSig.GetAllPubKeys().FirstOrDefault();
if (pubkey == null)
{
throw new Exception("Cannot Load the owner Public Key.");
}
// verify of the signature of the NFT
var verres = await ECDSAProvider.VerifyMessage(msg, dto.Signature, pubkey);
//var vmsg = await ECDSAProvider.VerifyMessage(msg, dto.Signature, pubkey);
if (!verres.Item1)
{
throw new Exception("Signature of the NFT is not valid.");
}
// check if the NFT is still as utxo on the address
var utxos = await NeblioTransactionHelpers.GetAddressUtxosObjects(add.ToString());
if (utxos.FirstOrDefault(u => (u.Txid == dto.TxId && u.Value == 10000 && u.Tokens.Count > 0 && u.Tokens.FirstOrDefault()?.Amount == 1)) == null)
{
throw new Exception("This ticket is not available on the address as spendable.");
}
// check if in previous transaction the ticket was unused
var prevmeta = await NeblioTransactionHelpers.GetTransactionMetadata(NFTHelpers.TokenId, inpt.PrevOut.Hash.ToString());
if (prevmeta.TryGetValue("NFT", out var isprevnft))
{
if (isprevnft != "true")
{
throw new Exception("This is not NFT");
}
}
if (prevmeta.TryGetValue("Type", out var prevtype))
{
if (prevtype != "NFT Ticket")
{
throw new Exception("This is not NFT Ticket");
}
}
if (prevmeta.TryGetValue("EventId", out var prevnfteventId))
{
if (prevnfteventId != eventId)
{
throw new Exception("Event Id on the ticket does not match the requested.");
}
}
if (prevmeta.TryGetValue("Used", out var prevused))
{
if (prevused == "true")
{
throw new Exception("This NFT Ticket was already used in previous transaction.");
}
}
// todo track origin for check minting address
var res = await VerifyNFTTicketOrigin(inpt.PrevOut.Hash.ToString(), eventId, allowedMintingAddresses);
if (!res.Item1)
{
throw new Exception($"Ticket was not minted on allowed address. The origin is from: {res.Item2.Item2}");
}
outDto.IsMintedByAllowedAddress = true;
outDto.MintAddress = res.Item2.Item2;
var nft = new TicketNFT("");
await nft.LoadLastData(metadata); // fill with already loaded the newest NFT metadata
nft.Time = Time;
outDto.IsSignatureValid = true;
outDto.NFT = nft;
outDto.OwnerAddress = add.ToString();
outDto.IsUsedOnSameAddress = true;
outDto.OwnerPubKey = pubkey;
outDto.TxId = dto.TxId;
}
}
return(outDto);
}
protected override async Task ExecuteAsync(CancellationToken stopToken)
{
await Task.Delay(1);
var neblioAddressForShop = string.Empty;
var neblioDepositAddressForShop = string.Empty;
var dogeAddressForShop = string.Empty;
var dogeDepositAddressForShop = string.Empty;
MainDataContext.IsAPIWithCredentials = settings.GetValue <bool>("IsAPIWithCredentials", true);
MainDataContext.LoadAllVENFTOwnersWithAllNFTs = settings.GetValue <bool>("LoadAllVENFTOwnersWithAllNFTs", false);
var loadWithInWebAssemblyLimits = settings.GetValue <bool>("LoadWithInWebAssemblyLimits", false);
MainDataContext.IpfsSecret = settings.GetValue <string>("IpfsSecret", string.Empty);
MainDataContext.IpfsProjectID = settings.GetValue <string>("IpfsProjectID", string.Empty);
if (!string.IsNullOrEmpty(MainDataContext.IpfsSecret) && !string.IsNullOrEmpty(MainDataContext.IpfsProjectID))
{
NFTHelpers.LoadConnectionInfo(MainDataContext.IpfsProjectID, MainDataContext.IpfsSecret);
}
var acc = new List <string>();
settings.GetSection("ObservedAccounts").Bind(acc);
if (acc != null)
{
MainDataContext.ObservedAccounts = acc;
}
try
{
/*
* var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "keys.json");
* if (!FileHelpers.IsFileExists(path))
* {
* Console.WriteLine("Missing keys.json file. Cannot continue without at least one root Neblio account.");
* return;
* }
* var skeys = FileHelpers.ReadTextFromFile(path);
* var keys = JsonConvert.DeserializeObject<List<AccountExportDto>>(skeys);
*/
var keys = new List <AccountExportDto>();
settings.GetSection("keys").Bind(keys);
if (keys == null || keys.Count == 0)
{
//log.Error("Missing keys in settigns. Cannot continue without at least one root Neblio account.");
Console.WriteLine("Missing keys in settigns. Cannot continue without at least one root Neblio account.");
return;
}
Console.WriteLine("------------------------------------");
Console.WriteLine("-----------Loading Accounts---------");
Console.WriteLine("------------------------------------");
if (keys != null)
{
foreach (var k in keys)
{
if (!string.IsNullOrEmpty(k.Address))
{
if (!k.IsDogeAccount)
{
var add = NeblioTransactionHelpers.ValidateNeblioAddress(k.Address);
if (!string.IsNullOrEmpty(add))
{
Console.WriteLine("");
Console.WriteLine("=========Neblio Main Account========");
Console.WriteLine($"Loading Neblio address {k.Address}...");
if (string.IsNullOrEmpty(k.Name))
{
k.Name = NeblioTransactionHelpers.ShortenAddress(k.Address);
}
var account = new NeblioAccount();
EncryptedBackupDto bckp = null;
if (FileHelpers.IsFileExists(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, k.Address + "-backup.json")))
{
var b = FileHelpers.ReadTextFromFile(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, k.Address + "-backup.json"));
if (!string.IsNullOrEmpty(b))
{
bckp = JsonConvert.DeserializeObject <EncryptedBackupDto>(b);
Console.WriteLine($"Backup data found for this account. It will be loaded based on VENFT backup.");
}
}
(bool, string)dbackup = (false, string.Empty);
(bool, string)dpass = (false, string.Empty);
if (await account.LoadAccount(k.Password, k.EKey, k.Address)) // fill your password
{
if (k.ConnectToMainShop && k.IsReceivingAccount)
{
neblioAddressForShop = k.Address;
}
else if (k.ConnectToMainShop && k.IsDepositAccount)
{
neblioDepositAddressForShop = k.Address;
}
if (bckp != null)
{
var dadd = await ECDSAProvider.DecryptMessage(bckp.eadd, account.Secret);
dbackup = await ECDSAProvider.DecryptMessage(bckp.edata, account.Secret);
dpass = await ECDSAProvider.DecryptMessage(bckp.epass, account.Secret);
if (dpass.Item1 && dadd.Item1 && dadd.Item1)
{
Console.WriteLine($"Loading Neblio address {k.Address} from VENFT Backup...");
if (await account.LoadAccountFromVENFTBackup(dpass.Item2, dbackup.Item2))
{
Console.WriteLine($"Neblio address {k.Address} initialized.");
}
else
{
Console.WriteLine($"Cannot load VENFT backup for address {k.Address}.");
}
}
}
// this is block autostart of the IoT Devices NFTs...add this to appsettings.json "LoadWithInWebAssemblyLimits": true,
account.RunningAsVENFTBlazorApp = loadWithInWebAssemblyLimits;
VEDLDataContext.Accounts.TryAdd(k.Address, account);
VEDLDataContext.AdminAddresses.Add(k.Address);
if (dbackup.Item1 && dpass.Item1)
{
try
{
var bdto = JsonConvert.DeserializeObject <BackupDataDto>(dbackup.Item2);
if (bdto != null && !string.IsNullOrEmpty(bdto.DogeAddress))
{
Console.WriteLine($"Backup for main address {k.Address} contains also Dogecoin address {bdto.DogeAddress}. It will be imported.");
var dogeAccount = new DogeAccount();
var res = await dogeAccount.LoadAccount(dpass.Item2, bdto.DogeKey, bdto.DogeAddress);
VEDLDataContext.DogeAccounts.TryAdd(bdto.DogeAddress, dogeAccount);
Console.WriteLine($"Dogecoin address {bdto.DogeAddress} initialized.");
}
}
catch (Exception ex)
{
//log.Error("Canno init doge account" + ex.Message);
Console.WriteLine("Cannot init doge account" + ex.Message);
}
}
}
}
}
else
{
var dadd = DogeTransactionHelpers.ValidateDogeAddress(k.Address);
if (dadd.Success)
{
Console.WriteLine("");
Console.WriteLine("========Dogecoin Main Account=======");
Console.WriteLine($"Loading Dogecoin address {k.Address}...");
var dogeacc = new DogeAccount();
if (await dogeacc.LoadAccount(k.Password, k.EKey, k.Address))
{
VEDLDataContext.DogeAccounts.TryAdd(dogeacc.Address, dogeacc);
}
Console.WriteLine($"Dogecoin address {k.Address} initialized.");
if (k.ConnectToMainShop && k.IsReceivingAccount)
{
dogeAddressForShop = k.Address;
}
else if (k.ConnectToMainShop && k.IsDepositAccount)
{
dogeDepositAddressForShop = k.Address;
}
}
}
}
}
}
}
catch (Exception ex)
{
//log.Error("Canno load the keys. " + ex.Message);
Console.WriteLine("Cannot load the keys. " + ex.Message);
}
await Task.Delay(5000);
Console.WriteLine("------------------------------------");
Console.WriteLine("Loading NFT Hashes...");
await AccountHandler.ReloadNFTHashes();
Console.WriteLine($"Count of NFTHashes: {VEDLDataContext.NFTHashs.Count}.");
Console.WriteLine("");
Console.WriteLine("------------------------------------");
Console.WriteLine("---------WooCommerce Shop-----------");
Console.WriteLine("------------------------------------");
try
{
VEDLDataContext.WooCommerceStoreUrl = settings.GetValue <string>("WooCommerceStoreUrl");
VEDLDataContext.WooCommerceStoreAPIKey = settings.GetValue <string>("WooCommerceStoreAPIKey");
VEDLDataContext.WooCommerceStoreSecret = settings.GetValue <string>("WooCommerceStoreSecret");
VEDLDataContext.WooCommerceStoreJWTToken = settings.GetValue <string>("WooCommerceStoreJWT");
VEDLDataContext.WooCommerceStoreCheckoutFieldCustomerNeblioAddress = settings.GetValue <string>("WooCommerceStoreCheckoutFieldCustomerNeblioAddress");
VEDLDataContext.WooCommerceStoreSendDogeToAuthor = settings.GetValue <bool>("WooCommerceStoreSendDogeToAuthor", false);
VEDLDataContext.AllowDispatchNFTOrders = settings.GetValue <bool>("AllowDispatchNFTOrders", false);
try
{
settings.GetSection("DepositSchemes").Bind(VEDLDataContext.DepositSchemes);
}
catch (Exception ex)
{
Console.WriteLine("Cannot load the deposit schemes. " + ex.Message);
}
if (VEDLDataContext.DepositSchemes.Count == 0)
{
Console.WriteLine("!!!Cannot load the deposit schemes!!!");
}
if (!string.IsNullOrEmpty(VEDLDataContext.WooCommerceStoreUrl) &&
!string.IsNullOrEmpty(VEDLDataContext.WooCommerceStoreAPIKey) &&
!string.IsNullOrEmpty(VEDLDataContext.WooCommerceStoreSecret))
{
Console.WriteLine("Initializing WooCommerce Shop...");
Console.WriteLine("API Url: " + VEDLDataContext.WooCommerceStoreUrl);
if (await WooCommerceHelpers.InitStoreApiConnection(VEDLDataContext.WooCommerceStoreUrl,
VEDLDataContext.WooCommerceStoreAPIKey,
VEDLDataContext.WooCommerceStoreSecret,
VEDLDataContext.WooCommerceStoreJWTToken, true))
{
Console.WriteLine("WooCommerce Shop Initialized correctly.");
Console.WriteLine($"- Number of Products: {WooCommerceHelpers.Shop.Products.Count}");
Console.WriteLine($"- Number of Orders: {WooCommerceHelpers.Shop.Orders.Count}");
Console.WriteLine("------------------------------------");
if (!string.IsNullOrEmpty(dogeAddressForShop))
{
await WooCommerceHelpers.Shop.ConnectDogeAccount(dogeAddressForShop);
Console.WriteLine($"Connecting Dogecoin address {dogeAddressForShop} to the WooCommerce Shop main input account.");
}
if (!string.IsNullOrEmpty(dogeDepositAddressForShop) && dogeAddressForShop != dogeDepositAddressForShop)
{
WooCommerceHelpers.Shop.ConnectedDepositDogeAccountAddress = dogeDepositAddressForShop;
Console.WriteLine($"Connecting Dogecoin address {dogeDepositAddressForShop} to the WooCommerce Shop as deposit account.");
}
if (!string.IsNullOrEmpty(dogeDepositAddressForShop) && !string.IsNullOrEmpty(dogeAddressForShop) && dogeAddressForShop == dogeDepositAddressForShop)
{
Console.WriteLine($"Input doge address and deposit address cannot be same.");
}
if (string.IsNullOrEmpty(WooCommerceHelpers.Shop.ConnectedDogeAccountAddress))
{
if (!string.IsNullOrEmpty(neblioAddressForShop))
{
await WooCommerceHelpers.Shop.ConnectNeblioAccount(neblioAddressForShop);
Console.WriteLine($"Connecting Neblio address {neblioAddressForShop} to the WooCommerce Shop main input account.");
}
if (!string.IsNullOrEmpty(neblioDepositAddressForShop) && neblioAddressForShop != dogeDepositAddressForShop)
{
await WooCommerceHelpers.Shop.ConnectDepositNeblioAccount(neblioDepositAddressForShop);
Console.WriteLine($"Connecting Neblio address {neblioDepositAddressForShop} to the WooCommerce Shop as deposit account.");
}
if (!string.IsNullOrEmpty(neblioDepositAddressForShop) && !string.IsNullOrEmpty(neblioAddressForShop) && neblioAddressForShop == neblioDepositAddressForShop)
{
Console.WriteLine($"Input Neblio address and deposit address cannot be same.");
}
}
}
else
{
Console.WriteLine("Cannot init the WooCommerce API.");
//log.Warn("Canno init WooCommerce API.");
}
}
}
catch (Exception ex)
{
//log.Error("Canno init WooCommerce API. " + ex.Message);
Console.WriteLine("Cannot init the WooCommerce API." + ex.Message);
}
Console.WriteLine("------------------------------------");
Console.WriteLine("--------Starting main cycle---------");
Console.WriteLine("------------------------------------");
try
{
var VENFTOwnersRefreshDefault = 3600;
var VENFTOwnersRefresh = 100;
var NFTHashsRefreshDefault = 100;
var NFTHashsRefresh = 10;
_ = Task.Run(async() =>
{
Console.WriteLine("Loading Observing addresses...");
// load observed addresses
if (MainDataContext.ObservedAccounts.Count > 0)
{
for (var i = 0; i < MainDataContext.ObservedAccounts.Count; i++)
{
try
{
var tab = new VEDriversLite.Bookmarks.ActiveTab(MainDataContext.ObservedAccounts[i]);
tab.MaxLoadedNFTItems = 1500;
await tab.StartRefreshing(10000, false, true);
MainDataContext.ObservedAccountsTabs.TryAdd(tab.Address, tab);
}
catch (Exception ex)
{
Console.WriteLine("Cannot start observing of account: " + MainDataContext.ObservedAccounts[i]);
}
}
}
Console.WriteLine("Running...");
while (!stopToken.IsCancellationRequested)
{
await Task.Delay(1000);
/*
* if (VENFTOwnersRefresh <= 0)
* {
* try
* {
* var owns = await NeblioTransactionHelpers.GetTokenOwners(NFTHelpers.TokenId);
* if (owns != null)
* {
* var ow = new Dictionary<string, TokenOwnerDto>();
* foreach (var o in owns)
* ow.Add(o.Address, o);
* MainDataContext.VENFTTokenOwners = ow;
* VENFTOwnersRefresh = VENFTOwnersRefreshDefault;
* }
* }
* catch(Exception ex)
* {
* log.Error("Cannot refresh VENFT Owners. " + ex.Message);
* Console.WriteLine("Cannot refresh VENFT Owners");
* }
* }
* else
* {
* VENFTOwnersRefresh--;
* }*/
try
{
if (NFTHashsRefresh <= 0)
{
if (await AccountHandler.ReloadNFTHashes())
{
NFTHashsRefresh = NFTHashsRefreshDefault;
}
}
else
{
NFTHashsRefresh--;
}
}
catch (Exception ex)
{
//log.Error("Cannot reload the NFT Hashes. " + ex.Message);
}
}
});
}
catch (Exception ex)
{
//log.Error("Fatal error in main loop. " + ex.Message);
lifetime.StopApplication();
}
}
/// <summary>
/// Decrypt and oad file from VENFT app to account
/// If account already exists, the data is updates.
/// If account do not exists, it will create new one and fill with the data
/// All accounts are stored in VEDLDataContext static class
/// After upload of the data, the local backup file is created. It is ecnrypted with private key, so key.json file is still required for the restart
/// </summary>
/// <param name="baseInfo"></param>
/// <param name="data"></param>
/// <param name="verifyActive"></param>
/// <returns></returns>
public static async Task <bool> LoadVENFTBackup(AdminActionBase baseInfo, EncryptedBackupDto data, bool verifyActive = false)
{
IAdminAction vres = null;
if (verifyActive)
{
vres = await VerifyAdminAction(baseInfo.Admin, baseInfo.Signature, baseInfo.Message);
if (vres == null)
{
return(false);
}
}
if (vres.Type != AdminActionTypes.ImportVENFTBackup)
{
throw new Exception("Provided Wrong action type.");
}
if (!VEDLDataContext.Accounts.TryGetValue(baseInfo.Admin, out var admin))
{
return(false);
}
var dadd = await ECDSAProvider.DecryptMessage(data.eadd, admin.Secret);
var dbackup = await ECDSAProvider.DecryptMessage(data.edata, admin.Secret);
var dpass = await ECDSAProvider.DecryptMessage(data.epass, admin.Secret);
if (!dbackup.Item1 || !dpass.Item1 || !dadd.Item1)
{
return(false);
}
Console.WriteLine("Loaded correct information for the update from the backup.");
if (VEDLDataContext.Accounts.TryGetValue(dadd.Item2, out var acc))
{
var r = await acc.LoadAccountFromVENFTBackup(dpass.Item2, dbackup.Item2);
if (r)
{
FileHelpers.WriteTextToFile(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, dadd.Item2 + "-backup.json"), JsonConvert.SerializeObject(data));
}
Console.WriteLine("Account updated from the backup.");
return(true);
}
else
{
var account = new NeblioAccount();
var res = await account.LoadAccountFromVENFTBackup(dpass.Item2, dbackup.Item2);
if (res && VEDLDataContext.Accounts.TryAdd(dadd.Item2, new NeblioAccount()))
{
FileHelpers.WriteTextToFile(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, dadd.Item2 + "-backup.json"), JsonConvert.SerializeObject(data));
if (data.asAdmin)
{
VEDLDataContext.AdminAddresses.Add(dadd.Item2);
}
Console.WriteLine("Account updated from the backup.");
return(true);
}
}
return(false);
}
public override async Task <IDictionary <string, string> > GetMetadata(string address = "", string key = "", string receiver = "")
{
var metadata = await GetCommonMetadata();
if (string.IsNullOrEmpty(address) || string.IsNullOrEmpty(key) || string.IsNullOrEmpty(receiver))
{
//throw new Exception("Wrong input. Must fill all parameters if you want to use metadata encryption.");
}
else
{
var edescription = string.Empty;
var ename = string.Empty;
var etext = string.Empty;
var eimagelink = string.Empty;
var elink = string.Empty;
if (Encrypt)
{
var res = await ECDSAProvider.EncryptStringWithSharedSecret(Description, receiver, key);
if (res.Item1)
{
edescription = res.Item2;
}
res = await ECDSAProvider.EncryptStringWithSharedSecret(Name, receiver, key);
if (res.Item1)
{
ename = res.Item2;
}
res = await ECDSAProvider.EncryptStringWithSharedSecret(Text, receiver, key);
if (res.Item1)
{
etext = res.Item2;
}
res = await ECDSAProvider.EncryptStringWithSharedSecret(ImageLink, receiver, key);
if (res.Item1)
{
eimagelink = res.Item2;
}
res = await ECDSAProvider.EncryptStringWithSharedSecret(Link, receiver, key);
if (res.Item1)
{
elink = res.Item2;
}
}
else
{
edescription = Description;
ename = Name;
etext = Text;
eimagelink = ImageLink;
elink = Link;
}
metadata["Name"] = ename;
if (!string.IsNullOrEmpty(Author))
{
metadata["Author"] = Author;
}
metadata["Description"] = edescription;
if (!string.IsNullOrEmpty(etext))
{
metadata["Text"] = etext;
}
if (!string.IsNullOrEmpty(eimagelink))
{
metadata["Image"] = eimagelink;
}
if (!string.IsNullOrEmpty(elink))
{
metadata["Link"] = elink;
}
}
return(metadata);
}
/// <summary>
/// Verify message which was signed by some address.
/// </summary>
/// <param name="message">Input message</param>
/// <param name="signature">Signature of this message created by owner of some doge address.</param>
/// <param name="address">Doge address which should sign the message and should be verified.</param>
/// <returns></returns>
public async Task <(bool, string)> VerifyMessage(string message, string signature, string address)
{
return(await ECDSAProvider.VerifyDogeMessage(message, signature, address));
}
