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); }