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 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 RouteConfig(HTTPRequest request)
{
var mode = request.GetVariable("mode");
var configStr = request.GetVariable("config");
WalletConfigDto config = new WalletConfigDto();
if (mode == "set")
{
config = JsonConvert.DeserializeObject <WalletConfigDto>(configStr);
Utils.WriteConfig <WalletConfigDto>(config, Utils.CfgPath);
AccountController.UpdateConfig(config);
// very ugly needs to be changed
Settings.SetRPCServerUrl();
InitAccountController();
SetupControllers();
var keyPair = GetLoginKey(request);
InvalidateCache(keyPair.Address);
return(JsonConvert.SerializeObject(config));
}
else if (mode == "get")
{
config = Utils.ReadConfig(Utils.CfgPath);
}
return(JsonConvert.SerializeObject(config));
}
private object HandleGet(HTTPRequest request)
{
var version = request.GetVariable("jsonrpc");
if (version != "2" && version != "2.0")
{
return(GenerateRPCError("Invalid jsonrpc version", -32602));
}
var method = request.GetVariable("method");
var id = request.GetVariable("id");
if (string.IsNullOrEmpty(id))
{
id = "0";
}
var encodedParams = request.GetVariable("params");
var decodedParams = encodedParams.UrlDecode();
DataNode paramNode;
try
{
paramNode = JSONReader.ReadFromString(decodedParams);
}
catch
{
return(GenerateRPCError("Parsing error", -32700));
}
return(HandleRPCRequest(id, method, paramNode));
}
private object RouteInvokeSettleTx(HTTPRequest request)
{
var txHash = request.GetVariable("txHash");
var neoKey = request.GetVariable("neoKey");
var neoPassphrase = request.GetVariable("neoPassphrase");
var assetSymbol = request.GetVariable("assetSymbol");
var context = InitContext(request);
var phantasmaKeys = GetLoginKey(request);
InvalidateCache(phantasmaKeys.Address);
if (context["holdings"] is Holding[] balance)
{
Phantasma.Neo.Core.NeoKeys neoKeys;
if (string.IsNullOrEmpty(neoPassphrase))
{
neoKeys = Phantasma.Neo.Core.NeoKeys.FromWIF(neoKey);
}
else
{
neoKeys = Phantasma.Neo.Core.NeoKeys.FromNEP2(neoKey, neoPassphrase);
}
var result = AccountController.InvokeSettleTx(neoKeys, phantasmaKeys, txHash, assetSymbol).Result;
ResetSessionSendFields(request);
return(result);
}
return(null);
}
private object RouteRedeemNFT(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 keyPair = GetLoginKey(request);
InvalidateCache(keyPair.Address);
string result;
result = AccountController.TransferTokensNFTRedeem(keyPair, addressTo, chainName, symbol, id).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 RouteContractABI(HTTPRequest request)
{
var chain = request.GetVariable("chain");
var contract = request.GetVariable("contract");
var result = JsonConvert.SerializeObject(AccountController
.GetContractABI(chain, contract).Result, Formatting.Indented);
return(result);
}
private object RouteMarketplace(HTTPRequest request)
{
try
{
var input = request.GetVariable("page");
if (!int.TryParse(input, out int pageNumber))
{
pageNumber = 1;
}
var selectedChain = request.GetVariable("chain");
var controller = MarketplaceControllerInstance;
var chainsWithMarkets = controller.GetChainsWithMarketsAndActiveAuctions().Result;
if (string.IsNullOrEmpty(selectedChain) && chainsWithMarkets.Any())
{
selectedChain = chainsWithMarkets[0]; //default
}
var pageModel = new PaginationModel
{
Count = controller.GetAuctionsCount(selectedChain).Result,
CurrentPage = pageNumber,
PageSize = AppSettings.PageSize,
};
var marketVm = controller.GetAuctions(selectedChain, pageModel.CurrentPage, pageModel.PageSize).Result;
var context = GetSessionContext(request);
if (marketVm.TotalAuctions >= 0)
{
context[AppSettings.MenuContext] = _menus;
context[AppSettings.MarketplaceContext] = marketVm;
context["marketChains"] = chainsWithMarkets;
context["selectedChain"] = selectedChain;
context[AppSettings.PaginationContext] = pageModel;
return(RendererView(context, "layout", AppSettings.MarketplaceContext));
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
_errorContextInstance.ErrorCode = "Marketplace error";
_errorContextInstance.ErrorDescription = "No active auctions found";
request.session.SetStruct <ErrorContext>(AppSettings.ErrorContext, _errorContextInstance);
return(HTTPResponse.Redirect(AppSettings.UrlError));
}
private object RouteCosmicCustom(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);
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.CosmicCustom(
keyPair, chain, contract, method, paramList.ToArray()
).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);
}
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 RouteTransaction(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;
if (txObject.Confirmations > 0)
{
return(JsonConvert.SerializeObject(txObject, Formatting.Indented));
}
PushError(request, "Error sending tx.");
return(JsonConvert.SerializeObject(new TransactionDto()
{
}, Formatting.Indented));
}
private HTTPResponse RouteLoginWithParams(HTTPRequest request)
{
var key = request.GetVariable("key");
WalletConfigDto config = Utils.ReadConfig(Utils.CfgPath);
AccountController.UpdateConfig(config);
// very ugly needs to be changed
Settings.SetRPCServerUrl();
InitAccountController();
SetupControllers();
try
{
request.session.SetString("wif", key);
request.session.SetBool("login", true);
}
catch (Exception e)
{
Log.Error(e.ToString());
PushError(request, "Error decoding key.");
return(HTTPResponse.Redirect("/login"));
}
return(HTTPResponse.Redirect("/portfolio"));
}
private object RouteTokensNft(HTTPRequest request)
{
var address = request.GetVariable("input");
try
{
var nftList = TokensControllerInstance.GetNftListByAddress(address);
var context = GetSessionContext(request);
if (nftList != null && nftList.Any())
{
context[AppSettings.MenuContext] = _menus;
context[AppSettings.NftTokensContext] = nftList;
return(RendererView(context, "layout", AppSettings.NftTokensContext));
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
_errorContextInstance.ErrorCode = "nft error";
_errorContextInstance.ErrorDescription = $"no nfts found for this {address} address";
request.session.SetStruct <ErrorContext>(AppSettings.ErrorContext, _errorContextInstance);
return(HTTPResponse.Redirect(AppSettings.UrlError));
}
private object RouteToken(HTTPRequest request)
{
try
{
var tokenSymbol = request.GetVariable("input");
var controller = TokensControllerInstance;
var token = controller.GetToken(tokenSymbol);
var context = GetSessionContext(request);
if (token != null)
{
var holders = controller.GetHolders(token.Symbol);
var transfers = controller.GetTransfers(token.Symbol);
context[AppSettings.MenuContext] = _menus;
context[AppSettings.TokenContext] = token;
context[AppSettings.HoldersContext] = holders;
context[AppSettings.TokenTransfersContext] = transfers;
return(RendererView(context, "layout", AppSettings.TokenContext, AppSettings.HoldersContext, "transfers"));
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
_errorContextInstance.ErrorCode = "token error";
_errorContextInstance.ErrorDescription = "Token not found";
request.session.SetStruct <ErrorContext>(AppSettings.ErrorContext, _errorContextInstance);
return(HTTPResponse.Redirect(AppSettings.UrlError));
}
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 RouteBlock(HTTPRequest request)
{
var input = request.GetVariable("input");
try
{
var block = BlocksControllerInstance.GetBlock(input);
var context = GetSessionContext(request);
if (block != null)
{
context[AppSettings.MenuContext] = _menus;
context[AppSettings.BlockContext] = block;
return(RendererView(context, "layout", AppSettings.BlockContext));
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
_errorContextInstance.ErrorCode = "blocks error";
_errorContextInstance.ErrorDescription = $"No block found with this {input} input";
request.session.SetStruct <ErrorContext>(AppSettings.ErrorContext, _errorContextInstance);
return(HTTPResponse.Redirect(AppSettings.UrlError));
}
private object RouteChain(HTTPRequest request)
{
var addressText = request.GetVariable("input");
try
{
var chain = ChainsControllerInstance.GetChain(addressText);
var context = GetSessionContext(request);
if (chain != null)
{
context[AppSettings.MenuContext] = _menus;
context[AppSettings.ChainContext] = chain;
return(RendererView(context, "layout", AppSettings.ChainContext));
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
_errorContextInstance.ErrorCode = "chains error";
_errorContextInstance.ErrorDescription = $"No chain found with this {addressText} address";
request.session.SetStruct <ErrorContext>(AppSettings.ErrorContext, _errorContextInstance);
return(HTTPResponse.Redirect(AppSettings.UrlError));
}
private object RouteApp(HTTPRequest request)
{
var appId = request.GetVariable("input");
try
{
var controller = AppsControllerInstance;
var app = controller.GetApp(appId);
var context = GetSessionContext(request);
if (app != null)
{
context[AppSettings.MenuContext] = _menus;
context[AppSettings.AppContext] = app;
return(RendererView(context, "layout", AppSettings.AppContext));
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
_errorContextInstance.ErrorCode = "apps error";
_errorContextInstance.ErrorDescription = $"No app with {appId} found";
request.session.SetStruct <ErrorContext>(AppSettings.ErrorContext, _errorContextInstance);
return(HTTPResponse.Redirect(AppSettings.UrlError));
}
private object RouteTransaction(HTTPRequest request)
{
var txHash = request.GetVariable("input");
try
{
var tx = TransactionsControllerInstance.GetTransaction(txHash);
var context = GetSessionContext(request);
if (tx != null)
{
ActivateMenuItem(AppSettings.UrlTransaction);
context[AppSettings.MenuContext] = _menus;
context[AppSettings.TxContext] = tx;
return(RendererView(context, "layout", AppSettings.TxContext));
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
_errorContextInstance.ErrorCode = "txs error";
_errorContextInstance.ErrorDescription = $"Transaction {txHash} not found";
request.session.SetStruct <ErrorContext>(AppSettings.ErrorContext, _errorContextInstance);
return(HTTPResponse.Redirect(AppSettings.UrlError));
}
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 string RouteMultisig(HTTPRequest request)
{
//var json = "{ \"addressCount\": 3, \"signeeCount\": 2, \"addressArray\": [\" ksdlfjksadjfkljsadlkfjasdklf \"]}";
var settingsJson = request.GetVariable("settings");
var settings = JsonConvert.DeserializeObject <MultisigSettings>(settingsJson);
var keyPair = GetLoginKey(request);
var result = AccountController.CreateMultisigWallet(keyPair, settings);
return(JsonConvert.SerializeObject(result, Formatting.Indented));
}
private object RouteConvertAddress(HTTPRequest request)
{
var neoKey = request.GetVariable("neoKey");
var neoPassphrase = request.GetVariable("neoPassphrase");
var context = InitContext(request);
Phantasma.Neo.Core.NeoKeys neoKeys;
if (string.IsNullOrEmpty(neoPassphrase))
{
neoKeys = Phantasma.Neo.Core.NeoKeys.FromWIF(neoKey);
}
else
{
neoKeys = Phantasma.Neo.Core.NeoKeys.FromNEP2(neoKey, neoPassphrase);
}
var result = $"{neoKeys.ToString()}";
return(result);
}
private object RouteInvokeSettleTxETH(HTTPRequest request)
{
var txHash = request.GetVariable("txHash");
var ethKey = request.GetVariable("ethKey");
var assetSymbol = request.GetVariable("assetSymbol");
var context = InitContext(request);
var phantasmaKeys = GetLoginKey(request);
InvalidateCache(phantasmaKeys.Address);
if (context["holdings"] is Holding[] balance)
{
EthereumKey ethKeys;
ethKeys = EthereumKey.FromWIF(ethKey);
var result = AccountController.InvokeSettleTxETH(ethKeys, phantasmaKeys, txHash, assetSymbol).Result;
ResetSessionSendFields(request);
return(result);
}
return(null);
}
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);
}
private object RouteConvertAddressETH(HTTPRequest request)
{
var ethKey = request.GetVariable("ethKey");
var context = InitContext(request);
EthereumKey ethKeys;
ethKeys = EthereumKey.FromWIF(ethKey);
var result = $"{ethKeys.ToString()}";
return(result);
}
private object RouteWaitingTx(HTTPRequest request)
{
if (!HasLogin(request))
{
return(HTTPResponse.Redirect("/login"));
}
var context = InitContext(request);
context["confirmingTxHash"] = request.GetVariable("txhash");
context["transferTx"] = request.session.GetStruct <TransferTx>("transferTx");
return(RendererView(context, "layout", "waiting"));
}
private object RouteAddress(HTTPRequest request)
{
try
{
var addressText = request.GetVariable("input");
var context = GetSessionContext(request);
if (AddressesControllerInstance.IsAddressStored(addressText))
{
var input = request.GetVariable("page");
if (!int.TryParse(input, out int pageNumber))
{
pageNumber = 1;
}
var controller = AddressesControllerInstance;
var pageModel = new PaginationModel
{
Count = controller.GetTransactionCount(addressText),
CurrentPage = pageNumber,
PageSize = AppSettings.PageSize,
};
var addressVm = AddressesControllerInstance.GetAddress(addressText, pageModel.CurrentPage, pageModel.PageSize);
context[AppSettings.MenuContext] = _menus;
context[AppSettings.AddressContext] = addressVm;
context[AppSettings.PaginationContext] = pageModel;
return(RendererView(context, "layout", AppSettings.AddressContext));
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
_errorContextInstance.ErrorCode = "Address error";
_errorContextInstance.ErrorDescription = $"Invalid address";
request.session.SetStruct <ErrorContext>(AppSettings.ErrorContext, _errorContextInstance);
return(HTTPResponse.Redirect(AppSettings.UrlError));
}
private object RouteConvertAddressETHHEX(HTTPRequest request)
{
var ethKey = request.GetVariable("ethKey");
var context = InitContext(request);
EthereumKey ethKeys;
var bytes = Base16.Decode(ethKey);
var temp = new PhantasmaKeys(bytes);
ethKeys = EthereumKey.FromWIF(temp.ToWIF());
var result = $"{ethKeys.ToString()}";
return(result);
}
