public static string DoSignVTHOTx(List <string[]> transactions, string privateKey, bool isSend, int?gasLimit) { byte chainTag = 0; byte[] blockRef = null; var clauses = new List <ToClause>(); foreach (var transaction in transactions) { var amount = Amount.VTHO(); amount.SetDecimalAmount(transaction[1]); clauses.Add( ERC20Contract.BuildTranferToClause(ERC20Token.VTHO, Address.FromHexString(transaction[0]), amount)); chainTag = ByteUtils.ToByteArray(transaction[2])[0]; blockRef = transaction[3] == null?BlockchainClient.GetBlockRef(null).ToByteArray() : ByteUtils.ToByteArray(transaction[3]); } int gas = clauses.Count * gasLimit ?? 80000; var rawTransaction = RawTransactionFactory.Instance.CreateRawTransaction(chainTag, blockRef, 720, gas, (byte)0x0, CryptoUtils.GenerateTxNonce(), clauses.ToArray()); if (isSend) { var result = TransactionClient.SignThenTransfer(rawTransaction, ECKeyPair.Create(privateKey)); return(JsonConvert.SerializeObject(result)); } else { var result = TransactionClient.Sign(rawTransaction, ECKeyPair.Create(privateKey)); return(ByteUtils.ToHexString(result.Encode(), Prefix.ZeroLowerX)); } }
public void RefundPaymentTest() { var request = new TransparentRedirectRequest("http://www.eway.com.au", TransactionType.Purchase); request = SetupRequest(request) as TransparentRedirectRequest; var response = client.ProcessPayment <TransparentRedirectResponse>(request); Assert.IsNotNull(response.AccessCode); Assert.IsNotNull(response.FormActionURL); Assert.IsNull(response.Errors); SubmitPaymentForm(response.FormActionURL, response.AccessCode); var accessResponse = client.GetAccessCodeResult(response.AccessCode); Assert.IsNull(accessResponse.Errors); Assert.IsTrue((bool)accessResponse.TransactionStatus); var refundClient = new TransactionClient(CredentialUtils.GetTestCredentials(), true); var refundRequest = new RefundRequest(); refundRequest = SetupRequest(refundRequest) as RefundRequest; var refundResponse = refundClient.RefundTransaction(refundRequest, accessResponse.TransactionID.ToString()); Assert.IsNull(refundResponse.Errors); var queryResponse = refundClient.QueryTransaction(accessResponse.TransactionID.ToString()); Assert.AreEqual(1, queryResponse.Transactions.Count); Assert.AreEqual(string.Empty, queryResponse.Errors); }
public BlockchainTransactionService(BlockchainNetworkConnection blockchainNetworkConnection) { BlockchainNetworkConnection = blockchainNetworkConnection; TransactionClient = new TransactionClient(blockchainNetworkConnection); NemUtils = new NemUtils(blockchainNetworkConnection.NetworkType); BlockchainMessageService = new BlockchainMessageService(blockchainNetworkConnection); }
private void button2_Click(object sender, EventArgs e) { try { if (string.IsNullOrEmpty(textBox1.Text) || string.IsNullOrEmpty(textBox9.Text)) { throw new Exception("Err: User and/or password cannot be null"); } richTextBox1.Text = ""; TransactionClient client = new TransactionClient(); using (new OperationContextScope(client.InnerChannel)) { HttpRequestMessageProperty requestMessage = new HttpRequestMessageProperty(); requestMessage.Headers["username"] = textBox1.Text; requestMessage.Headers["password"] = textBox9.Text; OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = requestMessage; string arg0 = textBox2.Text, arg1 = DateTime.Now.ToString("yyyyMMddHHmmss"), arg2 = textBox4.Text, arg3 = textBox5.Text, arg4 = textBox6.Text, arg5 = textBox7.Text, arg6 = textBox8.Text; string s = client.setToken(arg0, arg1, arg2, arg3, arg4, arg5, arg6); richTextBox1.Text = s; } } catch (Exception ex) { richTextBox1.Text = ex.Message; } }
public IActionResult NewTransaction(TransactionClient transaction) { var sign = RSA.RSA.Sign(transaction.sender_private_key, transaction.ToString()); var response = new { transaction = transaction, signature = sign }; return(Ok(response)); }
public MoneyTransferBl(Wallet wallet, TransactionClient trClient) { _wallet = wallet; _trClient = trClient; _bitcoinConverter = new WebAPIHelper(); _bitcoinConverter.Run(APIUrls.BitcoinRateAPIUrl); }
public void simple_synchronous_call_gettxoutputs_returns_result() { TransactionClient client = new TransactionClient(); TxOutputs result = client.GetTxOutputs(Network.Doge, "6f47f0b2e1ec762698a9b62fa23b98881b03d052c9d8cb1d16bb0b04eb3b7c5b"); Assert.IsNotNull(result); Assert.IsTrue(result.Status == Consts.Success); Assert.IsTrue(result.Data.Txid == "6f47f0b2e1ec762698a9b62fa23b98881b03d052c9d8cb1d16bb0b04eb3b7c5b"); }
internal BlockchainTransactionService(BlockchainNetworkConnection blockchainNetworkConnection, BlockchainMessageService blockchainMessageService, TransactionClient transactionClient, NemUtils nemUtils) { BlockchainNetworkConnection = blockchainNetworkConnection; BlockchainMessageService = blockchainMessageService; TransactionClient = transactionClient; NemUtils = nemUtils; }
public void simple_synchronous_call_getconfidence_returns_result() { TransactionClient client = new TransactionClient(); Confidence result = client.GetConfidence(Network.Bitcoin, "871265cc6efa69a749282321b19a22d3ed6cccff1995d1ce34323a6006b943eb"); Assert.IsNotNull(result); Assert.IsTrue(result.Status == Consts.Success); Assert.IsTrue(result.Data.Txid == "871265cc6efa69a749282321b19a22d3ed6cccff1995d1ce34323a6006b943eb"); }
public static TransactionClient CreateTransactionClient(AccountType accountType, Account account) { var generatedType = GetGeneratedAccountType(accountType); TransactionClient client = (TransactionClient)Activator.CreateInstance(generatedType); client.Account = account; return(client); }
private Transaction GetTransaction(string transactionHash) { try { return(TransactionClient.GetTransaction(transactionHash).Wait()); } catch (Exception ex) { throw new GetTransactionFailureException($"Unable to get transaction for {transactionHash}", ex); } }
public void simple_synchronous_call_istxspent_returns_result() { int outputNum = 0; TransactionClient client = new TransactionClient(); TxOutputSpent result = client.IsTxOutputSpent(Network.Doge, "6f47f0b2e1ec762698a9b62fa23b98881b03d052c9d8cb1d16bb0b04eb3b7c5b", outputNum); Assert.IsNotNull(result); Assert.IsTrue(result.Status == Consts.Success); Assert.IsTrue(result.Data.Txid == "6f47f0b2e1ec762698a9b62fa23b98881b03d052c9d8cb1d16bb0b04eb3b7c5b"); Assert.IsTrue(result.Data.OutputNo == outputNum); Assert.IsTrue(result.Data.IsSpent); }
public HttpResponseMessage AddFunds(Transaction oTransaction) { if (!ModelState.IsValid) { return(Request.CreateResponse(HttpStatusCode.BadRequest)); } TransactionClient oCustRepo = kernel.Get <TransactionClient>(); oCustRepo.AddFunds(oTransaction); return(Request.CreateResponse(HttpStatusCode.OK)); }
public override Transaction DoVoid(VoidTransactionRequest voidRequest) { VerifyStatus(); Payment payment = voidRequest.Payment; if (payment == null) { throw new ArgumentNullException("request.Payment"); } Transaction authorizeTransaction = voidRequest.AuthorizeTransaction; if (authorizeTransaction == null) { throw new ArgumentNullException("transactionRequest.AuthorizeTransaction"); } CreditCardRequest request = InitializeVoidRequest(payment, authorizeTransaction); CreditCardResponse response = null; //RECORD REQUEST if (this.UseDebugMode) { string reqDebug = BuildRequestDebug(request); this.RecordCommunication(this.Name, CommunicationDirection.Send, reqDebug, null); } //TODO : Test mode is not supported. if (this.UseTestMode) { response = (CreditCardResponse)TransactionClient.doTransaction(request, this.AccountToken); } else { response = (CreditCardResponse)TransactionClient.doTransaction(request, this.AccountToken); } if (response != null) { //RECORD RESPONSE if (this.UseDebugMode) { string respDebug = BuildResponseDebug(response); this.RecordCommunication(this.Name, CommunicationDirection.Receive, respDebug, null); } return(ProcessResponse(payment, response, TransactionType.Void, voidRequest.Amount)); } else { throw new Exception("Operation Failed, Response is null."); } }
public void simple_synchronous_call_getdisplaydata_returns_result() { TransactionClient client = new TransactionClient(); TransactionDisplayData result = client.GetDisplayData(Network.Doge, "6f47f0b2e1ec762698a9b62fa23b98881b03d052c9d8cb1d16bb0b04eb3b7c5b"); Assert.IsNotNull(result); Assert.IsTrue(result.Status == Consts.Success); Assert.IsTrue(result.Data.Txid == "6f47f0b2e1ec762698a9b62fa23b98881b03d052c9d8cb1d16bb0b04eb3b7c5b"); Assert.IsTrue(result.Data.BlockNo == 191172); Assert.IsTrue(result.Data.Time == 1398122840); Assert.IsTrue(result.Data.Inputs.Count > 0); Assert.IsTrue(result.Data.Outputs.Count > 0); }
public static TransactionResult GetTransaction(string transactionGuidInput, string paymentGuidInput, string transactioGroupInput) { Guid transactionGuid = Guid.Empty; Guid paymentGuid = Guid.Empty; Guid transactionGroupGuid = Guid.Empty; if (!Guid.TryParse(transactionGuidInput, out transactionGuid) || !Guid.TryParse(paymentGuidInput, out paymentGuid) || !Guid.TryParse(transactioGroupInput, out transactionGroupGuid)) { return(null); } Payment payment = Payment.CreateManager().Load(paymentGuid, GuidType.Internal); if (payment == null) { return(null); } ServiceLookupMethodMap slmm = ServiceLookupMethodMap.CreateManager().Load(payment.ServiceOffer.Service, payment.PaymentRequest.Customer.Country, LookupMethod.Wap); TransactionClient transactionClient = new TransactionClient(); transactionClient.AttachLogWriter(new CashflowLog(payment.ServiceOffer.Service)); GetTransactionsRequest getTransactionRequest = new GetTransactionsRequest(RequestMode.Default, payment.ExternalPaymentGuid.ToString(), slmm.PaymentConfiguration.PaymentCredentials.Username, slmm.PaymentConfiguration.PaymentCredentials.Password, transactionGroupGuid, null); GetTransactionsResponse getTransactionResponse = transactionClient.GetTransactions(getTransactionRequest, null); foreach (Cashflow.Message.Data.Transaction transaction in getTransactionResponse.Transactions) { if (transaction.TransactionID == transactionGuid) { return new TransactionResult() { Transaction = transaction, Username = slmm.PaymentConfiguration.PaymentCredentials.Username, Password = slmm.PaymentConfiguration.PaymentCredentials.Password } } } ; return(null); }
public void PrepareNewTransaction() { Transaction transaction = new Transaction { CashboxId = _data.Cashbox.IdCashbox, CashierId = _data.Cashier.IdCashier, Date = DateTime.Now }; TransactionClient transactionClient = new TransactionClient(_data.Token); Transaction newTransaction = transactionClient.CreateNew(transaction); _data.Transaction = newTransaction; }
public void should_simple_synchronous_call_getblockdisplaydata_hash_with_bad_height_throws_exception() { TransactionClient client = new TransactionClient(); Exception ex = null; try { client.GetDisplayData(Network.Doge, Consts.Wrong); } catch (Exception e) { ex = e; } Assert.IsNotNull(ex); }
public void should_simple_synchronous_call_gettx_with_bad_address_throws_exception() { TransactionClient client = new TransactionClient(); ExceptionWithMessage <TxidError> typedException = null; try { client.GetTx(Network.Doge, Consts.Wrong); } catch (Exception e) { typedException = e?.InnerException as ExceptionWithMessage <TxidError>; } Assert.IsNotNull(typedException); Assert.IsNotNull(typedException.ErrorMessage); Assert.IsTrue(typedException.ErrorMessage.Status == Consts.Fail); Assert.IsTrue(typedException.ErrorMessage.Data.Txid == Consts.ValidTxHashRequired); }
public IObservable <string> CreateAndAnnounceTransaction(ProximaxMessagePayloadModel messagePayload, string signerPrivateKey, string recipientPublicKey, string recipientAddress, int transactionDeadline, List <Mosaic> transactionMosaics, bool useBlockchainSecureMessage) { CheckParameter(signerPrivateKey != null, "signerPrivateKey is required"); CheckParameter(messagePayload != null, "messagePayload is required"); var message = BlockchainMessageService.CreateMessage(messagePayload, signerPrivateKey, recipientPublicKey, recipientAddress, useBlockchainSecureMessage); var recipient = GetRecipient(signerPrivateKey, recipientPublicKey, recipientAddress); var transaction = CreateTransaction(recipient, transactionDeadline, transactionMosaics, message); var signedTransaction = NemUtils.SignTransaction(signerPrivateKey, transaction); TransactionClient.Announce(signedTransaction, NemUtils.GetAddressFromPrivateKey(signerPrivateKey)); return(Observable.Return(signedTransaction.Hash)); }
protected void Initialize(string baseAddress, TimeSpan commandTimeout, string username = "", string password = "") { Client = new HttpClient(); Client.BaseAddress = new Uri(baseAddress); Client.Timeout = commandTimeout; Token = null; Security = new SecurityClient(this); Schema = new SchemaClient(this); Transaction = new TransactionClient(this); Document = new DocumentClient(this); Query = new QueryClient(this); if (string.IsNullOrWhiteSpace(username) == false) { Security.Login(username, password); } }
public void should_simple_synchronous_call_istxconfirmed_with_bad_address_throws_exception() { TransactionClient client = new TransactionClient(); ExceptionWithMessage <TxidError> typedException = null; try { client.IsTxConfirmed(Network.Doge, Consts.Wrong); } catch (Exception e) { typedException = e?.InnerException as ExceptionWithMessage <TxidError>; } Assert.IsNotNull(typedException); Assert.IsNotNull(typedException.ErrorMessage); Assert.IsTrue(typedException.ErrorMessage.Status == Consts.Fail); string withUppercaseFirst = Consts.ValidTxHashRequired.First().ToString().ToUpper() + String.Join("", Consts.ValidTxHashRequired.ToLower().Skip(1)); Assert.IsTrue(typedException.ErrorMessage.Data.Txid == withUppercaseFirst); }
public static void GetTransaction(string[] args) { if (args.Length < 3 || string.IsNullOrWhiteSpace(args[2])) { WriteLine("You have input invalid parameters."); Environment.Exit(0); } String txId = args[1]; String nodeUrl = args[2]; if (string.IsNullOrWhiteSpace(nodeUrl) && !nodeUrl.StartsWith("http")) { WriteLine("You have input invalid parameters."); Environment.Exit(0); } var nodeProvider = NodeProvider.Instance; nodeProvider.Provider = nodeUrl; nodeProvider.SocketTimeout = nodeProvider.ConnectTimeout = 5000; var transaction = TransactionClient.GetTransaction(txId, true, null); WriteLine("Transaction:" + JsonConvert.SerializeObject(transaction)); }
public static bool Refund(Cashflow.Message.Data.Transaction transaction, string username, string password) { if (transaction == null) { return(false); } TransactionClient transactionClient = new TransactionClient(); RefundTransactionRequest refundTransactionRequest = new RefundTransactionRequest(RequestMode.Synchronous, transaction.TransactionID.ToString(), username, password, transaction.TransactionID, RefundReason.Custom, "MP: Refunding our payments!", null); RefundTransactionResponse refundTransactionResponse = transactionClient.RefundTransaction(refundTransactionRequest, null); return(refundTransactionResponse.Status.Code == MessageStatusCode.Success); }
public async Task Connect(ConnectionSettings settings) { if (_session != null) { throw new InvalidOperationException("Cannot connect because the client is already connected"); } _commonClient = new CommonClient(); _hashClient = new HashClient(); _listClient = new ListClient(); _scriptClient = new ScriptClient(); _stringClient = new StringClient(); _transactionClient = new TransactionClient(); _setClient = new SetClient(); _subscriptionClient = new SubscriptionClient(); _session = await _commonClient.Connect(settings).ConfigureAwait(false); if (!_session.IsOpen) { throw new IOException("Session could not be opened"); } OnConnected?.Invoke(this); }
public PayPros Initiate(PayPros payment, string cardNumber) { #region CREATE REQUEST CreditCardRequest request = new CreditCardRequest(); try { request.setCreditCardNumber(cardNumber); if (!string.IsNullOrEmpty(payment.CCV)) { request.setCreditCardVerificationNumber(payment.CCV); } request.setExpireMonth(payment.CCExpireMonth); request.setExpireYear(payment.CCExpireYear); request.setChargeType(CreditCardRequest.SALE); request.setPurchaseOrderNumber(payment.PaymentAccount); request.setChargeTotal((double)payment.PaymentAmount); request.setPartialApprovalFlag(false); if (!string.IsNullOrEmpty(payment.RequestingOrigin)) { request.setCustomerIpAddress(payment.RequestingOrigin); } switch (_account) { case PaymentAccounts.UBO: request.setIndustry("DIRECT_MARKETING"); break; case PaymentAccounts.Judicial: break; default: break; } switch (_method) { case PaymentMethods.Web: request.setTransactionConditionCode(5); break; case PaymentMethods.Phone: request.setTransactionConditionCode(2); break; default: break; } } catch (Exception) { throw new ArgumentException("Unable to create request"); } #endregion #region PROCESS REQUEST string payprosToken = (payment.IsTest ? testTokens[_account] : accountTokens[_account]); CreditCardResponse response = (CreditCardResponse)TransactionClient.doTransaction(request, payprosToken); payment.responseCode = (payment.IsTest ? (-1 * response.getResponseCode()) : response.getResponseCode());//flip sign of response code for test payments (keeps it from being written for processing) payment.responseText = response.getResponseCodeText(); payment.retryRecommended = response.getRetryRecommended(); payment.timestamp = response.getTimeStamp(); #endregion #region RECORD RESPONSE double authorizedAmount = 0; if (double.TryParse(response.getAuthorizedAmount(), out authorizedAmount)) { payment.PaymentAmount = (decimal)authorizedAmount; } long orderID; if (long.TryParse(response.getOrderId(), out orderID)) { payment.orderID = orderID; } long batchID; if (long.TryParse(response.getBatchId(), out batchID)) { payment.batchID = batchID; } long bankApprovalCode; if (long.TryParse(response.getBankApprovalCode(), out bankApprovalCode)) { payment.bankApprovalCode = bankApprovalCode; } long bankTransactionId; if (long.TryParse(response.getBankTransactionId(), out bankTransactionId)) { payment.bankTransactionId = bankTransactionId; } int creditCardVerification; if (int.TryParse(response.getCreditCardVerificationResponse(), out creditCardVerification)) { payment.creditCardVerificationResponse = creditCardVerification; } #endregion return(payment); }
public static string SendRawVETTx(string rawTransaction) { var result = TransactionClient.Transfer(rawTransaction); return(JsonConvert.SerializeObject(result)); }
public override AuthorizeRecurringTransactionResponse DoAuthorizeRecurring(AuthorizeRecurringTransactionRequest authorizeRequest) { VerifyStatus(); Payment payment = authorizeRequest.Payment; if (payment == null) { throw new ArgumentNullException("request.Payment"); } Order order = payment.Order; if (order == null) { throw new ArgumentNullException("request.Payment.Order"); } User user = order.User; if (user == null) { throw new ArgumentNullException("request.Payment.Order.User"); } AuthorizeRecurringTransactionResponse response = new AuthorizeRecurringTransactionResponse(); AuthorizeTransactionRequest authRequest; Transaction tr1, tr2, errTrans; //VALIDATE THE PAYMENT PERIOD int payPeriod = GetPayPeriod(authorizeRequest); if (payPeriod == int.MinValue) { errTrans = Transaction.CreateErrorTransaction(this.PaymentGatewayId, authorizeRequest, "E", "The specified payment interval is not valid for this processor."); return(new AuthorizeRecurringTransactionResponse(errTrans)); } if (authorizeRequest.RecurringChargeSpecified) { //make a sale transaction first authRequest = new AuthorizeTransactionRequest(authorizeRequest.Payment, authorizeRequest.RemoteIP); authRequest.Capture = true; authRequest.Amount = authorizeRequest.Amount; tr1 = DoAuthorize(authRequest); if (tr1.TransactionStatus != TransactionStatus.Successful) { errTrans = Transaction.CreateErrorTransaction(PaymentGatewayId, authorizeRequest, "E", "Authorization Failed."); errTrans.TransactionType = TransactionType.AuthorizeRecurring; response.AddTransaction(tr1); response.AddTransaction(errTrans); response.Status = TransactionStatus.Failed; return(response); } response.AddTransaction(tr1); } RecurringRequest request = InitializeAuthRecurringRequest(authorizeRequest, payPeriod); RecurringResponse recResponse = null; //RECORD REQUEST : TODO /*if (this.UseDebugMode) * { * string reqDebug = BuildRequestDebug(request); * this.RecordCommunication(this.Name, CommunicationDirection.Send, reqDebug); * }*/ //TODO : Test mode is not supported. if (this.UseTestMode) { recResponse = (RecurringResponse)TransactionClient.doTransaction(request, this.AccountToken); } else { recResponse = (RecurringResponse)TransactionClient.doTransaction(request, this.AccountToken); } if (recResponse != null) { //RECORD RESPONSE if (this.UseDebugMode) { string respDebug = BuildRecurringResponseDebug(recResponse); this.RecordCommunication(this.Name, CommunicationDirection.Receive, respDebug, null); } tr2 = ProcessRecurringResponse(authorizeRequest, recResponse); response.AddTransaction(tr2); response.Status = tr2.TransactionStatus; return(response); } else { throw new Exception("Operation Failed, Response is null."); } }
public void FinalizeTransaction() { TransactionClient transactionClient = new TransactionClient(_data.Token); transactionClient.UpdateTransaction(_data.Transaction); }