public void ActivateLightning()
{
var btc = NetworkProvider.GetNetwork <BTCPayNetwork>("BTC").NBitcoinNetwork;
CustomerLightningD = LightningClientFactory.CreateClient(GetEnvironment("TEST_CUSTOMERLIGHTNINGD", "type=clightning;server=tcp://127.0.0.1:30992/"), btc);
MerchantLightningD = LightningClientFactory.CreateClient(GetEnvironment("TEST_MERCHANTLIGHTNINGD", "type=clightning;server=tcp://127.0.0.1:30993/"), btc);
MerchantCharge = new ChargeTester(this, "TEST_MERCHANTCHARGE", "type=charge;server=http://127.0.0.1:54938/;api-token=foiewnccewuify", "merchant_lightningd", btc);
MerchantLnd = new LndMockTester(this, "TEST_MERCHANTLND", "https://*****:*****@127.0.0.1:35531/", "merchant_lnd", btc);
PayTester.UseLightning = true;
PayTester.IntegratedLightning = MerchantCharge.Client.Uri;
}
public IActionResult WalletPSBT([ModelBinder(typeof(WalletIdModelBinder))]
WalletId walletId, WalletPSBTViewModel vm)
{
var network = NetworkProvider.GetNetwork(walletId.CryptoCode);
if (vm?.PSBT != null)
{
vm.Decoded = vm.GetPSBT(network.NBitcoinNetwork)?.ToString();
}
return(View(vm ?? new WalletPSBTViewModel()));
}
/// <inheritdoc />
public EggEntity(World level, NetworkProvider network) : base((int)EntityType.ThrownEgg, level, network)
{
Width = 0.25;
//Length = 0.25;
Height = 0.25;
Gravity = 0.03;
Drag = 0.01;
DespawnOnImpact = true;
}
/// <inheritdoc />
public SnowballEntity(World level, NetworkProvider network) : base(level, network)
{
Width = 0.25;
// Length = 0.25;
Height = 0.25;
Gravity = 0.03;
Drag = 0.01;
DespawnOnImpact = true;
}
public async Task <IActionResult> WalletPSBT([ModelBinder(typeof(WalletIdModelBinder))]
WalletId walletId, WalletPSBTViewModel vm)
{
var network = NetworkProvider.GetNetwork <BTCPayNetwork>(walletId.CryptoCode);
if (await vm.GetPSBT(network.NBitcoinNetwork) is PSBT psbt)
{
vm.Decoded = psbt.ToString();
vm.PSBT = psbt.ToBase64();
}
return(View(vm ?? new WalletPSBTViewModel()));
}
protected override void OnUnload()
{
Alex.InGame = false;
World.Destroy();
WorldProvider.Dispose();
NetworkProvider.Close();
_playingHud.Unload();
//GetService<IEventDispatcher>().UnregisterEvents(_playingHud.Chat);
//_playingHud.Chat =
}
public PlayingState(Alex alex, GraphicsDevice graphics, WorldProvider worldProvider, NetworkProvider networkProvider) : base(alex)
{
NetworkProvider = networkProvider;
World = new World(alex.Services, graphics, Options, networkProvider);
World.Player.IsFirstPersonMode = true;
WorldProvider = worldProvider;
if (worldProvider is SPWorldProvider)
{
World.DoDaylightcycle = false;
//World.Player.SetInventory(new BedrockInventory(46));
if (ItemFactory.TryGetItem("minecraft:diamond_sword", out var sword))
{
World.Player.Inventory.MainHand = sword;
World.Player.Inventory[World.Player.Inventory.SelectedSlot] = sword;
}
}
var title = new TitleComponent();
WorldProvider = worldProvider;
WorldProvider.Init(World);
WorldProvider.TitleComponent = title;
_playingHud = new PlayingHud(Alex, World.Player, title);
_playingHud.Chat.Network = networkProvider;
WorldProvider.ScoreboardView = _playingHud.Scoreboard;
WorldProvider.ChatRecipient = _playingHud;
//WorldProvider.ScoreboardView
_debugInfo = new GuiDebugInfo();
InitDebugInfo();
MiniMap = new GuiMiniMap(World.ChunkManager)
{
Anchor = Alignment.TopRight
};
var settings = GetService <IOptionsProvider>();
settings.AlexOptions.VideoOptions.Minimap.Bind(OnMinimapSettingChange);
RenderMinimap = settings.AlexOptions.VideoOptions.Minimap.Value;
if (RenderMinimap)
{
_playingHud.AddChild(MiniMap);
}
_networkDebugHud = new NetworkDebugHud(NetworkProvider);
}
/// <inheritdoc />
public ArrowEntity(World level, NetworkProvider network) : base((int)EntityType.Arrow, level, network)
{
Width = 0.15;
//Length = 0.15;
Height = 0.15;
Gravity = 0.05;
Drag = 0.01;
StopOnImpact = true;
DespawnOnImpact = false;
}
/// <inheritdoc />
public override bool TryGetWorldProvider(ServerConnectionDetails connectionDetails,
PlayerProfile playerProfile,
out WorldProvider worldProvider,
out NetworkProvider networkProvider)
{
worldProvider = new JavaWorldProvider(Alex, connectionDetails.EndPoint, playerProfile, new DedicatedThreadPool(new DedicatedThreadPoolSettings(2)), out networkProvider)
{
Hostname = connectionDetails.Hostname
};
return(true);
}
/// <inheritdoc />
public FireworkRocket(World level, NetworkProvider network) : base(level, network)
{
Width = 0.25;
Height = 0.25;
Gravity = 0.0;
Drag = 0.01;
HasCollision = true;
IsAffectedByGravity = true;
StopOnImpact = false;
}
public async Task <IActionResult> WalletPSBTReady(
[ModelBinder(typeof(WalletIdModelBinder))]
WalletId walletId, WalletPSBTReadyViewModel vm, string command = null)
{
PSBT psbt = null;
var network = NetworkProvider.GetNetwork(walletId.CryptoCode);
try
{
psbt = PSBT.Parse(vm.PSBT, network.NBitcoinNetwork);
await FetchTransactionDetails(walletId, vm, network);
}
catch
{
vm.GlobalError = "Invalid PSBT";
return(View(vm));
}
if (command == "broadcast")
{
if (!psbt.IsAllFinalized() && !psbt.TryFinalize(out var errors))
{
vm.SetErrors(errors);
return(View(vm));
}
var transaction = psbt.ExtractTransaction();
try
{
var broadcastResult = await ExplorerClientProvider.GetExplorerClient(network).BroadcastAsync(transaction);
if (!broadcastResult.Success)
{
vm.GlobalError = $"RPC Error while broadcasting: {broadcastResult.RPCCode} {broadcastResult.RPCCodeMessage} {broadcastResult.RPCMessage}";
return(View(vm));
}
}
catch (Exception ex)
{
vm.GlobalError = "Error while broadcasting: " + ex.Message;
return(View(vm));
}
return(await RedirectToWalletTransaction(walletId, transaction));
}
else if (command == "analyze-psbt")
{
return(RedirectToAction(nameof(WalletPSBT), new { walletId = walletId, psbt = psbt.ToBase64() }));
}
else
{
vm.GlobalError = "Unknown command";
return(View(vm));
}
}
public BedrockWorldProvider(Alex alex, IPEndPoint endPoint, PlayerProfile profile,
out NetworkProvider networkProvider)
{
Alex = alex;
//Client = new ExperimentalBedrockClient(alex, alex.Services, this, endPoint);
Client = new BedrockClient(alex, endPoint, profile, this);
networkProvider = Client;
var guiManager = Alex.GuiManager;
FormManager = new BedrockFormManager(networkProvider, guiManager, alex.InputManager);
}
private IActionResult RedirectToWalletTransaction(WalletId walletId, Transaction transaction)
{
var network = NetworkProvider.GetNetwork <BTCPayNetwork>(walletId.CryptoCode);
if (transaction != null)
{
var wallet = _walletProvider.GetWallet(network);
var derivationSettings = GetDerivationSchemeSettings(walletId);
wallet.InvalidateCache(derivationSettings.AccountDerivation);
TempData[WellKnownTempData.SuccessMessage] = $"Transaction broadcasted successfully ({transaction.GetHash().ToString()})";
}
return(RedirectToAction(nameof(WalletTransactions), new { walletId = walletId.ToString() }));
}
static void Main()
{
// Initialize wifi
NetworkProvider.Initialize();
Start();
//Thread.Sleep(5000);
//Stop();
//NetworkProvider.Controller.Disable();
//Thread.Sleep(5000);
//NetworkProvider.Controller.Enable();
//Start();
}
public NetworkDebugHud(NetworkProvider networkProvider)
{
NetworkProvider = networkProvider;
Anchor = Alignment.Fill;
NetworkInfoElement = new GuiAutoUpdatingTextElement(GetNetworkInfo, true);
NetworkInfoElement.BackgroundOverlay = Color.Black * 0.5f;
NetworkInfoElement.Anchor = Alignment.BottomRight;
NetworkInfoElement.TextOpacity = 0.75f;
NetworkInfoElement.TextColor = TextColor.Red;
NetworkInfoElement.Scale = 1f;
AddChild(NetworkInfoElement);
}
private async Task <IActionResult> RedirectToWalletTransaction(WalletId walletId, Transaction transaction)
{
var network = NetworkProvider.GetNetwork <BTCPayNetwork>(walletId.CryptoCode);
if (transaction != null)
{
var wallet = _walletProvider.GetWallet(network);
var derivationSettings = await GetDerivationSchemeSettings(walletId);
wallet.InvalidateCache(derivationSettings.AccountDerivation);
StatusMessage = $"Transaction broadcasted successfully ({transaction.GetHash().ToString()})";
}
return(RedirectToAction(nameof(WalletTransactions)));
}
public BedrockWorldProvider(Alex alex, IPEndPoint endPoint, PlayerProfile profile, DedicatedThreadPool threadPool,
out NetworkProvider networkProvider)
{
Alex = alex;
var eventDispatcher = alex.Services.GetRequiredService <IEventDispatcher>();
EventDispatcher = eventDispatcher;
//Client = new ExperimentalBedrockClient(alex, alex.Services, this, endPoint);
Client = new BedrockClient(alex, eventDispatcher, endPoint, profile, threadPool, this);
networkProvider = Client;
EventDispatcher.RegisterEvents(this);
}
private string GetNetworkInfo()
{
var info = NetworkProvider.GetConnectionInfo();
StringBuilder sb = new StringBuilder();
sb.Append($"Latency: {info.Latency}");
sb.Append($" | Ack: {info.AckSent} sent / {info.Ack} received");
sb.Append($" | NACK's: {info.Nack}");
sb.Append($" | Resends: {info.Resends}");
sb.Append($" | Fails: {info.Fails}");
return(sb.ToString());
}
public async Task <IActionResult> WalletPSBT(
[ModelBinder(typeof(WalletIdModelBinder))]
WalletId walletId,
WalletPSBTViewModel vm, string command = null)
{
var network = NetworkProvider.GetNetwork(walletId.CryptoCode);
var psbt = await vm.GetPSBT(network.NBitcoinNetwork);
if (psbt == null)
{
ModelState.AddModelError(nameof(vm.PSBT), "Invalid PSBT");
return(View(vm));
}
switch (command)
{
case null:
vm.Decoded = psbt.ToString();
ModelState.Remove(nameof(vm.PSBT));
ModelState.Remove(nameof(vm.FileName));
ModelState.Remove(nameof(vm.UploadedPSBTFile));
vm.PSBT = psbt.ToBase64();
vm.FileName = vm.UploadedPSBTFile?.FileName;
return(View(vm));
case "ledger":
return(ViewWalletSendLedger(psbt));
case "seed":
return(SignWithSeed(walletId, psbt.ToBase64()));
case "broadcast":
{
return(await WalletPSBTReady(walletId, psbt.ToBase64()));
}
case "combine":
ModelState.Remove(nameof(vm.PSBT));
return(View(nameof(WalletPSBTCombine), new WalletPSBTCombineViewModel()
{
OtherPSBT = psbt.ToBase64()
}));
case "save-psbt":
return(FilePSBT(psbt, vm.FileName));
default:
return(View(vm));
}
}
public async Task <IActionResult> WalletSign([ModelBinder(typeof(WalletIdModelBinder))]
WalletId walletId, WalletPSBTViewModel vm, string returnUrl = null, string command = null)
{
var network = NetworkProvider.GetNetwork <BTCPayNetwork>(walletId.CryptoCode);
if (returnUrl is null)
{
returnUrl = Url.Action(nameof(WalletTransactions), new { walletId });
}
var psbt = await vm.GetPSBT(network.NBitcoinNetwork);
if (psbt is null || vm.InvalidPSBT)
{
ModelState.AddModelError(nameof(vm.PSBT), "Invalid PSBT");
return(View("WalletSigningOptions", new WalletSigningOptionsModel(vm.SigningContext, returnUrl)));
}
switch (command)
{
case "vault":
return(ViewVault(walletId, vm.SigningContext));
case "seed":
return(SignWithSeed(walletId, vm.SigningContext));
case "decode":
return(await WalletPSBT(walletId, vm, "decode"));
default:
break;
}
if (await CanUseHotWallet())
{
var derivationScheme = GetDerivationSchemeSettings(walletId);
if (derivationScheme.IsHotWallet)
{
var extKey = await ExplorerClientProvider.GetExplorerClient(walletId.CryptoCode)
.GetMetadataAsync <string>(derivationScheme.AccountDerivation,
WellknownMetadataKeys.MasterHDKey);
if (extKey != null)
{
return(await SignWithSeed(walletId,
new SignWithSeedViewModel { SeedOrKey = extKey, SigningContext = vm.SigningContext }));
}
}
}
return(View("WalletSigningOptions", new WalletSigningOptionsModel(vm.SigningContext, returnUrl)));
}
public void PrintReadableInfo()
{
var info = String.Empty;
foreach (var type in _supportedInterfaces)
{
var sType = NetworkProvider.GetType();
if (sType.GetInterfaces().Contains(type))
{
info += " - " + type.Name + "\n";
}
}
System.Console.WriteLine($"'{NetworkProvider.Network.Name}':\n{info}");
}
/// <summary>
/// Wechselt die Quellgruppe.
/// </summary>
/// <param name="token">Die Informationen zur neuen Quellgruppe.</param>
/// <returns>Meldet, wie die Bearbeitung fortgesetzt werden soll.</returns>
private PipelineResult SetTuneRequest(TuneToken token)
{
// Ignore termination
if (token == null)
{
return(PipelineResult.Continue);
}
// Connect the request to the network provider
using (var provider = NetworkProvider.MarshalToManaged())
((ITuner)provider.Object).TuneRequest = token.TuneRequest;
// Now run post processings
return(PipelineResult.Continue);
}
public HackerWindow()
{
Program.HackerWindow = this;
processP = Program.ProcessProvider;
serviceP = Program.ServiceProvider;
networkP = Program.NetworkProvider;
InitializeComponent();
{ var handle = this.Handle; }
Program.HackerWindowHandle = this.Handle;
if (OSVersion.HasExtendedTaskbar)
{
Windows7Taskbar.AllowWindowMessagesThroughUipi();
Windows7Taskbar.AppId = "ProcessHacker";
Windows7Taskbar.ProcessAppId = "ProcessHacker";
thumbButtonManager = new ThumbButtonManager(this);
thumbButtonManager.TaskbarButtonCreated += new EventHandler(thumbButtonManager_TaskbarButtonCreated);
}
this.AddEscapeToClose();
Logging.Logged += this.QueueMessage;
Settings.Refresh();
this.LoadWindowSettings();
this.LoadOtherSettings();
this.LoadControls();
this.LoadNotificationIcons();
Program.AppInstance = new ApplicationInstance();
Program.AppInstance.MainMenu = new MainMenuManager(mainMenu.MenuItems);
Program.AppInstance.MainMenu.Hacker = new MenuItemManager(hackerMenuItem.MenuItems);
Program.AppInstance.MainMenu.View = new MenuItemManager(viewMenuItem.MenuItems);
Program.AppInstance.MainMenu.Tools = new MenuItemManager(toolsMenuItem.MenuItems);
Program.AppInstance.MainMenu.Help = new MenuItemManager(helpMenu.MenuItems);
this.LoadPlugins();
if ((!Properties.Settings.Default.StartHidden && !Program.StartHidden) ||
Program.StartVisible)
{
this.Visible = true;
}
if (tabControl.SelectedTab == tabProcesses)
treeProcesses.Tree.Select();
this.LoadOther();
this.LoadStructs();
vistaMenu.DelaySetImageCalls = false;
vistaMenu.PerformPendingSetImageCalls();
serviceP.RunOnceAsync();
serviceP.Enabled = true;
_dontCalculate = false;
}
public Task <RentCodeResult> RequestHolding(
int Duration = 300,
int Unit = 1,
NetworkProvider networkProvider = NetworkProvider.None)
{
var parameters = HttpUtility.ParseQueryString(string.Empty);
parameters["apiKey"] = ApiKey;
parameters["Duration"] = Duration.ToString();
parameters["Unit"] = Unit.ToString();
if (networkProvider != NetworkProvider.None)
{
parameters["NetworkProvider"] = ((int)networkProvider).ToString();
}
return(RequestGet <RentCodeResult>(EndPoint + $"order/request-holding?apiKey={ApiKey}&Duration={Duration}&Unit=1&NetworkProvider={(int)networkProvider}"));
}
public async Task<IActionResult> WalletPSBT([ModelBinder(typeof(WalletIdModelBinder))]
WalletId walletId, WalletPSBTViewModel vm)
{
var network = NetworkProvider.GetNetwork<BTCPayNetwork>(walletId.CryptoCode);
vm.CryptoCode = network.CryptoCode;
vm.NBXSeedAvailable = await CanUseHotWallet() && !string.IsNullOrEmpty(await ExplorerClientProvider.GetExplorerClient(network)
.GetMetadataAsync<string>(GetDerivationSchemeSettings(walletId).AccountDerivation,
WellknownMetadataKeys.Mnemonic));
if (await vm.GetPSBT(network.NBitcoinNetwork) is PSBT psbt)
{
vm.Decoded = psbt.ToString();
vm.PSBT = psbt.ToBase64();
vm.PSBTHex = psbt.ToHex();
}
return View(nameof(WalletPSBT), vm ?? new WalletPSBTViewModel() { CryptoCode = walletId.CryptoCode });
}
void Start()
{
HideLobby();
NetworkProvider.Initialize();
Screen.sleepTimeout = SleepTimeout.NeverSleep;
signOut.gameObject.SetActive(false);
if (NetworkProvider.Instance != null)
{
NetworkProvider.Instance.TrySilentSignIn();
}
else
{
multiPlayer.interactable = false;
}
}
public async Task <IActionResult> WalletPSBT([ModelBinder(typeof(WalletIdModelBinder))]
WalletId walletId)
{
var network = NetworkProvider.GetNetwork <BTCPayNetwork>(walletId.CryptoCode);
var vm = new WalletPSBTViewModel();
vm.CryptoCode = network.CryptoCode;
var derivationSchemeSettings = GetDerivationSchemeSettings(walletId);
if (derivationSchemeSettings == null)
{
return(NotFound());
}
vm.NBXSeedAvailable = await CanUseHotWallet() && derivationSchemeSettings.IsHotWallet;
return(View(vm));
}
public async Task <IActionResult> WalletPSBTReady(
[ModelBinder(typeof(WalletIdModelBinder))]
WalletId walletId, string psbt = null,
string signingKey = null,
string signingKeyPath = null)
{
var network = NetworkProvider.GetNetwork(walletId.CryptoCode);
var vm = new WalletPSBTReadyViewModel()
{
PSBT = psbt
};
vm.SigningKey = signingKey;
vm.SigningKeyPath = signingKeyPath;
await FetchTransactionDetails(walletId, vm, network);
return(View(nameof(WalletPSBTReady), vm));
}
public async Task<IActionResult> WalletPSBTReady(
[ModelBinder(typeof(WalletIdModelBinder))]
WalletId walletId,
WalletPSBTReadyViewModel vm)
{
if (vm is null)
return NotFound();
var network = NetworkProvider.GetNetwork<BTCPayNetwork>(walletId.CryptoCode);
var derivationSchemeSettings = GetDerivationSchemeSettings(walletId);
if (derivationSchemeSettings == null)
return NotFound();
try
{
await FetchTransactionDetails(derivationSchemeSettings, vm, network);
}
catch { return BadRequest(); }
return View(nameof(WalletPSBTReady), vm);
}
public void Setup()
{
INetworkProvider networkProvider = new NetworkProvider();
var config = new MapperConfiguration(cfg =>
{
var assimblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (var assmbly in assimblies)
{
cfg.AddMaps(assmbly);
}
});
var mapper = config.CreateMapper();
var pipeLine = new Pipeline();
stockItemContext = new StockItemContext(networkProvider, mapper, pipeLine);
}
private async void LogOut()
{
LoadingBarEnable(true);
var credentials = new Credentials {
UserId = loginInput.text, Password = passwordInput.text, Status = Status.LogOut
};
var res = await NetworkProvider.Login(credentials);
LoadingBarEnable(false);
if (res.IsError)
{
ShowInfo(res.ErrorMessage);
return;
}
loginPanel.SetActive(true);
mainPanel.SetActive(false);
}
private static void LoadProviders()
{
ProcessProvider = new ProcessSystemProvider();
ServiceProvider = new ServiceProvider();
NetworkProvider = new NetworkProvider();
Program.PrimaryProviderThread = new ProviderThread(Settings.Instance.RefreshInterval)
{
ProcessProvider,
ServiceProvider,
NetworkProvider
};
Program.SecondaryProviderThread = new ProviderThread(Settings.Instance.RefreshInterval);
}
private static void LoadProviders()
{
ProcessProvider = new ProcessSystemProvider();
ServiceProvider = new ServiceProvider();
NetworkProvider = new NetworkProvider();
Program.SharedThreadProvider =
new SharedThreadProvider(Properties.Settings.Default.RefreshInterval);
Program.SharedThreadProvider.Add(ProcessProvider);
Program.SharedThreadProvider.Add(ServiceProvider);
Program.SharedThreadProvider.Add(NetworkProvider);
Program.SecondarySharedThreadProvider =
new SharedThreadProvider(Properties.Settings.Default.RefreshInterval);
}
