private object RouteConfirmSellNFT(HTTPRequest request)
{
var chainName = request.GetVariable("chain");
var contractName = request.GetVariable("contract");
var methodName = request.GetVariable("method");
var param = request.GetVariable("params");
var id = request.GetVariable("id");
if (param == null)
{
PushError(request, "Parameters cannot be null!");
return(null);
}
List <object> paramList = SendUtils.BuildParamList(param);
var keyPair = GetLoginKey(request);
InvalidateCache(keyPair.Address);
string result;
result = AccountController.ConfirmSellNFT(keyPair, chainName, contractName, methodName, paramList.ToArray(), id).Result;
ResetSessionSendFields(request);
if (!SendUtils.IsTxHashValid(result))
{
PushError(request, result);
Log.Information("No valid result");
return("");
}
return(result);
}
private object RouteCosmicFixed(HTTPRequest request)
{
var context = InitContext(request);
if (context["holdings"] is Holding[] balance)
{
var keyPair = GetLoginKey(request);
InvalidateCache(keyPair.Address);
var result = AccountController.CosmicFixed(keyPair).Result;
if (result.GetType() == typeof(ErrorRes))
{
return(JsonConvert.SerializeObject(result, Formatting.Indented));
}
var contractTx = (string)result;
if (SendUtils.IsTxHashValid(contractTx))
{
request.session.SetString("confirmedHash", contractTx);
return(contractTx);
}
}
return(null);
}
private object RouteInvokeContract(HTTPRequest request)
{
var contract = request.GetVariable("contract");
var method = request.GetVariable("method");
var context = InitContext(request);
// TODO check if contract exists
if (context["holdings"] is Holding[] balance)
{
var soulBalance = balance.SingleOrDefault(b => b.Symbol == "SOUL");
if (soulBalance.Amount > 0.1m)
{
var keyPair = GetLoginKey(request);
var contractTx = AccountController.InvokeContractGeneric(keyPair, contract, method).Result;
if (SendUtils.IsTxHashValid(contractTx))
{
return(contractTx);
}
PushError(request, contractTx);
}
else
{
PushError(request, "You need a small drop of SOUL (+0.1) to call a contract.");
}
}
return("");
}
private object RouteSendMultipleNFT(HTTPRequest request)
{
var addressTo = request.GetVariable("dest");
var chainName = request.GetVariable("chain");
var destinationChain = request.GetVariable("destChain");
var symbol = request.GetVariable("token");
var id = request.GetVariable("id");
var isName = bool.Parse(request.GetVariable("isName"));
var keyPair = GetLoginKey(request);
InvalidateCache(keyPair.Address);
string result;
result = AccountController.TransferMultipleNFT(keyPair, addressTo, chainName, symbol, id, isName).Result;
ResetSessionSendFields(request);
if (!SendUtils.IsTxHashValid(result))
{
PushError(request, result);
Log.Information("No valid result");
return("");
}
return(result);
}
private object RouteInvokeContract(HTTPRequest request)
{
var chain = request.GetVariable("chain");
var contract = request.GetVariable("contract");
var method = request.GetVariable("method");
var param = request.GetVariable("params");
var context = InitContext(request);
if (param == null)
{
PushError(request, "Parameters cannot be null!");
return(null);
}
List <object> paramList = SendUtils.BuildParamList(param);
var keyPair = GetLoginKey(request);
InvalidateCache(keyPair.Address);
var result = AccountController.InvokeContractGeneric(keyPair, chain, contract, method, paramList.ToArray()).Result;
if (result != null && result.GetType() == typeof(BigInteger))
{
return(result.ToString());
}
return(JsonConvert.SerializeObject(result, Formatting.Indented));
}
private object RouteRegisterName(HTTPRequest request)
{
var name = request.GetVariable("name");
var context = InitContext(request);
if (context["holdings"] is Holding[] balance)
{
var keyPair = GetLoginKey(request);
InvalidateCache(keyPair.Address);
var result = AccountController.RegisterName(keyPair, name).Result;
if (result.GetType() == typeof(ErrorRes))
{
return(JsonConvert.SerializeObject(result, Formatting.Indented));
}
var registerTx = (string)result;
if (SendUtils.IsTxHashValid(registerTx))
{
request.session.SetString("confirmedHash", registerTx);
return(registerTx);
}
PushError(request, registerTx);
}
else
{
PushError(request, "Error while registering name.");
}
return("");
}
private object RouteRegisterName(HTTPRequest request)
{
var name = request.GetVariable("name");
var context = InitContext(request);
if (AccountContract.ValidateName(name))
{
if (context["holdings"] is Holding[] balance)
{
var soulBalance = balance.SingleOrDefault(b => b.Symbol == "SOUL");
if (soulBalance.Amount > 0.1m) //RegistrationCost
{
var keyPair = GetLoginKey(request);
var registerTx = AccountController.RegisterName(keyPair, name).Result;
if (SendUtils.IsTxHashValid(registerTx))
{
return(registerTx);
}
PushError(request, registerTx);
}
else
{
PushError(request, "You need a small drop of SOUL (+0.1) to register a name.");
}
}
}
else
{
PushError(request, "Error while registering name.");
}
return("");
}
private object RouteSendRawTxCustomNFT(HTTPRequest request)
{
var addressTo = request.GetVariable("dest");
var chainName = request.GetVariable("chain");
var symbol = request.GetVariable("token");
var amount = request.GetVariable("amount");
var payload = request.GetVariable("payload");
var donation = bool.Parse(request.GetVariable("donation"));
var keyPair = GetLoginKey(request);
string result;
result = AccountController.TransferTokensCustomNFT(keyPair, addressTo, chainName, symbol, amount, payload, donation).Result;
ResetSessionSendFields(request);
if (!SendUtils.IsTxHashValid(result))
{
PushError(request, result);
Log.Information("No valid result");
return("");
}
return(result);
}
public void Apply(WebSocket webSocket, JObject messageJson)
{
doApply(webSocket);
SendUtils.sendAsJson(webSocket, new BasicCommandOutput()
{
type = messageJson["type"].ToString()
});
}
private object RouteConfirmations(HTTPRequest request)
{
if (!HasLogin(request))
{
return(HTTPResponse.Redirect("/login"));
}
var context = InitContext(request);
var txHash = request.GetVariable("txhash");
request.session.SetStruct <ErrorContext>("error", new ErrorContext {
ErrorCode = "", ErrorDescription = $"{txHash} is still not confirmed."
});
var result = AccountController.GetTxConfirmations(txHash).Result;
if (result.GetType() == typeof(ErrorRes))
{
return(JsonConvert.SerializeObject(result, Formatting.Indented));
}
var txObject = (TransactionDto)result;
request.session.SetString("confirmedHash", txHash);
if (request.session.GetBool("isCrossTransfer"))
{
var settle = request.session.GetStruct <SettleTx>("settleTx");
var settleTx = AccountController.SettleBlockTransfer(
GetLoginKey(request),
settle.ChainAddress,
txObject.Txid, settle.DestinationChainAddress).Result;
// clear
request.session.SetBool("isCrossTransfer", false);
if (SendUtils.IsTxHashValid(settleTx))
{
context["confirmingTxHash"] = settleTx;
return("settling");
}
PushError(request, settleTx);
return("unconfirmed");
}
else
{
if (request.session.GetInt("txNumber") > 2)
{
return("continue");
}
//if it gets here, there are no more txs to process
var keyPair = GetLoginKey(request);
InvalidateCache(keyPair.Address);
ResetSessionSendFields(request);
return("confirmed");
}
}
private object RouteConfirmations(HTTPRequest request)
{
if (!HasLogin(request))
{
return(HTTPResponse.Redirect("/login"));
}
var context = InitContext(request);
var txHash = request.GetVariable("txhash");
request.session.SetStruct <ErrorContext>("error", new ErrorContext {
ErrorCode = "", ErrorDescription = $"{txHash} is still not confirmed."
});
var transactionDto = AccountController.GetTxConfirmations(txHash).Result;
// hack, transactionDto.Result might contain the confirmations, but that's empty
// so we check if the txid != null for now
if (transactionDto.Txid != null)
{
request.session.SetString("confirmedHash", txHash);
if (request.session.GetBool("isCrossTransfer"))
{
var settle = request.session.GetStruct <SettleTx>("settleTx");
var settleTx = AccountController.SettleBlockTransfer(
GetLoginKey(request),
settle.ChainAddress,
transactionDto.Txid, settle.DestinationChainAddress).Result;
// clear
request.session.SetBool("isCrossTransfer", false);
if (SendUtils.IsTxHashValid(settleTx))
{
context["confirmingTxHash"] = settleTx;
return("settling");
}
PushError(request, settleTx);
return("unconfirmed");
}
else
{
if (request.session.GetInt("txNumber") > 2)
{
return("continue");
}
//if it gets here, there are no more txs to process
var keyPair = GetLoginKey(request);
InvalidateCache(keyPair.Address);
ResetSessionSendFields(request);
return("confirmed");
}
}
PushError(request, "Error sending tx.");
return("unconfirmed");
}
private object RouteMarketBuyCustomModal(HTTPRequest request)
{
var chain = request.GetVariable("chain");
var contract = request.GetVariable("contract");
var method = request.GetVariable("method");
var param = request.GetVariable("params");
var id = request.GetVariable("id");
var quotesymbol = request.GetVariable("quoteSymbol");
var pricenft = request.GetVariable("priceNFT");
var creatoraddress = request.GetVariable("creatorAddress");
var context = InitContext(request);
if (param == null)
{
PushError(request, "Parameters cannot be null!");
return(null);
}
List <object> paramList = SendUtils.BuildParamList(param);
if (context["holdings"] is Holding[] balance)
{
var kcalBalance = balance.SingleOrDefault(b => b.Symbol == "KCAL" && b.Chain == chain);
if (kcalBalance.Amount > 0.1m)
{
var keyPair = GetLoginKey(request);
InvalidateCache(keyPair.Address);
var result = AccountController.MarketBuyCustomModal(
keyPair, chain, contract, method, paramList.ToArray(), id, quotesymbol, pricenft, creatoraddress
).Result;
if (result.GetType() == typeof(ErrorRes))
{
return(JsonConvert.SerializeObject(result, Formatting.Indented));
}
var contractTx = (string)result;
if (SendUtils.IsTxHashValid(contractTx))
{
request.session.SetString("confirmedHash", contractTx);
return(contractTx);
}
PushError(request, contractTx);
}
else
{
PushError(request, "You need a small drop of KCAL to call a contract.");
}
}
return(null);
}
public void Apply(WebSocket webSocket, JObject messageJson)
{
int percentOccupiedMemory = getOccupiedMemoryPercentage();
SendUtils.sendAsJson(webSocket,
new MonitorCommandOutput()
{
type = messageJson["type"].ToString(),
value = percentOccupiedMemory + "%",
sequenceId = Convert.ToInt64(messageJson["sequenceId"].ToString()) + 1
});
}
public void Apply(WebSocket webSocket, JObject messageJson)
{
PerformanceCounter cpuCounter = new PerformanceCounter("Processor Information", "% Processor Utility", "_Total", true);
cpuCounter.NextValue();
Thread.Sleep(500);
SendUtils.sendAsJson(webSocket,
new MonitorCommandOutput()
{
type = messageJson["type"].ToString(),
value = (int)cpuCounter.NextValue() + "%",
sequenceId = Convert.ToInt64(messageJson["sequenceId"].ToString()) + 1
});
}
private static void TestFunc(string[] obj)
{
var json2 = @"{ 'parameters': [ { 'name': 'address', 'vmtype': 'Object', 'type': 'Phantasma.Cryptography.Address', 'input': 'P5ySorAXMaJLwe6AqTsshW3XD8ahkwNpWHU9KLX9CwkYd', 'info': 'info1' },
{ 'name': 'address', 'vmtype': 'Enum', 'type': 'Phantasma.Blockchain.ArchiveFlags', 'input': '1', 'info': 'info1' },
{ 'name': 'address', 'vmtype': 'Enum', 'type': 'Phantasma.Blockchain.ArchiveFlags', 'input': '1', 'info': 'info1' },
{ 'name': 'address', 'vmtype': 'Enum', 'type': 'Phantasma.Blockchain.Contracts.Native.ExchangeOrderSide', 'input': '1', 'info': 'info1' },
{ 'name': 'address', 'vmtype': 'Enum', 'type': 'Phantasma.Blockchain.Contracts.Native.ExchangeOrderSide', 'input': '2', 'info': 'info1' },
{ 'name': 'address', 'vmtype': 'Enum', 'type': 'Phantasma.Blockchain.Contracts.Native.ExchangeOrderType', 'input': '3', 'info': 'info1' },
{ 'name': 'address', 'vmtype': 'Enum', 'type': 'Phantasma.Blockchain.Contracts.Native.ExchangeOrderType', 'input': '4', 'info': 'info1' },
{ 'name': 'address', 'vmtype': 'Timestamp', 'type': 'Phantasma.Core.Types.Timestamp', 'input': '07/20/2019 20:04:30', 'info': 'info1' },
{ 'name': 'address', 'vmtype': 'Bool', 'type': 'System.Boolean', 'input': 'False', 'info': 'info1' },
{ 'name': 'address', 'vmtype': 'Bool', 'type': 'System.Boolean', 'input': 'True', 'info': 'info1' },
{ 'name': 'address', 'vmtype': 'String', 'type': 'System.String', 'input': 'ThisIsAString', 'info': 'info1' },
{ 'name': 'address', 'vmtype': 'Bytes', 'type': 'System.Byte[]', 'input': 'ThisIsAByteArray', 'info': 'info1' },
{ 'name': 'address', 'vmtype': 'Number', 'type': 'System.Int32', 'input': '987654321', 'info': 'info1' },
{ 'name': 'address', 'vmtype': 'Number', 'type': 'Phantasma.Numerics.BigInteger', 'input': '12345678', 'info': 'info1' }
] }";
List <object> lst2 = SendUtils.BuildParamList(json2);
}
private object RouteStake(HTTPRequest request)
{
var stakeAmount = request.GetVariable("stakeAmount");
var context = InitContext(request);
if (stakeAmount == null)
{
PushError(request, "stakeAmount cannot be null!");
return(null);
}
if (context["holdings"] is Holding[] balance)
{
var keyPair = GetLoginKey(request);
InvalidateCache(keyPair.Address);
var result = AccountController.CreateStakeSoulTransactionWithClaim(
keyPair, stakeAmount
).Result;
if (result.GetType() == typeof(ErrorRes))
{
return(JsonConvert.SerializeObject(result, Formatting.Indented));
}
var contractTx = (string)result;
if (SendUtils.IsTxHashValid(contractTx))
{
request.session.SetString("confirmedHash", contractTx);
return(contractTx);
}
PushError(request, contractTx);
}
return(null);
}
public async Task <object> CreateMultisigWallet(PhantasmaKeys keyPair, MultisigSettings settings)
{
try
{
var multisigScript = SendUtils.GenerateMultisigScript(settings);
var script = ScriptUtils.BeginScript()
.AllowGas(keyPair.Address, Address.Null, MinimumFee, 800)
.CallContract("account", "RegisterScript", keyPair.Address, multisigScript)
.SpendGas(keyPair.Address)
.EndScript();
var nexusName = WalletConfig.Network;
var tx = new Phantasma.Blockchain.Transaction(nexusName, "main", script, DateTime.UtcNow + TimeSpan.FromMinutes(30), "PHT-0-8-7");
tx.Sign(keyPair);
var txResult = await _phantasmaRpcService.SendRawTx.SendRequestAsync(tx.ToByteArray(true).Encode());
return(txResult);
}
catch (RpcResponseException rpcEx)
{
Log.Error($"RPC Exception occurred: {rpcEx.RpcError.Message}");
return(new ErrorRes {
error = rpcEx.RpcError.Message
});
}
catch (Exception ex)
{
Log.Error($"Exception occurred: {ex.Message}");
return(new ErrorRes {
error = ex.Message
});
}
}
public List <ChainDto> GetShortestPath(string chainName, string destinationChain)
{
return(SendUtils.GetShortestPath(chainName, destinationChain, PhantasmaChains));
}
private object RouteSendRawTx(HTTPRequest request)
{
if (!HasLogin(request))
{
return(HTTPResponse.Redirect("/login"));
}
var isFungible = bool.Parse(request.GetVariable("fungible"));
var addressTo = request.GetVariable("dest");
var chainName = request.GetVariable("chain");
var destinationChain = request.GetVariable("destChain");
var symbol = request.GetVariable("token");
var amountOrId = request.GetVariable(isFungible ? "amount" : "id");
var isName = bool.Parse(request.GetVariable("isName"));
var keyPair = GetLoginKey(request);
string result;
// Multisig code, NOT YET DONE
// HACK if the address has a script it's multisig
//byte[] addressScript = AccountController.GetAddressScript(keyPair);
//if (addressScript != null && addressScript.Length > 0)
//{
// if (chainName != destinationChain)
// {
// // cross chain multisg not supported yet
// return null;
// }
// MultisigSettings settings = AccountController.CheckMultisig(keyPair, addressScript);
// result = AccountController.TransferTokens(isFungible
// ,keyPair
// ,addressTo
// ,chainName
// ,symbol
// ,amountOrId
// ,settings).Result;
// return "";
//}
if (chainName == destinationChain)
{
result = AccountController.TransferTokens(isFungible, keyPair, addressTo, chainName, symbol, amountOrId, isName).Result;
ResetSessionSendFields(request);
}
else //cross chain requires 2 txs
{
var pathList = AccountController.GetShortestPath(chainName, destinationChain).ToArray();
request.session.SetInt("txNumber", pathList.Length);
if (pathList.Length > 2)
{
chainName = pathList[0].Name;
destinationChain = pathList[1].Name;
// save tx
request.session.SetStruct <TransferTx>("transferTx", new TransferTx
{
IsFungible = isFungible,
FromChain = chainName,
ToChain = destinationChain,
FinalChain = pathList[pathList.Length - 1].Name,
AddressTo = addressTo,
Symbol = symbol,
AmountOrId = amountOrId
});
result = AccountController.CrossChainTransferToken(isFungible, keyPair, keyPair.Address.Text, chainName, destinationChain, symbol, amountOrId).Result;
}
else
{
result = AccountController.CrossChainTransferToken(isFungible, keyPair, addressTo, chainName, destinationChain, symbol, amountOrId).Result;
}
if (SendUtils.IsTxHashValid(result))
{
request.session.SetBool("isCrossTransfer", true);
request.session.SetStruct <SettleTx>("settleTx",
new SettleTx
{
ChainName = chainName,
ChainAddress = AccountController.PhantasmaChains.Find(p => p.Name == chainName).Address,
DestinationChainAddress = AccountController.PhantasmaChains.Find(p => p.Name == destinationChain).Address,
});
}
}
if (!SendUtils.IsTxHashValid(result))
{
PushError(request, result);
Log.Information("No valid result");
return("");
}
return(result);
}
private object RouteSendRawTx(HTTPRequest request)
{
if (!HasLogin(request))
{
return(HTTPResponse.Redirect("/login"));
}
var isFungible = bool.Parse(request.GetVariable("fungible"));
var addressTo = request.GetVariable("dest");
var chainName = request.GetVariable("chain");
var destinationChain = request.GetVariable("destChain");
var symbol = request.GetVariable("token");
var amountOrId = request.GetVariable(isFungible ? "amount" : "id");
var keyPair = GetLoginKey(request);
string result;
if (chainName == destinationChain)
{
result = AccountController.TransferTokens(isFungible, keyPair, addressTo, chainName, symbol, amountOrId).Result;
ResetSessionSendFields(request);
}
else //cross chain requires 2 txs
{
var pathList = AccountController.GetShortestPath(chainName, destinationChain).ToArray();
request.session.SetInt("txNumber", pathList.Length);
if (pathList.Length > 2)
{
chainName = pathList[0].Name;
destinationChain = pathList[1].Name;
// save tx
request.session.SetStruct <TransferTx>("transferTx", new TransferTx
{
IsFungible = isFungible,
FromChain = chainName,
ToChain = destinationChain,
FinalChain = pathList[pathList.Length - 1].Name,
AddressTo = addressTo,
Symbol = symbol,
AmountOrId = amountOrId
});
result = AccountController.CrossChainTransferToken(isFungible, keyPair, keyPair.Address.Text, chainName, destinationChain, symbol, amountOrId).Result;
}
else
{
result = AccountController.CrossChainTransferToken(isFungible, keyPair, addressTo, chainName, destinationChain, symbol, amountOrId).Result;
}
if (SendUtils.IsTxHashValid(result))
{
request.session.SetBool("isCrossTransfer", true);
request.session.SetStruct <SettleTx>("settleTx",
new SettleTx
{
ChainName = chainName,
ChainAddress = AccountController.PhantasmaChains.Find(p => p.Name == chainName).Address,
DestinationChainAddress = AccountController.PhantasmaChains.Find(p => p.Name == destinationChain).Address,
});
}
}
if (!SendUtils.IsTxHashValid(result))
{
PushError(request, result);
return("");
}
return(result);
}
