public static Signature GenerateSignature(this PublicEntry publicEntry,
ICryptoContext cryptoContext,
IPrivateKey privateKey,
SigningContext context)
{
return(GeneratePublicEntrySignature(publicEntry.Clone(), cryptoContext, privateKey, context));
}
public static TransactionBroadcast Sign(this TransactionBroadcast transaction,
ICryptoContext cryptoContext,
IPrivateKey privateKey,
SigningContext context)
{
var clone = transaction.Clone();
if (transaction.Signature?.RawBytes.Length == cryptoContext.SignatureLength)
{
Logger.Debug("The transaction was already signed, returning a clone.");
return(clone);
}
clone.Signature = null;
var signatureBytes = cryptoContext.Sign(privateKey, clone.ToByteArray(),
context.ToByteArray()).SignatureBytes;
clone.Signature = new Signature
{
RawBytes = signatureBytes.ToByteString(),
SigningContext = context
};
return(clone);
}
public LedgerTests()
{
_testScheduler = new TestScheduler();
_fakeRepository = Substitute.For <IAccountRepository>();
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_mapperProvider = new TestMapperProvider();
_logger = Substitute.For <ILogger>();
_mempool = Substitute.For <IMempool <PublicEntryDao> >();
_deltaHashProvider = Substitute.For <IDeltaHashProvider>();
_receipts = Substitute.For <ITransactionRepository>();
_synchroniser = Substitute.For <ISynchroniser>();
_genesisHash = _hashProvider.ComputeUtf8MultiHash("genesis").ToCid();
_synchroniser.DeltaCache.GenesisHash.Returns(_genesisHash);
_executor = Substitute.For <IDeltaExecutor>();
_stateProvider = Substitute.For <IStateProvider>();
_storageProvider = Substitute.For <IStorageProvider>();
_cryptoContext = new FfiWrapper();
_signingContext = new SigningContext
{
NetworkType = NetworkType.Devnet,
SignatureType = SignatureType.TransactionPublic
};
_deltaIndexService = new DeltaIndexService(new InMemoryRepository <DeltaIndexDao, string>());
}
public ProfileService(IUnitOfWork unitOfWork, IAuthenticatedUser authUser, IFileHelper fileHelper, ICryptoContext cryptoContext, IAuthTokenProvider authTokenProvider, IFormService formService)
: base(unitOfWork, authUser)
{
_fileHelper = fileHelper;
_cryptoContext = cryptoContext;
_authTokenProvider = authTokenProvider;
_formService = formService;
}
public TokenService(IUnitOfWork unitOfWork, ICryptoContext cryptoContext, DomainTaskStatus taskStatus, IOptions <JwtOptions> options, IAuthTokenProvider authTokenProvider)
{
_unitOfWork = unitOfWork;
_cryptoContext = cryptoContext;
_taskStatus = taskStatus;
_options = options;
_authTokenProvider = authTokenProvider;
}
public KeySignerTests()
{
_keystore = Substitute.For <IKeyStore>();
_keyRegistry = Substitute.For <IKeyRegistry>();
_signature = Substitute.For <ISignature>();
_privateKey = Substitute.For <IPrivateKey>();
_cryptoContext = Substitute.For <ICryptoContext>();
_cryptoContext.Sign(default, default, default).ReturnsForAnyArgs(_signature);
/// <summary>Initializes a new instance of the <see cref="KeySigner"/> class.</summary>
/// <param name="keyStore">The key store.</param>
/// <param name="cryptoContext">The crypto context.</param>
/// /// <param name="keyRegistry">The key registry.</param>
public KeySigner(IKeyStore keyStore,
ICryptoContext cryptoContext,
IKeyRegistry keyRegistry)
{
_keyStore = keyStore;
_cryptoContext = cryptoContext;
_keyRegistry = keyRegistry;
InitialiseKeyRegistry();
}
public void Init()
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_random = new Random(1);
_randomFactory = Substitute.For <IDeterministicRandomFactory>();
_randomFactory.GetDeterministicRandomFromSeed(Arg.Any <byte[]>())
.Returns(ci => new IsaacRandom(((byte[])ci[0]).ToHex()));
_producerId = PeerIdHelper.GetPeerId("producer");
_peerSettings = _producerId.ToSubstitutedPeerSettings();
_previousDeltaHash = _hashProvider.ComputeUtf8MultiHash("previousDelta").ToCid();
_zeroCoinbaseEntry = new CoinbaseEntry
{
Amount = UInt256.Zero.ToUint256ByteString(),
ReceiverPublicKey = _producerId.PublicKey.ToByteString()
};
_logger = Substitute.For <ILogger>();
_cache = Substitute.For <IDeltaCache>();
Delta previousDelta = new Delta();
previousDelta.StateRoot = ByteString.CopyFrom(Keccak.EmptyTreeHash.Bytes);
_cache.TryGetOrAddConfirmedDelta(Arg.Any <Cid>(), out Arg.Any <Delta>()).Returns(x =>
{
x[1] = previousDelta;
return(true);
});
_dateTimeProvider = new DateTimeProvider();
IDb codeDb = new MemDb();
ISnapshotableDb stateDb = new StateDb();
ISpecProvider specProvider = new CatalystSpecProvider();
_cryptoContext = new FfiWrapper();
_stateProvider = new StateProvider(stateDb, codeDb, LimboLogs.Instance);
IStorageProvider storageProvider = new StorageProvider(stateDb, _stateProvider, LimboLogs.Instance);
KatVirtualMachine virtualMachine = new KatVirtualMachine(_stateProvider,
storageProvider,
new StateUpdateHashProvider(),
specProvider,
new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256")),
new FfiWrapper(),
LimboLogs.Instance);
_deltaExecutor = new DeltaExecutor(specProvider,
_stateProvider,
storageProvider,
virtualMachine,
_cryptoContext,
_logger);
}
public LocalKeyStoreTests(ITestOutputHelper output) : base(output)
{
_fileSystem = Substitute.For <IFileSystem>();
_context = new FfiWrapper();
var logger = Substitute.For <ILogger>();
_passwordManager = Substitute.For <IPasswordManager>();
_passwordManager.RetrieveOrPromptPassword(default)
public void Init()
{
this.Setup(TestContext.CurrentContext);
_fileSystem = Substitute.For <IFileSystem>();
_context = new FfiWrapper();
var logger = Substitute.For <ILogger>();
_passwordManager = Substitute.For <IPasswordManager>();
_passwordManager.RetrieveOrPromptPassword(default)
public KeySignerTests()
{
_keystore = Substitute.For <IKeyStore>();
_keyRegistry = Substitute.For <IKeyRegistry>();
_signature = Substitute.For <ISignature>();
_privateKey = Substitute.For <IPrivateKey>();
_cryptoContext = new CryptoContext(_signature);
_privateKey.Bytes.Returns(ByteUtil.GenerateRandomByteArray(32));
_keystore.KeyStoreDecrypt(default).ReturnsForAnyArgs(_privateKey);
public LocalKeyStore(IPasswordManager passwordManager,
ICryptoContext cryptoContext,
IFileSystem fileSystem,
IHashProvider hashProvider,
ILogger logger)
{
_passwordManager = passwordManager;
_cryptoContext = cryptoContext;
_fileSystem = fileSystem;
_hashProvider = hashProvider;
_logger = logger;
}
public AccountsService(IUnitOfWork unitOfWork,
IFormService formService,
IAuthTokenProvider tokenProvider,
ICryptoContext cryptoContext,
IEmailSender emailSender,
IAuthenticatedUser au)
{
_unitOfWork = unitOfWork;
_cryptoContext = cryptoContext;
_tokenProvider = tokenProvider;
_emailSender = emailSender;
_au = au;
_formService = formService;
}
public KatVirtualMachine(IStateProvider stateProvider,
IStorageProvider storageProvider,
IStateUpdateHashProvider blockhashProvider,
ISpecProvider specProvider,
IHashProvider hashProvider,
ICryptoContext cryptoContext,
ILogManager logManager)
: base(stateProvider, storageProvider, blockhashProvider, specProvider, logManager)
{
_hashProvider = hashProvider ?? throw new ArgumentNullException(nameof(hashProvider));
_cryptoContext = cryptoContext ?? throw new ArgumentNullException(nameof(cryptoContext));
AddCatalystPrecompiledContracts();
}
/// <summary>
/// Note that there is a distinct approach to state and storage even as only together they form the 'state'
/// in the business sense. <see cref="IStorageProvider" /> needs to handle storage trees for various accounts
/// while <see cref="IStateProvider" /> handles the basic accounts state with storage roots only.
/// </summary>
/// <param name="specProvider">The network upgrade spec - defines the virtual machine version.</param>
/// <param name="stateProvider">Access to accounts.</param>
/// <param name="storageProvider">Access to accounts' storage.</param>
/// <param name="virtualMachine">A virtual machine to execute the code on.</param>
/// <param name="cryptoContext">Support for crypto operations.</param>
/// <param name="logger">Logger for the execution details.</param>
public DeltaExecutor(ISpecProvider specProvider,
IStateProvider stateProvider,
IStorageProvider storageProvider,
IKvm virtualMachine,
ICryptoContext cryptoContext,
ILogger logger)
{
_logger = logger;
_specProvider = specProvider;
_virtualMachine = virtualMachine;
_cryptoContext = cryptoContext;
_stateProvider = stateProvider;
_storageProvider = storageProvider;
}
public ForgotPaswordService(IUnitOfWork unitOfWork,
IAuthTokenProvider authTokenProvider,
IEmailSender emailSender,
IAuthenticatedUser au,
IOptions <ResetPasswordOptions> options,
ICryptoContext cryptoContext)
{
_unitOfWork = unitOfWork;
_authTokenProvider = authTokenProvider;
_emailSender = emailSender;
_cryptoContext = cryptoContext;
_resetPasswordOptions = options.Value;
_au = au;
}
public Ledger(IAccountRepository accounts,
IDeltaHashProvider deltaHashProvider,
ILedgerSynchroniser synchroniser,
IMempool <MempoolDocument> mempool,
ILogger logger)
{
Accounts = accounts;
_synchroniser = synchroniser;
_mempool = mempool;
_logger = logger;
_deltaUpdatesSubscription = deltaHashProvider.DeltaHashUpdates.Subscribe(Update);
LatestKnownDelta = _synchroniser.DeltaCache.GenesisHash;
_cryptoContext = new FfiWrapper();
}
private static Signature GeneratePublicEntrySignature(PublicEntry publicEntry,
ICryptoContext cryptoContext,
IPrivateKey privateKey,
SigningContext context)
{
publicEntry.Signature = null;
var signatureBytes = cryptoContext.Sign(privateKey, publicEntry.ToByteArray(),
context.ToByteArray()).SignatureBytes;
return(new Signature
{
RawBytes = signatureBytes.ToByteString(),
SigningContext = context
});
}
public static PublicEntry Sign(this PublicEntry publicEntry,
ICryptoContext cryptoContext,
IPrivateKey privateKey,
SigningContext context)
{
var clone = publicEntry.Clone();
if (publicEntry.Signature?.RawBytes.Length == cryptoContext.SignatureLength)
{
Logger.Debug("The transaction was already signed, returning a clone.");
return(clone);
}
clone.Signature = GeneratePublicEntrySignature(clone, cryptoContext, privateKey, context);
return(clone);
}
public static bool Verify(this ICryptoContext crypto, ISignature signature, IMessage message, IMessage context)
{
ProtoPreconditions.CheckNotNull(message, nameof(message));
ProtoPreconditions.CheckNotNull(context, nameof(context));
var messageSize = message.CalculateSize();
var contextSize = context.CalculateSize();
var array = ArrayPool <byte> .Shared.Rent(messageSize + contextSize);
using (var output = new CodedOutputStream(array))
{
message.WriteTo(output);
context.WriteTo(output);
}
var result = crypto.Verify(signature, array.AsSpan(0, messageSize), array.AsSpan(messageSize, contextSize));
ArrayPool <byte> .Shared.Return(array);
return(result);
}
public Ed25519VerifyPrecompile(ICryptoContext cryptoContext)
{
_cryptoContext = cryptoContext ?? throw new ArgumentNullException(nameof(cryptoContext));
}
public PeerIdValidator(ICryptoContext cryptoContext)
{
_cryptoContext = cryptoContext;
}
public TokenService(IUnitOfWork _unitOfWork, IOptions <JwtOptions> _options, ICryptoContext _cryptoContext)
{
unitOfWork = _unitOfWork;
options = _options.Value;
cryptoContext = _cryptoContext;
}
public RegistrationService(IUnitOfWork _unitOfWork, ICryptoContext _cryptoContext, ITokenService _tokenService)
{
unitOfWork = _unitOfWork;
cryptoContext = _cryptoContext;
tokenService = _tokenService;
}
public TransactionValidator(ILogger logger,
ICryptoContext cryptoContext)
{
_cryptoContext = cryptoContext;
_logger = logger;
}
