/// <inheritdoc /> public void DeleteRecurringTransaction(int id, bool deleteInstances) { this.ConcurrentInvoke(() => { var processor = new TransactionProcessor(this.Context, this.splitwiseContext); var entity = this.Context.RecurringTransactions.GetEntity(id); var instances = this.Context.Transactions.GetTransactionsFromRecurring(entity.Id); foreach (var instance in instances) { if (deleteInstances) { processor.RevertIfProcessed(instance); this.Context.Remove(instance); } else { instance.RecurringTransactionId = null; } } this.Context.Remove(entity); this.Context.SaveChanges(); }); }
public async void Buy(object sender, EventArgs e) { ApiServer server = new ApiServer(); var tp = new TransactionProcessor(server); tp.ConfirmOrder(CurrentOrder, "buyerPhoneNumber"); }
public async void TransferFundsBtn_Clicked(object sender, EventArgs e) { ApiServer server = new ApiServer(); TransactionProcessor processor = new TransactionProcessor(server); processor.AddMobileTransfer(100, AuthModel.MobilePhoneNumber, "buyerNumber"); }
/// <inheritdoc /> public void UpdateTransactionReceiver(int id, int accountId) { this.ConcurrentInvoke(() => { var transaction = this.Context.Transactions.GetEntity(id); if (transaction.Type != TransactionType.Transfer) { throw new ValidationException("Only a transfer transaction can have a receiving account."); } var newReceiver = this.Context.Accounts.GetEntity(accountId); var processor = new TransactionProcessor(this.Context, this.splitwiseContext); // Transfer transaction do not use budgets or categories, so we can use the normal revert process. processor.RevertIfProcessed(transaction, true); transaction.ReceivingAccountId = newReceiver.Id; transaction.ReceivingAccount = newReceiver; processor.ProcessIfNeeded(transaction); this.Context.SaveChanges(); }); }
/// <inheritdoc /> public Transaction CompleteTransferImport(int splitwiseId, int accountId) { var splitwiseTransaction = this.Context.SplitwiseTransactions.GetEntity(splitwiseId); var splitwiseAccount = this.Context.Accounts.GetSplitwiseEntity(); return(this.ConcurrentInvoke(() => { var processor = new TransactionProcessor(this.Context, this.splitwiseContext); var account = this.Context.Accounts.GetEntity(accountId); if (account.Type != AccountType.Normal) { throw new ValidationException("A normal account should be specified."); } var transaction = splitwiseTransaction.ToTransaction(splitwiseAccount, account); processor.ProcessIfNeeded(transaction); this.Context.Transactions.Add(transaction); this.Context.SaveChanges(); return transaction.AsTransaction(); })); }
public ReadOnlyTxProcessingEnv( IReadOnlyDbProvider?readOnlyDbProvider, IReadOnlyTrieStore?readOnlyTrieStore, IReadOnlyBlockTree?readOnlyBlockTree, ISpecProvider?specProvider, ILogManager?logManager) { if (specProvider == null) { throw new ArgumentNullException(nameof(specProvider)); } DbProvider = readOnlyDbProvider ?? throw new ArgumentNullException(nameof(readOnlyDbProvider)); _codeDb = readOnlyDbProvider.CodeDb.AsReadOnly(true); StateReader = new StateReader(readOnlyTrieStore, _codeDb, logManager); StateProvider = new StateProvider(readOnlyTrieStore, _codeDb, logManager); StorageProvider = new StorageProvider(readOnlyTrieStore, StateProvider, logManager); IWorldState worldState = new WorldState(StateProvider, StorageProvider); BlockTree = readOnlyBlockTree ?? throw new ArgumentNullException(nameof(readOnlyBlockTree)); BlockhashProvider = new BlockhashProvider(BlockTree, logManager); Machine = new VirtualMachine(BlockhashProvider, specProvider, logManager); TransactionProcessor = new TransactionProcessor(specProvider, worldState, Machine, logManager); }
public void ExecuteTransaction() { var transaction = CreateTransaction(100); var addr1 = transaction.Sender; var addr2 = transaction.Receiver; var store = new AccountsState(); AccountsState newstore = null; store = store.Put(addr1, new AccountState(new BigInteger(200), 0)); var processor = new TransactionProcessor(); Assert.IsTrue(processor.ExecuteTransaction(transaction, store, ref newstore)); Assert.IsNotNull(newstore); Assert.AreNotSame(store, newstore); Assert.AreEqual(new BigInteger(200), store.Get(addr1).Balance); Assert.AreEqual(BigInteger.Zero, store.Get(addr2).Balance); Assert.AreEqual(new BigInteger(100), newstore.Get(addr1).Balance); Assert.AreEqual(new BigInteger(100), newstore.Get(addr2).Balance); }
public void Setup() { IDb blocksDb = new MemDb(); IDb headersDb = new MemDb(); IDb blocksInfoDb = new MemDb(); ISnapshotableDb stateDb = new StateDb(); ISnapshotableDb codeDb = new StateDb(); ChainLevelInfoRepository repository = new ChainLevelInfoRepository(blocksInfoDb); ISpecProvider specProvider = MainNetSpecProvider.Instance; _blockTree = new BlockTree(blocksDb, headersDb, blocksInfoDb, repository, specProvider, NullTxPool.Instance, NullBloomStorage.Instance, new SyncConfig(), LimboLogs.Instance); StateProvider stateProvider = new StateProvider(stateDb, codeDb, LimboLogs.Instance); StorageProvider storageProvider = new StorageProvider(stateDb, stateProvider, LimboLogs.Instance); BlockhashProvider blockhashProvider = new BlockhashProvider(_blockTree, LimboLogs.Instance); VirtualMachine virtualMachine = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, specProvider, LimboLogs.Instance); TransactionProcessor transactionProcessor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, LimboLogs.Instance); BlockProcessor blockProcessor = new BlockProcessor(specProvider, TestBlockValidator.AlwaysValid, NoBlockRewards.Instance, transactionProcessor, stateDb, codeDb, stateProvider, storageProvider, NullTxPool.Instance, NullReceiptStorage.Instance, LimboLogs.Instance); _processor = new BlockchainProcessor(_blockTree, blockProcessor, new CompositeDataRecoveryStep(), LimboLogs.Instance, false); Block genesis = Build.A.Block.Genesis.TestObject; _blockTree.SuggestBlock(genesis); _processor.Process(genesis, ProcessingOptions.None, NullBlockTracer.Instance); }
public void processTransactionTest() { string stringTransactionList = "12346,04/11/2012,$112.00\n2122,01-21-2012,200.00\n345,02/11/2012,$19.00\n345,13/11/2012,$19.00\nv,02/11/2012,$19.00\n119,02/11/2012,k\n"; List <Transaction> goodTransactions = new List <Transaction>() { new Transaction() { CustomerId = 12346, TransactionDate = DateTime.Parse("04/11/2012"), TransactionPoints = 74, TransactionAmount = decimal.Parse("112.00") }, new Transaction() { CustomerId = 2122, TransactionDate = DateTime.Parse("01-21-2012"), TransactionPoints = 250, TransactionAmount = decimal.Parse("200.00") }, new Transaction() { CustomerId = 345, TransactionDate = DateTime.Parse("02/11/2012"), TransactionPoints = 0, TransactionAmount = decimal.Parse("19.00") } }; List <string> errorTransactions = new List <string>() { "345,13/11/2012,$19.00", "v,02/11/2012,$19.00", "119,02/11/2012,k" }; List <Transaction> goodProcessedTransactions = new List <Transaction>(); List <string> errorProcessedTransactions = new List <string>(); TransactionProcessor transactionProcessor = new TransactionProcessor(); foreach (string transaction in stringTransactionList.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None)) { transactionProcessor.processTransaction(transaction, goodProcessedTransactions, errorProcessedTransactions); } CollectionAssert.Equals(goodTransactions, goodProcessedTransactions); CollectionAssert.AreEqual(errorTransactions, errorProcessedTransactions); }
public void Setup() { IDbProvider memDbProvider = TestMemDbProvider.Init(); TrieStore trieStore = new TrieStore(new MemDb(), LimboLogs.Instance); StateProvider stateProvider = new StateProvider(trieStore, new MemDb(), LimboLogs.Instance); StorageProvider storageProvider = new StorageProvider(trieStore, stateProvider, LimboLogs.Instance); ChainLevelInfoRepository chainLevelInfoRepository = new ChainLevelInfoRepository(memDbProvider); ISpecProvider specProvider = MainnetSpecProvider.Instance; IBloomStorage bloomStorage = NullBloomStorage.Instance; EthereumEcdsa ecdsa = new EthereumEcdsa(1, LimboLogs.Instance); TxPool.TxPool txPool = new TxPool.TxPool( NullTxStorage.Instance, ecdsa, specProvider, new TxPoolConfig(), stateProvider, LimboLogs.Instance); _blockTree = new BlockTree( memDbProvider, chainLevelInfoRepository, specProvider, bloomStorage, new SyncConfig(), LimboLogs.Instance); BlockhashProvider blockhashProvider = new BlockhashProvider(_blockTree, LimboLogs.Instance); VirtualMachine virtualMachine = new VirtualMachine( stateProvider, storageProvider, blockhashProvider, specProvider, LimboLogs.Instance); TransactionProcessor transactionProcessor = new TransactionProcessor( specProvider, stateProvider, storageProvider, virtualMachine, LimboLogs.Instance); BlockProcessor blockProcessor = new BlockProcessor( MainnetSpecProvider.Instance, Always.Valid, new RewardCalculator(specProvider), transactionProcessor, stateProvider, storageProvider, txPool, NullReceiptStorage.Instance, new WitnessCollector(memDbProvider.StateDb, LimboLogs.Instance), LimboLogs.Instance); _blockchainProcessor = new BlockchainProcessor( _blockTree, blockProcessor, new RecoverSignatures( ecdsa, txPool, specProvider, LimboLogs.Instance), LimboLogs.Instance, BlockchainProcessor.Options.Default); }
public void ValidateExcel20Transactions() { ExcelFile ef; var assembly = Assembly.GetExecutingAssembly(); var fileName = "20_transactions.xlsx"; var resourceName = $"TaxFileImport.UnitTests.TestFiles.{fileName}"; using (var stream = assembly.GetManifestResourceStream(resourceName)) { ef = ExcelFile.Load(stream, LoadOptions.XlsxDefault); } //Act var mockTransactionDataProvider = A.Fake <ITransactionDataProvider>(); var transactionProcessor = new TransactionProcessor(new Iso4217DataProvider(), mockTransactionDataProvider); var excelFileProcessor = new ExcelFileProcessor(transactionProcessor); //setup on call DataProvide to data save successfully A.CallTo(() => mockTransactionDataProvider.Save(A <Transaction> ._)).Returns(1); var errorMessages = excelFileProcessor.ProcessExcelFile(ef); //Assert Assert.True(errorMessages.Count > 0); }
public void GlobalSetup() { ISnapshotableDb codeDb = new StateDb(); ISnapshotableDb stateDb = new StateDb(); IDb blockInfoDb = new MemDb(10, 5); ISpecProvider specProvider = MainNetSpecProvider.Instance; IReleaseSpec spec = MainNetSpecProvider.Instance.GenesisSpec; StateProvider stateProvider = new StateProvider(stateDb, codeDb, LimboLogs.Instance); stateProvider.CreateAccount(Address.Zero, 1000.Ether()); stateProvider.Commit(spec); StorageProvider storageProvider = new StorageProvider(stateDb, stateProvider, LimboLogs.Instance); StateReader stateReader = new StateReader(stateDb, codeDb, LimboLogs.Instance); ChainLevelInfoRepository chainLevelInfoRepository = new ChainLevelInfoRepository(blockInfoDb); BlockTree blockTree = new BlockTree(new MemDb(), new MemDb(), blockInfoDb, chainLevelInfoRepository, specProvider, NullTxPool.Instance, LimboLogs.Instance); _blockhashProvider = new BlockhashProvider(blockTree, LimboLogs.Instance); _virtualMachine = new VirtualMachine(stateProvider, storageProvider, _blockhashProvider, specProvider, LimboLogs.Instance); Block genesisBlock = Build.A.Block.Genesis.TestObject; blockTree.SuggestBlock(genesisBlock); Block block1 = Build.A.Block.WithParent(genesisBlock).WithNumber(1).TestObject; blockTree.SuggestBlock(block1); TransactionProcessor transactionProcessor = new TransactionProcessor(MainNetSpecProvider.Instance, stateProvider, storageProvider, _virtualMachine, LimboLogs.Instance); BlockProcessor blockProcessor = new BlockProcessor(specProvider, AlwaysValidBlockValidator.Instance, new RewardCalculator(specProvider), transactionProcessor, stateDb, codeDb, new MemDb(), stateProvider, storageProvider, NullTxPool.Instance, NullReceiptStorage.Instance, LimboLogs.Instance); BlockchainProcessor blockchainProcessor = new BlockchainProcessor( blockTree, blockProcessor, new TxSignaturesRecoveryStep(new EthereumEcdsa(specProvider, LimboLogs.Instance), NullTxPool.Instance, LimboLogs.Instance), LimboLogs.Instance, false, false); blockchainProcessor.Process(genesisBlock, ProcessingOptions.None, NullBlockTracer.Instance); blockchainProcessor.Process(block1, ProcessingOptions.None, NullBlockTracer.Instance); BlockchainBridge bridge = new BlockchainBridge( stateReader, stateProvider, storageProvider, blockTree, NullTxPool.Instance, NullReceiptStorage.Instance, NullFilterStore.Instance, NullFilterManager.Instance, new DevWallet(new WalletConfig(), LimboLogs.Instance), transactionProcessor, new EthereumEcdsa(MainNetSpecProvider.Instance, LimboLogs.Instance)); _ethModule = new EthModule(LimboLogs.Instance, bridge); }
public void Base_fee_opcode_should_return_expected_results(bool eip3198Enabled, int baseFee) { _processor = new TransactionProcessor(SpecProvider, TestState, Storage, Machine, LimboLogs.Instance); byte[] code = Prepare.EvmCode .Op(Instruction.BASEFEE) .PushData(0) .Op(Instruction.SSTORE) .Done; long blockNumber = eip3198Enabled ? LondonTestBlockNumber : LondonTestBlockNumber - 1; (Block block, Transaction transaction) = PrepareTx(blockNumber, 100000, code); block.Header.BaseFee = (UInt256)baseFee; transaction.FeeCap = (UInt256)baseFee; TestAllTracerWithOutput tracer = CreateTracer(); _processor.Execute(transaction, block.Header, tracer); if (eip3198Enabled) { AssertStorage((UInt256)0, (UInt256)baseFee); } else { tracer.Error.Should().Be(EvmExceptionType.BadInstruction.ToString()); AssertStorage((UInt256)0, (UInt256)0); } }
public EntityListController(AccountProcessor accountProcessor, TransactionProcessor transactionProcessor, DatafeedProcessor datafeedProcessor, GoalProcessor goalProcessor) { _accountProcessor = accountProcessor; _transactionProcessor = transactionProcessor; _datafeedProcessor = datafeedProcessor; _goalProcessor = goalProcessor; }
public void RegisterServices( BitcoinStore bitcoinStore, WasabiSynchronizer syncer, NodesGroup nodes, ServiceConfiguration serviceConfiguration, IFeeProvider feeProvider, CoreNode coreNode = null) { if (State != WalletState.Uninitialized) { throw new InvalidOperationException($"{nameof(State)} must be {WalletState.Uninitialized}. Current state: {State}."); } BitcoinStore = Guard.NotNull(nameof(bitcoinStore), bitcoinStore); Nodes = Guard.NotNull(nameof(nodes), nodes); Synchronizer = Guard.NotNull(nameof(syncer), syncer); ServiceConfiguration = Guard.NotNull(nameof(serviceConfiguration), serviceConfiguration); FeeProvider = Guard.NotNull(nameof(feeProvider), feeProvider); CoreNode = coreNode; ChaumianClient = new CoinJoinClient(Synchronizer, Network, KeyManager); TransactionProcessor = new TransactionProcessor(BitcoinStore.TransactionStore, KeyManager, ServiceConfiguration.DustThreshold, ServiceConfiguration.PrivacyLevelStrong); Coins = TransactionProcessor.Coins; TransactionProcessor.WalletRelevantTransactionProcessed += TransactionProcessor_WalletRelevantTransactionProcessedAsync; ChaumianClient.OnDequeue += ChaumianClient_OnDequeue; BitcoinStore.IndexStore.NewFilter += IndexDownloader_NewFilterAsync; BitcoinStore.IndexStore.Reorged += IndexDownloader_ReorgedAsync; BitcoinStore.MempoolService.TransactionReceived += Mempool_TransactionReceived; State = WalletState.Initialized; }
/// <summary> /// Button 'Charge Fee' click /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void btnChargeFee_Click(object sender, EventArgs e) { ITransactionProcessor transactionProccesor = TransactionProcessor.GetTransactionProcessor(); CurrencyAmount currencyAmount = new CurrencyAmount(); currencyAmount.Amount = Convert.ToInt32(txtTransactionAmoun.Text); currencyAmount.Currency = txtTransactionCurrency.Text; IDepositAccount depositAccount = createDepositAccount(); ILoanAccount loanAccount = createLoanAccount(); List <IAccount> accounts = new List <IAccount>(); accounts.Add(depositAccount); accounts.Add(loanAccount); TransactionStatus status = ProcessorExtensions.ChargeProcessingFee(transactionProccesor, currencyAmount, accounts); if (status.Equals(TransactionStatus.Completed)) { lblTransactionStatus.Text = "Transaction Completed"; } else { lblTransactionStatus.Text = "Transaction Failed"; } DisplayLastTransactionDetails(); }
/// <summary> /// Method for dispaiing last transaction details /// </summary> private void DisplayLastTransactionDetails() { TransactionProcessor transactionProcessor = TransactionProcessor.GetTransactionProcessor(); TransactionLogEntry tmp = transactionProcessor.LastTransaction; //TransactionLogEntry tmp = transactionProcessor[transactionProcessor.TransactionCount - 1]; lbl_LogTransactionType.Text = tmp.TransactionType.ToString(); lbl_LogAmount.Text = tmp.Amount.Amount.ToString(); lbl_LogCurrency.Text = tmp.Amount.Currency; lbl_LogTransactionStatus.Text = tmp.Status.ToString(); foreach (IAccount account in tmp.Accounts) { if (account is ITransactionAccount) { populateTransactionAccount(account as ITransactionAccount); } else if (account is ILoanAccount) { populateLoanAccount(account as ILoanAccount); } else if (account is IDepositAccount) { populateDepositAccount(account as IDepositAccount); } } lblNumberTransactions.Text = "Number of transactions: " + transactionProcessor.TransactionCount.ToString(); }
public async Task CanGetState() { var serverAddress = "inproc://get-state-test"; var serverSocket = new PairSocket(); serverSocket.Bind(serverAddress); var processor = new TransactionProcessor(serverAddress); processor.Start(); var context = new TransactionContext(processor, "context"); var addresses = new[] { "address1", "address2" }; var task = Task.Run(() => { var message = new Message(); message.MergeFrom(serverSocket.ReceiveFrameBytes()); Assert.Equal(MessageType.TpStateGetRequest, message.MessageType); var response = new TpStateGetResponse(); response.Entries.AddRange(addresses.Select(x => new TpStateEntry { Address = x, Data = ByteString.Empty })); serverSocket.SendFrame(response.Wrap(message, MessageType.TpStateGetResponse).ToByteArray()); }); var stateResponse = await context.GetStateAsync(addresses); Assert.Equal(addresses.Length, stateResponse.Count()); }
private static void E2E() { string sellerPhoneNumber = "07434"; string buyerPhoneNumber = "34075"; string donatorPhoneNumber = "1234"; ApiServer apiServer = new ApiServer("http://africatransferapi.azurewebsites.net/api/"); apiServer.AddPhoneNUmber(sellerPhoneNumber); apiServer.AddPhoneNUmber(buyerPhoneNumber); apiServer.AddPhoneNUmber(donatorPhoneNumber); var x = apiServer.GetAuthModels(); TransactionProcessor processor = new TransactionProcessor(apiServer); processor.AddBankTransfer(44, donatorPhoneNumber); processor.AddMobileTransfer(23, donatorPhoneNumber, buyerPhoneNumber); var product = processor.AddProduct(new Product { Name = "Capriciosa", Price = 22 }); var orderId = processor.AddOrder(new List <OrderLine>() { new OrderLine { ProductID = product.ID, Quantity = 2 } }, sellerPhoneNumber); var order = processor.GetOrder(orderId); var orderTotal = order.OrderLines.Sum(o => o.ProductPrice); processor.ConfirmOrder(order, buyerPhoneNumber); }
public async void AddOrder(object sender, EventArgs e) { TransactionProcessor processor = new TransactionProcessor(); var order = processor.GetOrder(OrderId); //await Navigation.PushAsync(new ) }
public static void Main(string[] args = null) { var lines = File.ReadAllText("./transactions.txt"); var result = TransactionProcessor.Default().ProcessLines(lines); Console.WriteLine(string.Join("\r\n", result)); }
public void Setup() { IDb blocksDb = new MemDb(); IDb blocksInfoDb = new MemDb(); IDb headersDb = new MemDb(); ChainLevelInfoRepository repository = new ChainLevelInfoRepository(blocksInfoDb); ISpecProvider specProvider = MainnetSpecProvider.Instance; _blockTree = new BlockTree(blocksDb, headersDb, blocksInfoDb, repository, specProvider, NullBloomStorage.Instance, new SyncConfig(), LimboLogs.Instance); ISnapshotableDb stateDb = new StateDb(); ISnapshotableDb codeDb = new StateDb(); StateProvider stateProvider = new StateProvider(stateDb, codeDb, LimboLogs.Instance); StorageProvider storageProvider = new StorageProvider(stateDb, stateProvider, LimboLogs.Instance); BlockhashProvider blockhashProvider = new BlockhashProvider(_blockTree, LimboLogs.Instance); VirtualMachine virtualMachine = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, specProvider, LimboLogs.Instance); TransactionProcessor transactionProcessor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, LimboLogs.Instance); BlockProcessor blockProcessor = new BlockProcessor(specProvider, Always.Valid, NoBlockRewards.Instance, transactionProcessor, stateDb, codeDb, stateProvider, storageProvider, NullTxPool.Instance, NullReceiptStorage.Instance, LimboLogs.Instance); var txRecovery = new RecoverSignatures(new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance), NullTxPool.Instance, specProvider, LimboLogs.Instance); _processor = new BlockchainProcessor(_blockTree, blockProcessor, txRecovery, LimboLogs.Instance, BlockchainProcessor.Options.NoReceipts); Block genesis = Build.A.Block.Genesis.TestObject; _blockTree.SuggestBlock(genesis); _processor.Process(genesis, ProcessingOptions.None, NullBlockTracer.Instance); _tracer = new Tracer(stateProvider, _processor); }
public void processThreeMonthsOfTransactionsTest() { List <Transaction> goodProcessedTransactions = new List <Transaction>(); TransactionProcessor transactionProcessor = new TransactionProcessor(); transactionProcessor.returnThreeMonthsOfTransactions(goodProcessedTransactions, DateTime.Now); }
public void Setup() { var random = new Random(Seed: 145); var utxos = new List <Coin>(); _tp = CreateTransactionProcessorAsync().Result; // Crediting transactions for (var i = 0; i < 100; i++) { var stx = CreateCreditingTransaction(GetP2wpkhScript(_tp), Money.Coins(2.0m), true); utxos.Add(stx.Transaction.Outputs.AsCoins().First()); _tp.Process(stx); } _txs = new List <SmartTransaction>(TRANSACTIONS); for (var i = 0; i < TRANSACTIONS; i++) { var numOfCoinsToSpend = Math.Min(random.Next(1, 3), utxos.Count()); var coinsToSpend = utxos.Take(numOfCoinsToSpend); var stx = CreateSpendingTransaction(coinsToSpend, new Key().PubKey.ScriptPubKey, GetP2wpkhScript(_tp)); utxos.Add(stx.Transaction.Outputs.AsCoins().Last()); _txs.Add(stx); } }
/// <inheritdoc /> public Transaction CompleteTransactionImport(int splitwiseId, int categoryId, Maybe <int> accountId) { var splitwiseTransaction = this.Context.SplitwiseTransactions.GetEntity(splitwiseId); var splitwiseAccount = this.Context.Accounts.GetSplitwiseEntity(); var category = this.Context.Categories.GetEntity(categoryId, allowObsolete: false); return(this.ConcurrentInvoke(() => { var processor = new TransactionProcessor(this.Context, this.splitwiseContext); var account = accountId .Select(id => this.Context.Accounts.GetEntity(id)) .ValueOrElse(splitwiseAccount); var transaction = splitwiseTransaction.ToTransaction(account, category); processor.ProcessIfNeeded(transaction); this.Context.Transactions.Add(transaction); this.Context.SaveChanges(); return transaction.AsTransaction(); })); }
public void Transactions_should_be_charged() { var lines = File.ReadAllText("./transactions.txt"); var processor = TransactionProcessor.Default(); var actual = processor.ProcessLines(lines); actual.Should().BeEquivalentTo(new[] { new Fee("2018-09-01", "7-ELEVEN", 30.00m), new Fee("2018-09-04", "CIRCLE_K", 29.80m), new Fee("2018-09-07", "TELIA", 29.90m), new Fee("2018-09-09", "NETTO", 30.00m), new Fee("2018-09-13", "CIRCLE_K", 0.80m), new Fee("2018-09-16", "TELIA", 0.90m), new Fee("2018-09-19", "7-ELEVEN", 1.00m), new Fee("2018-09-22", "CIRCLE_K", 0.80m), new Fee("2018-09-25", "TELIA", 0.90m), new Fee("2018-09-28", "7-ELEVEN", 1.00m), new Fee("2018-09-30", "CIRCLE_K", 0.80m), new Fee("2018-10-01", "7-ELEVEN", 30.00m), new Fee("2018-10-04", "CIRCLE_K", 29.80m), new Fee("2018-10-07", "TELIA", 29.90m), new Fee("2018-10-10", "NETTO", 30.00m), new Fee("2018-10-13", "CIRCLE_K", 0.80m), new Fee("2018-10-16", "TELIA", 0.90m), new Fee("2018-10-19", "7-ELEVEN", 1.00m), new Fee("2018-10-22", "CIRCLE_K", 0.80m), new Fee("2018-10-25", "TELIA", 0.90m), new Fee("2018-10-28", "7-ELEVEN", 1.00m), new Fee("2018-10-30", "CIRCLE_K", 0.80m), }); }
private void LoadRepository(string addyPk, bool testRegion, string version, Blockchain blockchain) { _helper = new Helper(); if (string.IsNullOrEmpty(addyPk)) { _neoWallet = null; } else if (addyPk.First() == 'A' || addyPk.Substring(0, 2) == "0x") { _neoWallet = new NeoWallet(addyPk); } else { var pkSecure = _helper.GetSecureString(addyPk); _neoWallet = new NeoWallet(pkSecure); } var testSwitch = testRegion ? "test-" : string.Empty; _baseUrl = $"https://{testSwitch}api.switcheo.network"; _restRepo = new RESTRepository(); _security = new Security(); _txnProcessor = new TransactionProcessor(); _tokens = GetTokens(); _blockchain = blockchain; _contract_version = version; _contract_hash = GetContractHash(); _dtHelper = new DateTimeHelper(); _systemTimetamp = TimestampCompare(); }
protected void Prepare() { _wallet = new DevWallet(new WalletConfig(), _logManager); _feeAccount = _wallet.GetAccounts()[0]; _consumerAccount = _wallet.GetAccounts()[1]; _providerAccount = _wallet.GetAccounts()[2]; _ndmConfig = new NdmConfig(); IReleaseSpec spec = _releaseSpec; ISpecProvider specProvider = new SingleReleaseSpecProvider(spec, 99); StateDb stateDb = new StateDb(); _state = new StateProvider(stateDb, new StateDb(), _logManager); StorageProvider storageProvider = new StorageProvider(stateDb, _state, _logManager); _state.CreateAccount(_consumerAccount, 1000.Ether()); _state.CreateAccount(_providerAccount, 1.Ether()); _state.Commit(spec); _state.CommitTree(); VirtualMachine machine = new VirtualMachine(_state, storageProvider, Substitute.For <IBlockhashProvider>(), _logManager); TransactionProcessor processor = new TransactionProcessor(specProvider, _state, storageProvider, machine, _logManager); _bridge = new BlockchainBridge(processor, _releaseSpec); TxReceipt receipt = DeployContract(Bytes.FromHexString(ContractData.GetInitCode(_feeAccount))); _ndmConfig.ContractAddress = receipt.ContractAddress.ToString(); }
protected async Task Prepare() { _wallet = new DevWallet(new WalletConfig(), _logManager); _feeAccount = _wallet.GetAccounts()[0]; _consumerAccount = _wallet.GetAccounts()[1]; _providerAccount = _wallet.GetAccounts()[2]; _ndmConfig = new NdmConfig(); IReleaseSpec spec = _releaseSpec; ISpecProvider specProvider = new SingleReleaseSpecProvider(spec, 99); StateDb stateDb = new StateDb(); _state = new StateProvider(stateDb, new StateDb(), _logManager); StorageProvider storageProvider = new StorageProvider(stateDb, _state, _logManager); _state.CreateAccount(_consumerAccount, 1000.Ether()); _state.CreateAccount(_providerAccount, 1.Ether()); _state.Commit(spec); _state.CommitTree(); VirtualMachine machine = new VirtualMachine(_state, storageProvider, Substitute.For <IBlockhashProvider>(), specProvider, _logManager); TransactionProcessor processor = new TransactionProcessor(specProvider, _state, storageProvider, machine, _logManager); _bridge = new BlockchainBridge(processor); TxReceipt receipt = await DeployContract(Bytes.FromHexString(ContractData.GetInitCode(_feeAccount))); ((NdmConfig)_ndmConfig).ContractAddress = receipt.ContractAddress.ToString(); _contractAddress = receipt.ContractAddress; _txPool = new TxPool.TxPool(new InMemoryTxStorage(), Timestamper.Default, new EthereumEcdsa(specProvider.ChainId, _logManager), specProvider, new TxPoolConfig(), _state, _logManager); _ndmBridge = new NdmBlockchainBridge(_bridge, _bridge, _bridge, _bridge); }
public BlockchainBridge(TransactionProcessor processor, IReleaseSpec spec) { _spec = spec; _receiptsTracer = new BlockReceiptsTracer(new SingleReleaseSpecProvider(_spec, 99), Substitute.For <IStateProvider>()); _processor = processor; _receiptsTracer.SetOtherTracer(GethTracer); _receiptsTracer.StartNewBlockTrace(_headBlock); }
public Transaction(Guid id, Guid orderID, decimal amount, DateTime executed, string authCode, string notes, TransactionProcessor processor) { ID = id; OrderID = orderID; Amount = amount; DateExecuted = executed; AuthorizationCode = authCode; Notes = notes; Processor = processor; }
public static Transaction Create(decimal amount, DateTime executed, string authCode, string notes, TransactionProcessor processor) { var trans = new Transaction(); trans.ID = Guid.NewGuid(); trans.Amount = amount; trans.DateExecuted = executed; trans.AuthorizationCode = authCode; trans.Notes = notes; trans.Processor = processor; return trans; }
void CreateTransaction(Order order, string authCode, decimal payment, TransactionProcessor processor) { //create a transaction if (order.Transactions == null) order.Transactions = new LazyList<Transaction>(); order.Transactions.Add(new Transaction(order.ID, payment, authCode, processor)); }
public Transaction(Guid orderID, decimal amount, string authCode, TransactionProcessor processor) : this(Guid.NewGuid(), orderID, amount, DateTime.Now, authCode, "",processor) { }
public static Transaction Create(decimal amount, string authCode, TransactionProcessor processor) { return Create(amount, DateTime.Now, authCode, "", processor); }