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