/**
* @TODO this should extend file system based tests and resolve tests via autofac container
*/
public DeltaExecutorTests()
{
_specProvider = new CatalystSpecProvider();
_stateProvider = new StateProvider(new StateDb(), new StateDb(), LimboLogs.Instance);
var storageProvider = new StorageProvider(new StateDb(), _stateProvider, LimboLogs.Instance);
IKvm virtualMachine = new KatVirtualMachine(_stateProvider, storageProvider, new StateUpdateHashProvider(),
_specProvider, LimboLogs.Instance);
var logger = Substitute.For <ILogger>();
logger.IsEnabled(Arg.Any <LogEventLevel>()).Returns(true);
_senderPrivateKey = _cryptoContext.GeneratePrivateKey();
_senderPublicKey = _senderPrivateKey.GetPublicKey();
_recipient = _cryptoContext.GeneratePrivateKey().GetPublicKey();
_poorSender = _cryptoContext.GeneratePrivateKey().GetPublicKey();
_stateProvider.CreateAccount(_poorSender.ToKvmAddress(), 0.Kat());
_stateProvider.CreateAccount(_senderPublicKey.ToKvmAddress(), 1000.Kat());
_stateProvider.CreateAccount(Address.Zero, 1000.Kat());
_stateProvider.Commit(_specProvider.GenesisSpec);
_executor = new DeltaExecutor(_specProvider, _stateProvider, storageProvider, virtualMachine,
new FfiWrapper(), logger);
_signingContext = new SigningContext
{
NetworkType = NetworkType.Devnet,
SignatureType = SignatureType.TransactionPublic
};
}
private IEnumerable <PublicEntry> GenerateSamplePublicTransactions(int sampleSize)
{
for (var i = 0; i < sampleSize; i++)
{
var sender = _cryptoContext.GeneratePrivateKey();
var recipient = _cryptoContext.GeneratePrivateKey().GetPublicKey();
var publicEntry = EntryUtils.PreparePublicEntry(recipient, sender.GetPublicKey(), 10);
publicEntry.Signature = publicEntry.GenerateSignature(_cryptoContext, sender, _signingContext);
yield return(publicEntry);
}
}
public async Task <IPrivateKey> KeyStoreGenerateAsync(NetworkType networkType, KeyRegistryTypes keyIdentifier)
{
var privateKey = _cryptoContext.GeneratePrivateKey();
await KeyStoreEncryptAsync(privateKey, networkType, keyIdentifier).ConfigureAwait(false);
return(privateKey);
}
public async Task <IPrivateKey> KeyStoreGenerate(KeyRegistryTypes keyIdentifier)
{
var privateKey = _cryptoContext.GeneratePrivateKey();
await KeyStoreEncryptAsync(privateKey, keyIdentifier);
return(privateKey);
}
private IPublicKey GetPublicKey(int index)
{
if (!_publicKeys.ContainsKey(index))
{
IPublicKey key = _cryptoContext.GeneratePrivateKey().GetPublicKey();
_publicKeys[index] = key;
}
return(_publicKeys[index]);
}
public void TestGenerateKey()
{
var privateKey = _wrapper.GeneratePrivateKey();
privateKey.Bytes.Length.Should().Be(_wrapper.PrivateKeyLength);
}
public void TestGeneratePrivateKey()
{
var privateKey = _context.GeneratePrivateKey();
privateKey.Should().BeOfType(typeof(PrivateKey));
}
