public virtual MvcMailMessage EmailConfirmation(ReceiptResponse receipt, int merchantId, string email)
{
var merchant = _blackstoneService.FindMerchant(merchantId);
return merchant.IsFullCarga
? EmailConfirmationForFullCarga(receipt, merchantId, GetReceiptConfigForFullCarga(email))
: EmailConfirmationForBlackstonePos(receipt, GetReceiptConfigForBlackstone(email));
}
public void ContractTransaction_Call_Method_Consumes_All_Gas_Throws_OutOfGasException()
{
// Ensure fixture is funded.
this.mockChain.MineBlocks(1);
// Deploy contract
ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/InfiniteLoop.cs");
Assert.True(compilationResult.Success);
BuildCreateContractTransactionResponse preResponse = this.node1.SendCreateContractTransaction(compilationResult.Compilation, 0);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
Assert.NotNull(this.node1.GetCode(preResponse.NewContractAddress));
decimal amount = 0;
ulong gasLimit = SmartContractFormatLogic.GasLimitCallMinimum + 1;
Money senderBalanceBefore = this.node1.WalletSpendableBalance;
uint256 currentHash = this.node1.GetLastBlock().GetHash();
BuildCallContractTransactionResponse response = this.node1.SendCallContractTransaction(nameof(InfiniteLoop.Loop), preResponse.NewContractAddress, amount, gasLimit: gasLimit, gasPrice: 200);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
NBitcoin.Block lastBlock = this.node1.GetLastBlock();
// Blocks progressed
Assert.NotEqual(currentHash, lastBlock.GetHash());
// Block does not contain a refund transaction
Assert.Equal(2, lastBlock.Transactions.Count);
// Receipt is correct
ReceiptResponse receipt = this.node1.GetReceipt(response.TransactionId.ToString());
Assert.Equal(lastBlock.GetHash().ToString(), receipt.BlockHash);
Assert.Equal(response.TransactionId.ToString(), receipt.TransactionHash);
Assert.Empty(receipt.Logs);
Assert.False(receipt.Success);
Assert.Equal(gasLimit, receipt.GasUsed); // All the gas should have been consumed
Assert.Null(receipt.NewContractAddress);
Assert.Equal(this.node1.MinerAddress.Address, receipt.From);
Assert.StartsWith("Execution ran out of gas.", receipt.Error);
Assert.Equal(preResponse.NewContractAddress, receipt.To);
}
public IActionResult GetReceipt([FromQuery] string txHash)
{
uint256 txHashNum = new uint256(txHash);
Receipt receipt = this.receiptRepository.Retrieve(txHashNum);
if (receipt == null)
{
this.logger.LogTrace("(-)[RECEIPT_NOT_FOUND]");
return(ErrorHelpers.BuildErrorResponse(HttpStatusCode.BadRequest,
"Receipt not found.",
"Could not find a stored transaction for this hash."));
}
var receiptResponse = new ReceiptResponse(receipt, this.network);
return(Json(receiptResponse));
}
public void ContractTransaction_InvalidByteCode()
{
// Ensure fixture is funded.
this.mockChain.MineBlocks(1);
decimal amount = 25;
Money senderBalanceBefore = this.node1.WalletSpendableBalance;
uint256 currentHash = this.node1.GetLastBlock().GetHash();
// Create transaction with random bytecode.
var random = new Random();
byte[] bytes = new byte[100];
random.NextBytes(bytes);
BuildCreateContractTransactionResponse response = this.node1.SendCreateContractTransaction(bytes, amount);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
NBitcoin.Block lastBlock = this.node1.GetLastBlock();
// Blocks progressed
Assert.NotEqual(currentHash, lastBlock.GetHash());
// Contract wasn't created
Assert.Null(this.node1.GetCode(response.NewContractAddress));
// Block contains a refund transaction
Assert.Equal(3, lastBlock.Transactions.Count);
Transaction refundTransaction = lastBlock.Transactions[2];
uint160 refundReceiver = this.senderRetriever.GetAddressFromScript(refundTransaction.Outputs[0].ScriptPubKey).Sender;
Assert.Equal(this.node1.MinerAddress.Address, refundReceiver.ToBase58Address(this.node1.CoreNode.FullNode.Network));
Assert.Equal(new Money((long)amount, MoneyUnit.BTC), refundTransaction.Outputs[0].Value);
// Receipt is correct
ReceiptResponse receipt = this.node1.GetReceipt(response.TransactionId.ToString());
Assert.Equal(lastBlock.GetHash().ToString(), receipt.BlockHash);
Assert.Equal(response.TransactionId.ToString(), receipt.TransactionHash);
Assert.Empty(receipt.Logs);
Assert.False(receipt.Success);
Assert.Equal(GasPriceList.CreateCost, receipt.GasUsed);
Assert.Null(receipt.NewContractAddress);
Assert.Equal(this.node1.MinerAddress.Address, receipt.From);
Assert.Null(receipt.To);
}
public void ContractTransaction_ValidationFailure()
{
// Ensure fixture is funded.
this.mockChain.MineBlocks(1);
decimal amount = 25;
uint256 currentHash = this.node1.GetLastBlock().GetHash();
// Create transaction with non-deterministic bytecode.
ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/NonDeterministicContract.cs");
Assert.True(compilationResult.Success);
BuildCreateContractTransactionResponse response = this.node1.SendCreateContractTransaction(compilationResult.Compilation, amount);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
NBitcoin.Block lastBlock = this.node1.GetLastBlock();
// Blocks progressed
Assert.NotEqual(currentHash, lastBlock.GetHash());
// Contract wasn't created
Assert.Null(this.node2.GetCode(response.NewContractAddress));
// Block contains a refund transaction
Assert.Equal(3, lastBlock.Transactions.Count);
Transaction refundTransaction = lastBlock.Transactions[2];
uint160 refundReceiver = this.senderRetriever.GetAddressFromScript(refundTransaction.Outputs[0].ScriptPubKey).Sender;
Assert.Equal(this.node1.MinerAddress.Address, refundReceiver.ToBase58Address(this.node1.CoreNode.FullNode.Network));
Assert.Equal(new Money((long)amount, MoneyUnit.BTC), refundTransaction.Outputs[0].Value);
// Receipt is correct
ReceiptResponse receipt = this.node1.GetReceipt(response.TransactionId.ToString());
Assert.Equal(lastBlock.GetHash().ToString(), receipt.BlockHash);
Assert.Equal(response.TransactionId.ToString(), receipt.TransactionHash);
Assert.Empty(receipt.Logs);
Assert.False(receipt.Success);
Assert.Equal(GasPriceList.CreateCost, receipt.GasUsed);
Assert.Null(receipt.NewContractAddress);
Assert.Equal(this.node1.MinerAddress.Address, receipt.From);
Assert.Null(receipt.To);
}
public void Local_Call_Should_Produce_Logs_And_Transfers()
{
// Demonstrates some potentially unusual behaviour when saving contract state.
var localExecutor = this.mockChain.Nodes[0].CoreNode.FullNode.NodeService <ILocalExecutor>();
// Ensure fixture is funded.
this.mockChain.MineBlocks(1);
// Deploy contract
ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/LocalCallTests.cs");
Assert.True(compilationResult.Success);
BuildCreateContractTransactionResponse preResponse = this.node1.SendCreateContractTransaction(compilationResult.Compilation, 10);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
Assert.NotNull(this.node1.GetCode(preResponse.NewContractAddress));
Assert.Equal(1000000000UL, this.node1.GetContractBalance(preResponse.NewContractAddress));
uint256 currentHash = this.node1.GetLastBlock().GetHash();
NBitcoin.Block lastBlock = this.node1.GetLastBlock();
ReceiptResponse receipt = this.node1.GetReceipt(preResponse.TransactionId.ToString());
Assert.True(receipt.Success);
// Create a log in a local call
var call = new ContractTxData(1, 100, (Gas)250000, preResponse.NewContractAddress.ToUint160(this.node1.CoreNode.FullNode.Network), nameof(LocalCallTests.CreateLog));
var createLogResult = localExecutor.Execute((ulong)this.node1.CoreNode.FullNode.ChainIndexer.Height, this.mockChain.Nodes[0].MinerAddress.Address.ToUint160(this.node1.CoreNode.FullNode.Network), 0, call);
Assert.NotEmpty(createLogResult.Logs);
RLPCollection collection = (RLPCollection)RLP.Decode(createLogResult.Logs[0].Data);
var loggedData = Encoding.UTF8.GetString(collection[0].RLPData);
Assert.Equal(nameof(LocalCallTests.CreateLog), loggedData);
// Create a transfer in a local call
call = new ContractTxData(1, 100, (Gas)250000, preResponse.NewContractAddress.ToUint160(this.node1.CoreNode.FullNode.Network), nameof(LocalCallTests.CreateTransfer));
var createTransferResult = localExecutor.Execute((ulong)this.node1.CoreNode.FullNode.ChainIndexer.Height, this.mockChain.Nodes[0].MinerAddress.Address.ToUint160(this.node1.CoreNode.FullNode.Network), 0, call);
Assert.NotEmpty(createTransferResult.InternalTransfers);
Assert.Equal(Address.Zero.ToUint160(), createTransferResult.InternalTransfers[0].To);
Assert.Equal(1UL, createTransferResult.InternalTransfers[0].Value);
}
public void ContractTransaction_AddressDoesntExist()
{
// Ensure fixture is funded.
this.mockChain.MineBlocks(1);
double amount = 25;
Money senderBalanceBefore = this.node1.WalletSpendableBalance;
uint256 currentHash = this.node1.GetLastBlock().GetHash();
// Send call to non-existent address
string nonExistentAddress = new uint160(0).ToBase58Address(this.node1.CoreNode.FullNode.Network);
Assert.Null(this.node1.GetCode(nonExistentAddress));
BuildCallContractTransactionResponse response = this.node1.SendCallContractTransaction("Method", nonExistentAddress, amount);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
NBitcoin.Block lastBlock = this.node1.GetLastBlock();
// Blocks progressed
Assert.NotEqual(currentHash, lastBlock.GetHash());
// Block contains a refund transaction
Assert.Equal(3, lastBlock.Transactions.Count);
Transaction refundTransaction = lastBlock.Transactions[2];
Assert.Single(refundTransaction.Outputs); // No transfers
uint160 refundReceiver = this.senderRetriever.GetAddressFromScript(refundTransaction.Outputs[0].ScriptPubKey).Sender;
Assert.Equal(this.node1.MinerAddress.Address, refundReceiver.ToBase58Address(this.node1.CoreNode.FullNode.Network));
Assert.Equal(new Money((long)amount, MoneyUnit.BTC), refundTransaction.Outputs[0].Value);
// Receipt is correct
ReceiptResponse receipt = this.node1.GetReceipt(response.TransactionId.ToString());
Assert.Equal(lastBlock.GetHash().ToString(), receipt.BlockHash);
Assert.Equal(response.TransactionId.ToString(), receipt.TransactionHash);
Assert.Empty(receipt.Logs);
Assert.False(receipt.Success);
Assert.Equal(GasPriceList.BaseCost, receipt.GasUsed);
Assert.Null(receipt.NewContractAddress);
Assert.Equal(this.node1.MinerAddress.Address, receipt.From);
Assert.Equal(StateTransitionErrors.NoCode, receipt.Error);
Assert.Equal(nonExistentAddress, receipt.To);
}
public void ContractTransaction_RecursiveContractCreate_OutOfGas()
{
// Ensure fixture is funded.
this.mockChain.MineBlocks(1);
decimal amount = 25;
ulong gasLimit = SmartContractFormatLogic.GasLimitMaximum;
uint256 currentHash = this.node1.GetLastBlock().GetHash();
ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/RecursiveLoopCreate.cs");
Assert.True(compilationResult.Success);
BuildCreateContractTransactionResponse response = this.node1.SendCreateContractTransaction(compilationResult.Compilation, amount, gasLimit: gasLimit);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
NBitcoin.Block lastBlock = this.node1.GetLastBlock();
// Blocks progressed
Assert.NotEqual(currentHash, lastBlock.GetHash());
// Contract was not created
Assert.Null(this.node2.GetCode(response.NewContractAddress));
// Block contains a refund transaction
Assert.Equal(3, lastBlock.Transactions.Count);
Transaction refundTransaction = lastBlock.Transactions[2];
uint160 refundReceiver = this.senderRetriever.GetAddressFromScript(refundTransaction.Outputs[0].ScriptPubKey).Sender;
Assert.Equal(this.node1.MinerAddress.Address, refundReceiver.ToBase58Address(this.node1.CoreNode.FullNode.Network));
Assert.Equal(new Money((long)amount, MoneyUnit.BTC), refundTransaction.Outputs[0].Value);
// Receipt is correct
ReceiptResponse receipt = this.node1.GetReceipt(response.TransactionId.ToString());
Assert.Equal(lastBlock.GetHash().ToString(), receipt.BlockHash);
Assert.Equal(response.TransactionId.ToString(), receipt.TransactionHash);
Assert.Empty(receipt.Logs);
Assert.False(receipt.Success);
Assert.True(receipt.GasUsed > (gasLimit - GasPriceList.BaseCost)); // The amount spent should be within 1 BaseCost of being used up.
Assert.Null(receipt.NewContractAddress);
Assert.Equal(this.node1.MinerAddress.Address, receipt.From);
Assert.Null(receipt.To);
}
internal static void Response(ReceiptResponse data)
{
if (data != null)
{
Console.WriteLine("{0:G} ========== response: {1}", DateTime.Now, JsonConvert.SerializeObject(data));
Console.WriteLine("========== n: {0} CashBoxIdentificateion:{1} ReceiptIdentification:{2} ==========", data.cbReceiptReference, data.ftCashBoxIdentification, data.ftReceiptIdentification);
foreach (var item in data.ftSignatures)
{
if (item.ftSignatureFormat == 0x03)
{
if (item.Data.Length <= 300)
{
fiskaltrust.ifPOS.TwoDCode.QR_TextChars(item.Data, 80, true);
}
else if (item.Data.Length > 300 && item.Data.Length <= 800)
{
fiskaltrust.ifPOS.TwoDCode.QR_TextChars(item.Data, 100, true);
}
else if (item.Data.Length > 800 && item.Data.Length <= 1000)
{
fiskaltrust.ifPOS.TwoDCode.QR_TextChars(item.Data, 125, true);
}
else if (item.Data.Length > 1000 && item.Data.Length <= 1200)
{
fiskaltrust.ifPOS.TwoDCode.QR_TextChars(item.Data, 150, true);
}
else if (item.Data.Length > 1200)
{
fiskaltrust.ifPOS.TwoDCode.QR_TextChars(item.Data, 200, true);
}
}
else if (item.ftSignatureFormat == 0x08)
{
fiskaltrust.ifPOS.TwoDCode.AZTEC_TextChars(item.Data, 80, true);
}
Console.WriteLine("{0}:{1}", item.Caption, item.Data);
}
}
else
{
Console.WriteLine("null-result!!!");
}
}
private async void btnReApply_Click(object sender, EventArgs e)
{
lblState.Text = "Please wait....";
receiptResponse = await supervisor.ReApply();
if (receiptResponse != null && receiptResponse.success)
{
OutputResponseInformation(receiptResponse);
lblState.Text = InProgressState;
btnStartReviewProcess.Enabled = false;
btnCompleteReviewProcess.Enabled = false;
btnPayApplicationTransferFee.Enabled = false;
btnTransferOwnership.Enabled = false;
btnReApply.Enabled = false;
btnInitApplication.Enabled = true;
}
}
public void InternalTransfer_ToWalletAddress()
{
// Deploy contract
ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/BasicTransfer.cs");
Assert.True(compilationResult.Success);
BuildCreateContractTransactionResponse preResponse = this.node1.SendCreateContractTransaction(compilationResult.Compilation, 0);
this.node1.WaitMempoolCount(1);
this.node1.WaitForBlocksToBeMined(1);
Assert.NotNull(this.node1.GetCode(preResponse.NewContractAddress));
double amount = 25;
// Send amount to contract, which will send to wallet address (address without code)
uint160 walletUint160 = new uint160(1);
string address = walletUint160.ToAddress().ToString();
string[] parameters = new string[] { string.Format("{0}#{1}", (int)MethodParameterDataType.Address, address) };
BuildCallContractTransactionResponse response = this.node1.SendCallContractTransaction(
nameof(BasicTransfer.SendToAddress),
preResponse.NewContractAddress,
amount,
parameters);
this.node2.WaitMempoolCount(1);
this.node2.WaitForBlocksToBeMined(1);
// Contract doesn't maintain any balance
Assert.Equal((ulong)0, this.node1.GetContractBalance(preResponse.NewContractAddress));
// Receipt is correct
ReceiptResponse receipt = this.node1.GetReceipt(response.TransactionId.ToString());
Assert.Equal(response.TransactionId.ToString(), receipt.TransactionHash);
Assert.Empty(receipt.Logs); // TODO: Could add logs to this test
Assert.True(receipt.Success);
Assert.True(receipt.GasUsed > GasPriceList.BaseCost);
Assert.Null(receipt.NewContractAddress);
Assert.Equal(this.node1.MinerAddress.Address, receipt.From);
Assert.Null(receipt.Error);
Assert.Equal(preResponse.NewContractAddress, receipt.To);
}
/// <summary>
/// Transfer Ownership
/// </summary>
/// <returns>ReceiptResponse</returns>
public async Task <ReceiptResponse> TransferOwnership(string seller,
string buyer)
{
ReceiptResponse receiptResponce = null;
SaleDeedTransferOwnershipRequest transferOwnershipEntity = new SaleDeedTransferOwnershipRequest
{
GasPrice = gasPrice,
GasLimit = gasLimit,
Amount = amount,
Sender = sender,
BuyerAddress = buyer,
FeeAmount = fee,
WalletName = walletName,
WalletPassword = walletPassword,
OwnerAddress = seller,
AssetId = requestObject.AssetId
};
System.Console.WriteLine("Trying to execute the SaleDeed -> TransferOwnership Request");
var ownershipResponse = await saleRegistryFacade.TransferOwnership(transferOwnershipEntity);
System.Console.WriteLine("Completed executing SaleDeed -> TransferOwnership Request");
var commandResponse = JsonConvert.DeserializeObject <CommandResponse>(ownershipResponse.Content.ReadAsStringAsync().Result);
if (commandResponse.success)
{
receiptResponce = await saleRegistryFacade.TryReceiptResponse(commandResponse.transactionId);
if (receiptResponce != null && receiptResponce.success)
{
Dump(receiptResponce);
}
else
{
System.Console.WriteLine("TransferOwnership -> Receipt Response Error");
Dump(receiptResponce);
}
}
return(receiptResponce);
}
private async void btnInitApplication_Click(object sender, System.EventArgs e)
{
if (string.IsNullOrEmpty(txtAssetID.Text))
{
MessageBox.Show("Please specify the AssetId", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error);
txtAssetID.Focus();
return;
}
if (string.IsNullOrEmpty(txtBuyerAddress.Text))
{
MessageBox.Show("Please specify the Buyer Address", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error);
txtBuyerAddress.Focus();
return;
}
if (string.IsNullOrEmpty(txtSellerAddress.Text))
{
MessageBox.Show("Please specify the Seller Address", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error);
txtSellerAddress.Focus();
return;
}
lblState.Visible = true;
lblState.Text = "Please wait....";
supervisor = new Supervisor(txtAssetID.Text.Trim(),
txtBuyerAddress.Text.Trim(), txtSellerAddress.Text.Trim());
receiptResponse = await supervisor.InitApplication();
if (receiptResponse != null && receiptResponse.success)
{
OutputResponseInformation(receiptResponse);
lblState.Text = InProgressState;
btnInitApplication.Enabled = false;
btnStartReviewProcess.Enabled = true;
btnRejectApplication.Enabled = true;
}
}
internal static void Response(ReceiptResponse data)
{
if (data != null)
{
Console.WriteLine("========== n: {0} CashBoxIdentificateion:{1} ReceiptIdentification:{2} ==========", data.cbReceiptReference, data.ftCashBoxIdentification, data.ftReceiptIdentification);
foreach (var item in data.ftSignatures)
{
if (item.ftSignatureFormat == 0x03)
{
fiskaltrust.ifPOS.Utilities.QR_TextChars(item.Data, 64, true);
Console.WriteLine(fiskaltrust.ifPOS.Utilities.AT_RKSV_Signature_ToBase32(item.Data));
}
Console.WriteLine("{0}:{1}", item.Caption, item.Data);
}
}
else
{
Console.WriteLine("null-result!!!");
}
}
private static void PrintResponse(ReceiptResponse data)
{
if (data != null)
{
Console.WriteLine("{0:G} ReceiptResponse:", DateTime.Now);
Console.WriteLine(JsonConvert.SerializeObject(data, Formatting.Indented));
Console.WriteLine("========== n: {0} CashBoxIdentificateion:{1} ReceiptIdentification:{2} ==========", data.cbReceiptReference, data.ftCashBoxIdentification, data.ftReceiptIdentification);
foreach (var item in data.ftSignatures.Where(x => x.ftSignatureFormat != 0x03))
{
Console.WriteLine("{0}:{1}", item.Caption, item.Data);
}
foreach (var item in data.ftSignatures.Where(x => x.ftSignatureFormat == 0x03))
{
QrCodeHelper.PrintQrCode(item);
}
}
else
{
Console.WriteLine("null-result!!!");
}
}
private String sendMessage(MessageType msgType, String CorpNum, string sender, string subject, string content, List <Message> messages, DateTime?reserveDT, string UserID)
{
if (messages == null || messages.Count == 0)
{
throw new PopbillException(-99999999, "전송할 메시지가 입력되지 않았습니다.");
}
sendRequest request = new sendRequest();
request.snd = sender;
request.subject = subject;
request.content = content;
request.sndDT = reserveDT == null ? null : reserveDT.Value.ToString("yyyyMMddHHmmss");
request.msgs = messages;
String PostData = toJsonString(request);
ReceiptResponse response = httppost <ReceiptResponse>("/" + msgType.ToString(), CorpNum, UserID, PostData, null);
return(response.receiptNum);
}
public void TestChain_Auction()
{
// Compile the contract we want to deploy
ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/Auction.cs");
Assert.True(compilationResult.Success);
using (TestChain chain = new TestChain().Initialize())
{
// Get an address we can use for deploying
Base58Address deployerAddress = chain.PreloadedAddresses[0];
// Create and send transaction to mempool with parameters
SendCreateContractResult createResult = chain.SendCreateContractTransaction(deployerAddress, compilationResult.Compilation, 0, new object[] { 20uL });
// Mine a block which will contain our sent transaction
chain.MineBlocks(1);
// Check the receipt to see that contract deployment was successful
ReceiptResponse receipt = chain.GetReceipt(createResult.TransactionId);
Assert.Equal(deployerAddress, receipt.From);
// Check that the code is indeed saved on-chain
byte[] savedCode = chain.GetCode(createResult.NewContractAddress);
Assert.NotNull(savedCode);
// Use another identity to bid
Base58Address bidderAddress = chain.PreloadedAddresses[1];
// Send a call to the bid method
SendCallContractResult callResult = chain.SendCallContractTransaction(bidderAddress, "Bid", createResult.NewContractAddress, 1);
chain.MineBlocks(1);
// Call a method locally to check the state is as expected
ILocalExecutionResult localCallResult = chain.CallContractMethodLocally(bidderAddress, "HighestBidder", createResult.NewContractAddress, 0);
Address storedHighestBidder = (Address)localCallResult.Return;
Assert.NotEqual(default(Address), storedHighestBidder); // TODO: A nice way of comparing hex and base58 representations
}
}
public void EmptyMethodNameFails()
{
// Ensure fixture is funded.
this.mockChain.MineBlocks(1);
// Deploy contract to send to
ContractCompilationResult receiveCompilationResult = ContractCompiler.CompileFile("SmartContracts/BasicReceive.cs");
Assert.True(receiveCompilationResult.Success);
BuildCreateContractTransactionResponse receiveResponse = this.node1.SendCreateContractTransaction(receiveCompilationResult.Compilation, 0);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
Assert.NotNull(this.node1.GetCode(receiveResponse.NewContractAddress));
decimal amount = 25;
Money senderBalanceBefore = this.node1.WalletSpendableBalance;
uint256 currentHash = this.node1.GetLastBlock().GetHash();
// Send to empty method name on contract
string[] parameters = new string[] { string.Format("{0}#{1}", (int)MethodParameterDataType.Address, receiveResponse.NewContractAddress) };
BuildCallContractTransactionResponse response = this.node1.SendCallContractTransaction(
"",
receiveResponse.NewContractAddress,
amount,
parameters);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
NBitcoin.Block lastBlock = this.node1.GetLastBlock();
// Receipt shows failure
ReceiptResponse receipt = this.node1.GetReceipt(response.TransactionId.ToString());
Assert.False(receipt.Success);
Assert.Equal(StateTransitionErrors.NoMethodName, receipt.Error);
}
public void InternalTransfer_FromConstructor()
{
double amount = 25;
uint256 currentHash = this.node1.GetLastBlock().GetHash();
// Deploy contract
ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/TransferFromConstructor.cs");
Assert.True(compilationResult.Success);
uint160 walletUint160 = new uint160(1);
string address = walletUint160.ToAddress().ToString();
string[] parameters = new string[] { string.Format("{0}#{1}", (int)MethodParameterDataType.Address, address) };
BuildCreateContractTransactionResponse response = this.node1.SendCreateContractTransaction(compilationResult.Compilation, amount, parameters);
this.node2.WaitMempoolCount(1);
this.node2.WaitForBlocksToBeMined(1);
Assert.NotNull(this.node1.GetCode(response.NewContractAddress));
NBitcoin.Block lastBlock = this.node1.GetLastBlock();
// Blocks progressed
Assert.NotEqual(currentHash, lastBlock.GetHash());
// Contract maintains half the balance
Assert.Equal((ulong)new Money((long)amount, MoneyUnit.BTC) / 2, this.node1.GetContractBalance(response.NewContractAddress));
// Receipt is correct
ReceiptResponse receipt = this.node1.GetReceipt(response.TransactionId.ToString());
Assert.Equal(response.TransactionId.ToString(), receipt.TransactionHash);
Assert.Empty(receipt.Logs); // TODO: Could add logs to this test
Assert.True(receipt.Success);
Assert.True(receipt.GasUsed > GasPriceList.BaseCost);
Assert.Equal(response.NewContractAddress, receipt.NewContractAddress);
Assert.Equal(this.node1.MinerAddress.Address, receipt.From);
Assert.Null(receipt.Error);
Assert.Null(receipt.To);
}
private async void btnTransferOwnership_Click(object sender, System.EventArgs e)
{
if (string.IsNullOrEmpty(txtSellerAddress.Text))
{
MessageBox.Show("Please specify the Seller Address", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error);
txtSellerAddress.Focus();
return;
}
lblState.Text = "Please wait....";
propertySeller = new PropertySeller(txtSellerAddress.Text.Trim());
receiptResponse = await supervisor.TransferOwnership(propertySeller.GetOwnerAddress(),
propertyBuyer.GetBuyerAddress());
if (receiptResponse != null && receiptResponse.success)
{
OutputResponseInformation(receiptResponse);
btnTransferOwnership.Enabled = false;
lblState.Text = TransferOwnershipComplete;
}
}
//sendMessage (MMS)
public string SendMMS(string CorpNum, string snd, string sndnm, string subject, string content,
List <Message> messages, string mmsfilepath, DateTime?sndDT = null, bool adsYN = false,
string requestNum = null, string UserID = null)
{
if (messages == null || messages.Count == 0)
{
throw new PopbillException(-99999999, "전송할 메시지가 입력되지 않았습니다.");
}
sendRequest request = new sendRequest();
request.snd = snd;
request.sndnm = sndnm;
request.subject = subject;
request.content = content;
request.msgs = messages;
request.sndDT = sndDT == null ? null : sndDT.Value.ToString("yyyyMMddHHmmss");
request.adsYN = adsYN;
request.requestNum = requestNum;
string PostData = toJsonString(request);
List <UploadFile> UploadFiles = new List <UploadFile>();
UploadFile uf = new UploadFile();
uf.FieldName = "file";
uf.FileName = System.IO.Path.GetFileName(mmsfilepath);
uf.FileData = new FileStream(mmsfilepath, FileMode.Open, FileAccess.Read);
UploadFiles.Add(uf);
ReceiptResponse response =
httppostFile <ReceiptResponse>("/MMS", CorpNum, PostData, UploadFiles, null, UserID);
return(response.receiptNum);
}
/// <summary>
/// Get Application State
/// </summary>
/// <returns>ReceiptResponse</returns>
public async Task <ReceiptResponse> GetApplicationState()
{
ReceiptResponse receiptResponce = null;
System.Console.WriteLine("Trying to execute the SaleDeed -> GetApplicationState Request");
// Execute a method "GetPropertyState" to get the application state
var response = await saleRegistryFacade.GetPropertyState(requestObject);
System.Console.WriteLine("Completed executing SaleDeed -> GetApplicationState Request");
if (response.IsSuccessStatusCode)
{
CommandResponse commandResponse = JsonConvert.DeserializeObject <CommandResponse>(response.Content.ReadAsStringAsync().Result);
if (commandResponse.success)
{
System.Console.WriteLine($"Trying to get the Receipt Response for transactionId: {commandResponse.transactionId}");
receiptResponce = await saleRegistryFacade.TryReceiptResponse(commandResponse.transactionId);
if (receiptResponce != null && receiptResponce.success)
{
Dump(receiptResponce);
}
else
{
System.Console.WriteLine("GetApplicationState -> Receipt Response Error");
Dump(receiptResponce);
}
}
}
else
{
System.Console.WriteLine("Problem in performing the GetApplicationState Operation");
}
return(receiptResponce);
}
public void PersistentState_Clear_State_Should_Be_Empty_In_Same_Tx()
{
// Ensure fixture is funded.
this.mockChain.MineBlocks(1);
// Deploy contract
ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/ClearDataContract.cs");
Assert.True(compilationResult.Success);
BuildCreateContractTransactionResponse preResponse = this.node1.SendCreateContractTransaction(compilationResult.Compilation, 0);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
Assert.NotNull(this.node1.GetCode(preResponse.NewContractAddress));
uint256 currentHash = this.node1.GetLastBlock().GetHash();
// Clear the data and check that it's empty
BuildCallContractTransactionResponse response = this.node1.SendCallContractTransaction(
nameof(ClearDataContract.ClearDataAndCheck),
preResponse.NewContractAddress,
0);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
NBitcoin.Block lastBlock = this.node1.GetLastBlock();
// Blocks progressed
Assert.NotEqual(currentHash, lastBlock.GetHash());
ReceiptResponse receipt = this.node1.GetReceipt(response.TransactionId.ToString());
Assert.True(receipt.Success);
Assert.Equal(true.ToString(), receipt.ReturnValue);
}
public void InternalTransfer_FromConstructor()
{
// Ensure fixture is funded.
this.mockChain.MineBlocks(1);
decimal amount = 25;
Money senderBalanceBefore = this.node1.WalletSpendableBalance;
uint256 currentHash = this.node1.GetLastBlock().GetHash();
// Deploy contract
ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/TransferFromConstructor.cs");
Assert.True(compilationResult.Success);
uint160 walletUint160 = new uint160(1);
string address = walletUint160.ToBase58Address(this.node1.CoreNode.FullNode.Network);
string[] parameters = new string[] { string.Format("{0}#{1}", (int)MethodParameterDataType.Address, address) };
BuildCreateContractTransactionResponse response = this.node1.SendCreateContractTransaction(compilationResult.Compilation, amount, parameters);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
Assert.NotNull(this.node1.GetCode(response.NewContractAddress));
NBitcoin.Block lastBlock = this.node1.GetLastBlock();
// Blocks progressed
Assert.NotEqual(currentHash, lastBlock.GetHash());
// Block contains a condensing transaction
Assert.Equal(3, lastBlock.Transactions.Count);
Transaction condensingTransaction = lastBlock.Transactions[2];
Assert.Equal(2, condensingTransaction.Outputs.Count);
// 1 output which is contract maintaining its balance
byte[] toBytes = condensingTransaction.Outputs[0].ScriptPubKey.ToBytes();
Assert.Equal((byte)ScOpcodeType.OP_INTERNALCONTRACTTRANSFER, toBytes[0]);
uint160 toAddress = new uint160(toBytes.Skip(1).ToArray());
Assert.Equal(response.NewContractAddress, toAddress.ToBase58Address(this.node1.CoreNode.FullNode.Network));
Assert.Equal(new Money((long)amount, MoneyUnit.BTC) / 2, condensingTransaction.Outputs[1].Value);
// 1 output to address sent in params
uint160 transferReceiver = this.senderRetriever.GetAddressFromScript(condensingTransaction.Outputs[1].ScriptPubKey).Sender;
Assert.Equal(walletUint160, transferReceiver);
Assert.Equal(new Money((long)amount, MoneyUnit.BTC) / 2, condensingTransaction.Outputs[1].Value);
// Contract maintains half the balance
Assert.Equal((ulong)new Money((long)amount, MoneyUnit.BTC) / 2, this.node1.GetContractBalance(response.NewContractAddress));
// Receipt is correct
ReceiptResponse receipt = this.node1.GetReceipt(response.TransactionId.ToString());
Assert.Equal(lastBlock.GetHash().ToString(), receipt.BlockHash);
Assert.Equal(response.TransactionId.ToString(), receipt.TransactionHash);
Assert.Empty(receipt.Logs); // TODO: Could add logs to this test
Assert.True(receipt.Success);
Assert.True(receipt.GasUsed > GasPriceList.BaseCost);
Assert.Equal(response.NewContractAddress, receipt.NewContractAddress);
Assert.Equal(this.node1.MinerAddress.Address, receipt.From);
Assert.Null(receipt.Error);
Assert.Null(receipt.To);
}
public void InternalTransfer_ToWalletAddress()
{
// Ensure fixture is funded.
this.mockChain.MineBlocks(1);
// Deploy contract
ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/BasicTransfer.cs");
Assert.True(compilationResult.Success);
BuildCreateContractTransactionResponse preResponse = this.node1.SendCreateContractTransaction(compilationResult.Compilation, 0);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
Assert.NotNull(this.node1.GetCode(preResponse.NewContractAddress));
decimal amount = 25;
Money senderBalanceBefore = this.node1.WalletSpendableBalance;
uint256 currentHash = this.node1.GetLastBlock().GetHash();
// Send amount to contract, which will send to wallet address (address without code)
uint160 walletUint160 = new uint160(1);
string address = walletUint160.ToBase58Address(this.node1.CoreNode.FullNode.Network);
string[] parameters = new string[] { string.Format("{0}#{1}", (int)MethodParameterDataType.Address, address) };
BuildCallContractTransactionResponse response = this.node1.SendCallContractTransaction(
nameof(BasicTransfer.SendToAddress),
preResponse.NewContractAddress,
amount,
parameters);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
NBitcoin.Block lastBlock = this.node1.GetLastBlock();
// Blocks progressed
Assert.NotEqual(currentHash, lastBlock.GetHash());
// Block contains a condensing transaction
Assert.Equal(3, lastBlock.Transactions.Count);
Transaction condensingTransaction = lastBlock.Transactions[2];
Assert.Single(condensingTransaction.Outputs); // Entire balance was forwarded,
uint160 transferReceiver = this.senderRetriever.GetAddressFromScript(condensingTransaction.Outputs[0].ScriptPubKey).Sender;
Assert.Equal(walletUint160, transferReceiver);
Assert.Equal(new Money((long)amount, MoneyUnit.BTC), condensingTransaction.Outputs[0].Value);
// Contract doesn't maintain any balance
Assert.Equal((ulong)0, this.node1.GetContractBalance(preResponse.NewContractAddress));
// Receipt is correct
ReceiptResponse receipt = this.node1.GetReceipt(response.TransactionId.ToString());
Assert.Equal(lastBlock.GetHash().ToString(), receipt.BlockHash);
Assert.Equal(response.TransactionId.ToString(), receipt.TransactionHash);
Assert.Empty(receipt.Logs); // TODO: Could add logs to this test
Assert.True(receipt.Success);
Assert.True(receipt.GasUsed > GasPriceList.BaseCost);
Assert.Null(receipt.NewContractAddress);
Assert.Equal(this.node1.MinerAddress.Address, receipt.From);
Assert.Null(receipt.Error);
Assert.Equal(preResponse.NewContractAddress, receipt.To);
}
public void CreateContract_OneOfEachParameterType()
{
// Ensure fixture is funded.
this.mockChain.MineBlocks(1);
decimal amount = 25;
uint256 currentHash = this.node1.GetLastBlock().GetHash();
ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/CreateWithAllParameters.cs");
Assert.True(compilationResult.Success);
const char testChar = 'c';
string testAddressBase58 = new uint160("0x0000000000000000000000000000000000000001").ToBase58Address(this.node1.CoreNode.FullNode.Network);
Address testAddress = testAddressBase58.ToAddress(this.node1.CoreNode.FullNode.Network);
const bool testBool = true;
const int testInt = Int32.MaxValue;
const long testLong = Int64.MaxValue;
const uint testUint = UInt32.MaxValue;
const ulong testUlong = UInt64.MaxValue;
const string testString = "The quick brown fox jumps over the lazy dog";
byte[] testBytes = new byte[] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 };
string[] parameters = new string[]
{
string.Format("{0}#{1}", (int)MethodParameterDataType.Char, testChar),
string.Format("{0}#{1}", (int)MethodParameterDataType.Address, testAddressBase58),
string.Format("{0}#{1}", (int)MethodParameterDataType.Bool, testBool),
string.Format("{0}#{1}", (int)MethodParameterDataType.Int, testInt),
string.Format("{0}#{1}", (int)MethodParameterDataType.Long, testLong),
string.Format("{0}#{1}", (int)MethodParameterDataType.UInt, testUint),
string.Format("{0}#{1}", (int)MethodParameterDataType.ULong, testUlong),
string.Format("{0}#{1}", (int)MethodParameterDataType.String, testString),
string.Format("{0}#{1}", (int)MethodParameterDataType.ByteArray, testBytes.ToHexString()),
};
BuildCreateContractTransactionResponse response = this.node1.SendCreateContractTransaction(compilationResult.Compilation, amount, parameters);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
NBitcoin.Block lastBlock = this.node1.GetLastBlock();
// Blocks progressed
Assert.NotEqual(currentHash, lastBlock.GetHash());
// Contract was created
Assert.NotNull(this.node1.GetCode(response.NewContractAddress));
// Block doesn't contain any extra transactions
Assert.Equal(2, lastBlock.Transactions.Count);
// Contract keeps balance
Assert.Equal((ulong)new Money((ulong)amount, MoneyUnit.BTC), this.node1.GetContractBalance(response.NewContractAddress));
// All values were stored
Assert.Equal(this.serializer.Serialize(testChar), this.node1.GetStorageValue(response.NewContractAddress, "char"));
Assert.Equal(this.serializer.Serialize(testAddress), this.node1.GetStorageValue(response.NewContractAddress, "Address"));
Assert.Equal(this.serializer.Serialize(testBool), this.node1.GetStorageValue(response.NewContractAddress, "bool"));
Assert.Equal(this.serializer.Serialize(testInt), this.node1.GetStorageValue(response.NewContractAddress, "int"));
Assert.Equal(this.serializer.Serialize(testLong), this.node1.GetStorageValue(response.NewContractAddress, "long"));
Assert.Equal(this.serializer.Serialize(testUint), this.node1.GetStorageValue(response.NewContractAddress, "uint"));
Assert.Equal(this.serializer.Serialize(testUlong), this.node1.GetStorageValue(response.NewContractAddress, "ulong"));
Assert.Equal(this.serializer.Serialize(testString), this.node1.GetStorageValue(response.NewContractAddress, "string"));
Assert.Equal(testBytes, this.node1.GetStorageValue(response.NewContractAddress, "bytes"));
// Test that the contract address, event name, and logging values are available in the bloom.
var scBlockHeader = lastBlock.Header as ISmartContractBlockHeader;
Assert.True(scBlockHeader.LogsBloom.Test(response.NewContractAddress.ToUint160(this.node1.CoreNode.FullNode.Network).ToBytes()));
Assert.True(scBlockHeader.LogsBloom.Test(Encoding.UTF8.GetBytes("Log")));
Assert.True(scBlockHeader.LogsBloom.Test(this.serializer.Serialize(testChar)));
Assert.True(scBlockHeader.LogsBloom.Test(this.serializer.Serialize(testAddress)));
Assert.True(scBlockHeader.LogsBloom.Test(this.serializer.Serialize(testBool)));
Assert.True(scBlockHeader.LogsBloom.Test(this.serializer.Serialize(testInt)));
Assert.True(scBlockHeader.LogsBloom.Test(this.serializer.Serialize(testLong)));
Assert.True(scBlockHeader.LogsBloom.Test(this.serializer.Serialize(testUint)));
Assert.True(scBlockHeader.LogsBloom.Test(this.serializer.Serialize(testUlong)));
Assert.True(scBlockHeader.LogsBloom.Test(this.serializer.Serialize(testString)));
Assert.True(scBlockHeader.LogsBloom.Test(this.serializer.Serialize(testBytes)));
// And sanity test that random fields aren't contained in bloom.
Assert.False(scBlockHeader.LogsBloom.Test(Encoding.UTF8.GetBytes("RandomValue")));
Assert.False(scBlockHeader.LogsBloom.Test(BitConverter.GetBytes(123)));
// Receipt is correct
ReceiptResponse receipt = this.node1.GetReceipt(response.TransactionId.ToString());
Assert.Equal(lastBlock.GetHash().ToString(), receipt.BlockHash);
Assert.Equal(response.TransactionId.ToString(), receipt.TransactionHash);
Assert.True(receipt.Success);
Assert.Single(receipt.Logs);
Assert.True(receipt.GasUsed > GasPriceList.BaseCost);
Assert.Equal(response.NewContractAddress, receipt.NewContractAddress);
Assert.Equal(this.node1.MinerAddress.Address, receipt.From);
Assert.Null(receipt.To);
Assert.Null(receipt.Error);
}
internal static void Response(ReceiptResponse data)
{
if (data != null)
{
Console.WriteLine("========== n: {0} CashBoxIdentificateion:{1} ReceiptIdentification:{2} ==========", data.cbReceiptReference, data.ftCashBoxIdentification, data.ftReceiptIdentification);
foreach (var item in data.ftSignatures)
{
if (item.ftSignatureFormat == 0x03)
{
fiskaltrust.ifPOS.Utilities.QR_TextChars(item.Data, 64, true);
Console.WriteLine(fiskaltrust.ifPOS.Utilities.AT_RKSV_Signature_ToBase32(item.Data));
}
Console.WriteLine("{0}:{1}", item.Caption, item.Data);
}
}
else
{
Console.WriteLine("null-result!!!");
}
}
public void SerializeArrays_ForEachMethodParamType()
{
// Ensure fixture is funded.
this.mockChain.MineBlocks(1);
decimal amount = 25;
uint256 currentHash = this.node1.GetLastBlock().GetHash();
ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/CreateWithAllArrays.cs");
Assert.True(compilationResult.Success);
char[] chars = new char[] { 'a', '9' };
Address[] addresses = new Address[] { this.node1.MinerAddress.Address.ToAddress(this.node1.CoreNode.FullNode.Network), "mipcBbFg9gMiCh81Kj8tqqdgoZub1ZJRfn".ToAddress(this.node1.CoreNode.FullNode.Network) };
bool[] bools = new bool[] { false, true, false };
int[] ints = new int[] { 1, -123, int.MaxValue };
long[] longs = new long[] { 1, -123, long.MaxValue };
uint[] uints = new uint[] { 1, 123, uint.MaxValue };
ulong[] ulongs = new ulong[] { 1, 123, ulong.MaxValue };
string[] strings = new string[] { "Test", "", "The quick brown fox jumps over the lazy dog" }; // TODO: Ensure Assert checks "" equality in contract when null bug fixed
string[] parameters = new string[]
{
string.Format("{0}#{1}", (int)MethodParameterDataType.ByteArray, this.serializer.Serialize(chars).ToHexString()),
string.Format("{0}#{1}", (int)MethodParameterDataType.ByteArray, this.serializer.Serialize(addresses).ToHexString()),
string.Format("{0}#{1}", (int)MethodParameterDataType.ByteArray, this.serializer.Serialize(bools).ToHexString()),
string.Format("{0}#{1}", (int)MethodParameterDataType.ByteArray, this.serializer.Serialize(ints).ToHexString()),
string.Format("{0}#{1}", (int)MethodParameterDataType.ByteArray, this.serializer.Serialize(longs).ToHexString()),
string.Format("{0}#{1}", (int)MethodParameterDataType.ByteArray, this.serializer.Serialize(uints).ToHexString()),
string.Format("{0}#{1}", (int)MethodParameterDataType.ByteArray, this.serializer.Serialize(ulongs).ToHexString()),
string.Format("{0}#{1}", (int)MethodParameterDataType.ByteArray, this.serializer.Serialize(strings).ToHexString())
};
BuildCreateContractTransactionResponse response = this.node1.SendCreateContractTransaction(compilationResult.Compilation, amount, parameters);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
NBitcoin.Block lastBlock = this.node1.GetLastBlock();
// Blocks progressed
Assert.NotEqual(currentHash, lastBlock.GetHash());
// Contract was created
Assert.NotNull(this.node1.GetCode(response.NewContractAddress));
// Block doesn't contain any extra transactions
Assert.Equal(2, lastBlock.Transactions.Count);
// Contract keeps balance
Assert.Equal((ulong)new Money((ulong)amount, MoneyUnit.BTC), this.node1.GetContractBalance(response.NewContractAddress));
// All values were stored
Assert.Equal(this.serializer.Serialize(chars), this.node1.GetStorageValue(response.NewContractAddress, "chars"));
Assert.Equal(this.serializer.Serialize(addresses), this.node1.GetStorageValue(response.NewContractAddress, "addresses"));
Assert.Equal(this.serializer.Serialize(bools), this.node1.GetStorageValue(response.NewContractAddress, "bools"));
Assert.Equal(this.serializer.Serialize(ints), this.node1.GetStorageValue(response.NewContractAddress, "ints"));
Assert.Equal(this.serializer.Serialize(longs), this.node1.GetStorageValue(response.NewContractAddress, "longs"));
Assert.Equal(this.serializer.Serialize(uints), this.node1.GetStorageValue(response.NewContractAddress, "uints"));
Assert.Equal(this.serializer.Serialize(ulongs), this.node1.GetStorageValue(response.NewContractAddress, "ulongs"));
Assert.Equal(this.serializer.Serialize(strings), this.node1.GetStorageValue(response.NewContractAddress, "strings"));
// Receipt is correct
ReceiptResponse receipt = this.node1.GetReceipt(response.TransactionId.ToString());
Assert.Equal(lastBlock.GetHash().ToString(), receipt.BlockHash);
Assert.Equal(response.TransactionId.ToString(), receipt.TransactionHash);
Assert.True(receipt.Success);
Assert.Empty(receipt.Logs);
Assert.True(receipt.GasUsed > GasPriceList.BaseCost);
Assert.Equal(response.NewContractAddress, receipt.NewContractAddress);
Assert.Equal(this.node1.MinerAddress.Address, receipt.From);
Assert.Null(receipt.To);
Assert.Null(receipt.Error);
}
public void Internal_CallContract_SerializeEachParameterType()
{
// Ensure fixture is funded.
this.mockChain.MineBlocks(1);
// Deploy contract to send to
ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/CallWithAllParameters.cs");
Assert.True(compilationResult.Success);
BuildCreateContractTransactionResponse preResponse = this.node1.SendCreateContractTransaction(compilationResult.Compilation, 0);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
Assert.NotNull(this.node1.GetCode(preResponse.NewContractAddress));
decimal amount = 25;
uint256 currentHash = this.node1.GetLastBlock().GetHash();
const char testChar = 'c';
string testAddressBase58 = new uint160("0x0000000000000000000000000000000000000001").ToBase58Address(this.node1.CoreNode.FullNode.Network);
const bool testBool = true;
const int testInt = Int32.MaxValue;
const long testLong = Int64.MaxValue;
const uint testUint = UInt32.MaxValue;
const ulong testUlong = UInt64.MaxValue;
const string testString = "The quick brown fox jumps over the lazy dog";
string[] parameters = new string[]
{
string.Format("{0}#{1}", (int)MethodParameterDataType.Char, testChar),
string.Format("{0}#{1}", (int)MethodParameterDataType.Address, testAddressBase58),
string.Format("{0}#{1}", (int)MethodParameterDataType.Bool, testBool),
string.Format("{0}#{1}", (int)MethodParameterDataType.Int, testInt),
string.Format("{0}#{1}", (int)MethodParameterDataType.Long, testLong),
string.Format("{0}#{1}", (int)MethodParameterDataType.UInt, testUint),
string.Format("{0}#{1}", (int)MethodParameterDataType.ULong, testUlong),
string.Format("{0}#{1}", (int)MethodParameterDataType.String, testString),
string.Format("{0}#{1}", (int)MethodParameterDataType.Address, preResponse.NewContractAddress) // sendTo
};
compilationResult = ContractCompiler.CompileFile("SmartContracts/ForwardParameters.cs");
BuildCreateContractTransactionResponse response = this.node1.SendCreateContractTransaction(compilationResult.Compilation, amount, parameters);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
NBitcoin.Block lastBlock = this.node1.GetLastBlock();
// Blocks progressed
Assert.NotEqual(currentHash, lastBlock.GetHash());
// Block contains extra transaction forwarding balance
Assert.Equal(3, lastBlock.Transactions.Count);
// Contract called internally gets balance
Assert.Equal((ulong)new Money((ulong)amount, MoneyUnit.BTC), this.node1.GetContractBalance(preResponse.NewContractAddress));
// Receipt is correct
ReceiptResponse receipt = this.node1.GetReceipt(response.TransactionId.ToString());
Assert.Equal(lastBlock.GetHash().ToString(), receipt.BlockHash);
Assert.Equal(response.TransactionId.ToString(), receipt.TransactionHash);
Assert.True(receipt.Success);
Assert.Empty(receipt.Logs);
Assert.True(receipt.GasUsed > GasPriceList.BaseCost);
Assert.Equal(response.NewContractAddress, receipt.NewContractAddress);
Assert.Equal(this.node1.MinerAddress.Address, receipt.From);
Assert.Null(receipt.To);
Assert.Null(receipt.Error);
}
public void InternalTransfer_ToContractAddress()
{
// Deploy contract to send to
ContractCompilationResult receiveCompilationResult = ContractCompiler.CompileFile("SmartContracts/BasicReceive.cs");
Assert.True(receiveCompilationResult.Success);
BuildCreateContractTransactionResponse receiveResponse = this.node1.SendCreateContractTransaction(receiveCompilationResult.Compilation, 0);
this.node1.WaitMempoolCount(1);
this.node1.WaitForBlocksToBeMined(1);
Assert.NotNull(this.node1.GetCode(receiveResponse.NewContractAddress));
// Deploy contract to send from
ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/BasicTransfer.cs");
Assert.True(compilationResult.Success);
BuildCreateContractTransactionResponse preResponse = this.node1.SendCreateContractTransaction(compilationResult.Compilation, 0);
this.node1.WaitMempoolCount(1);
this.node1.WaitForBlocksToBeMined(1);
Assert.NotNull(this.node1.GetCode(preResponse.NewContractAddress));
double amount = 25;
uint256 currentHash = this.node1.GetLastBlock().GetHash();
// Send amount to contract, which will send to contract address
string[] parameters = new string[] { string.Format("{0}#{1}", (int)MethodParameterDataType.Address, receiveResponse.NewContractAddress.ToAddress(this.mockChain.Network)) };
BuildCallContractTransactionResponse response = this.node1.SendCallContractTransaction(
nameof(BasicTransfer.SendToAddress),
preResponse.NewContractAddress,
amount,
parameters);
this.node2.WaitMempoolCount(1);
this.node2.WaitForBlocksToBeMined(1);
NBitcoin.Block lastBlock = this.node1.GetLastBlock();
// Blocks progressed
Assert.NotEqual(currentHash, lastBlock.GetHash());
// Contract doesn't maintain any balance
Assert.Equal((ulong)0, this.node1.GetContractBalance(preResponse.NewContractAddress));
// Receiver contract now has balance
Assert.Equal((ulong)new Money((int)amount, MoneyUnit.BTC), this.node1.GetContractBalance(receiveResponse.NewContractAddress));
// Receiver contract stored to state
Assert.Equal(new byte[] { 1 }, this.node1.GetStorageValue(receiveResponse.NewContractAddress, BasicReceive.ReceiveKey));
// Receipt is correct
ReceiptResponse receipt = this.node1.GetReceipt(response.TransactionId.ToString());
Assert.Equal(response.TransactionId.ToString(), receipt.TransactionHash);
Assert.Single(receipt.Logs);
Assert.Equal(receiveResponse.NewContractAddress, receipt.Logs[0].Address);
Assert.True(receipt.Success);
Assert.True(receipt.GasUsed > GasPriceList.BaseCost);
Assert.Null(receipt.NewContractAddress);
Assert.Equal(this.node1.MinerAddress.Address, receipt.From);
Assert.Null(receipt.Error);
Assert.Equal(preResponse.NewContractAddress, receipt.To);
}
public void InternalTransfer_Create_WithValueTransfer()
{
// Ensure fixture is funded.
this.mockChain.MineBlocks(1);
// Deploy contract
ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/CreationTransfer.cs");
Assert.True(compilationResult.Success);
BuildCreateContractTransactionResponse preResponse = this.node1.SendCreateContractTransaction(compilationResult.Compilation, 0);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
Assert.NotNull(this.node1.GetCode(preResponse.NewContractAddress));
decimal amount = 25;
Money senderBalanceBefore = this.node1.WalletSpendableBalance;
uint256 currentHash = this.node1.GetLastBlock().GetHash();
// Send amount to contract, which will send to new address of contract it creates
BuildCallContractTransactionResponse response = this.node1.SendCallContractTransaction(
nameof(CreationTransfer.CreateAnotherContract),
preResponse.NewContractAddress,
amount);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
NBitcoin.Block lastBlock = this.node1.GetLastBlock();
// Blocks progressed
Assert.NotEqual(currentHash, lastBlock.GetHash());
// Get created contract address - TODO FIX
uint160 createdAddress = this.addressGenerator.GenerateAddress(response.TransactionId, 0);
// Block contains a condensing transaction
Assert.Equal(3, lastBlock.Transactions.Count);
Transaction condensingTransaction = lastBlock.Transactions[2];
Assert.Single(condensingTransaction.Outputs); // Entire balance was forwarded,
byte[] toBytes = condensingTransaction.Outputs[0].ScriptPubKey.ToBytes();
Assert.Equal((byte)ScOpcodeType.OP_INTERNALCONTRACTTRANSFER, toBytes[0]);
uint160 toAddress = new uint160(toBytes.Skip(1).ToArray());
Assert.Equal(createdAddress, toAddress);
Assert.Equal(new Money((long)amount, MoneyUnit.BTC), condensingTransaction.Outputs[0].Value);
// Contract doesn't maintain any balance
Assert.Equal((ulong)0, this.node1.GetContractBalance(preResponse.NewContractAddress));
// Created contract received full amount
Assert.Equal((ulong)new Money((ulong)amount, MoneyUnit.BTC), this.node1.GetContractBalance(createdAddress.ToBase58Address(this.node1.CoreNode.FullNode.Network)));
// Receipt is correct
ReceiptResponse receipt = this.node1.GetReceipt(response.TransactionId.ToString());
Assert.Equal(lastBlock.GetHash().ToString(), receipt.BlockHash);
Assert.Equal(response.TransactionId.ToString(), receipt.TransactionHash);
Assert.Empty(receipt.Logs); // TODO: Could add logs to this test
Assert.True(receipt.Success);
Assert.True(receipt.GasUsed > GasPriceList.BaseCost);
Assert.Null(receipt.NewContractAddress);
Assert.Equal(this.node1.MinerAddress.Address, receipt.From);
Assert.Null(receipt.Error);
Assert.Equal(preResponse.NewContractAddress, receipt.To);
}
private MvcMailMessage EmailConfirmationForBlackstonePos(ReceiptResponse receipt, ReceiptConfigViewModel receiptConfig)
{
try
{
receipt.PhoneNumber = ServiceImplementationUtils.GetAmericanFormat(receipt.PhoneNumber);
//Filling the ViewData to be displayed in the email (ignoring the PhoneRecharged)
ServiceImplementationUtils.LoadDictionaryfromType(ViewData, receipt);
ViewBag.LogoUrl = receiptConfig.LogoUrl;
ViewBag.Company = receiptConfig.Company;
return Populate(x =>
{
x.From = new MailAddress(receiptConfig.EmailId);
x.Subject = receiptConfig.Subject;
x.To.Add(receiptConfig.Email);
x.ViewName = "Confirmation";
});
}
catch (Exception exception)
{
_logger.Error(exception.StackTrace);
return null;
}
}
public void InternalTransfer_ToContractAddress()
{
// Ensure fixture is funded.
this.mockChain.MineBlocks(1);
// Deploy contract to send to
ContractCompilationResult receiveCompilationResult = ContractCompiler.CompileFile("SmartContracts/BasicReceive.cs");
Assert.True(receiveCompilationResult.Success);
BuildCreateContractTransactionResponse receiveResponse = this.node1.SendCreateContractTransaction(receiveCompilationResult.Compilation, 0);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
Assert.NotNull(this.node1.GetCode(receiveResponse.NewContractAddress));
// Deploy contract to send from
ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/BasicTransfer.cs");
Assert.True(compilationResult.Success);
BuildCreateContractTransactionResponse preResponse = this.node1.SendCreateContractTransaction(compilationResult.Compilation, 0);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
Assert.NotNull(this.node1.GetCode(preResponse.NewContractAddress));
decimal amount = 25;
Money senderBalanceBefore = this.node1.WalletSpendableBalance;
uint256 currentHash = this.node1.GetLastBlock().GetHash();
// Send amount to contract, which will send to contract address
string[] parameters = new string[] { string.Format("{0}#{1}", (int)MethodParameterDataType.Address, receiveResponse.NewContractAddress) };
BuildCallContractTransactionResponse response = this.node1.SendCallContractTransaction(
nameof(BasicTransfer.SendToAddress),
preResponse.NewContractAddress,
amount,
parameters);
this.mockChain.WaitAllMempoolCount(1);
this.mockChain.MineBlocks(1);
NBitcoin.Block lastBlock = this.node1.GetLastBlock();
// Blocks progressed
Assert.NotEqual(currentHash, lastBlock.GetHash());
// Contract doesn't maintain any balance
Assert.Equal((ulong)0, this.node1.GetContractBalance(preResponse.NewContractAddress));
// Receiver contract now has balance
Assert.Equal((ulong)new Money((int)amount, MoneyUnit.BTC), this.node1.GetContractBalance(receiveResponse.NewContractAddress));
// Receiver contract stored to state
Assert.Equal(new byte[] { 1 }, this.node1.GetStorageValue(receiveResponse.NewContractAddress, BasicReceive.ReceiveKey));
// Log was stored - bloom filter should be non-zero
Assert.NotEqual(new Bloom(), ((ISmartContractBlockHeader)lastBlock.Header).LogsBloom);
// Block contains a condensing transaction
Assert.Equal(3, lastBlock.Transactions.Count);
Transaction condensingTransaction = lastBlock.Transactions[2];
Assert.Single(condensingTransaction.Outputs); // Entire balance was forwarded
byte[] toBytes = condensingTransaction.Outputs[0].ScriptPubKey.ToBytes();
Assert.Equal((byte)ScOpcodeType.OP_INTERNALCONTRACTTRANSFER, toBytes[0]);
uint160 toAddress = new uint160(toBytes.Skip(1).ToArray());
Assert.Equal(receiveResponse.NewContractAddress, toAddress.ToBase58Address(this.node1.CoreNode.FullNode.Network));
Assert.Equal(new Money((long)amount, MoneyUnit.BTC), condensingTransaction.Outputs[0].Value);
// Receipt is correct
ReceiptResponse receipt = this.node1.GetReceipt(response.TransactionId.ToString());
Assert.Equal(lastBlock.GetHash().ToString(), receipt.BlockHash);
Assert.Equal(response.TransactionId.ToString(), receipt.TransactionHash);
Assert.Single(receipt.Logs);
Assert.Equal(receiveResponse.NewContractAddress, receipt.Logs[0].Address);
Assert.True(receipt.Success);
Assert.True(receipt.GasUsed > GasPriceList.BaseCost);
Assert.Null(receipt.NewContractAddress);
Assert.Equal(this.node1.MinerAddress.Address, receipt.From);
Assert.Null(receipt.Error);
Assert.Equal(preResponse.NewContractAddress, receipt.To);
}
private MvcMailMessage EmailConfirmationForFullCarga(ReceiptResponse receipt, int merchantId, ReceiptConfigViewModel receiptConfig)
{
try
{
var bodyMessageForFullCarga = _blackstoneService.GetFullCargaSmsFormat(receipt, merchantId);
ServiceImplementationUtils.LoadDictionaryFromFormattedText(ViewData, bodyMessageForFullCarga);
ViewBag.LogoUrl = receiptConfig.LogoUrl;
ViewBag.Company = receiptConfig.Company;
return Populate(x =>
{
x.From = new MailAddress(receiptConfig.EmailId);
x.Subject = receiptConfig.Subject;
x.To.Add(receiptConfig.Email);
x.ViewName = "Confirmation";
});
}
catch (Exception exception)
{
_logger.Error(exception.StackTrace);
return null;
}
}
