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);
}
){kind=link}