public void Construct(
     PopupManager popupManager,
     TradableAssetManager tradableAssetManager,
     TradableAssetImageManager tradableAssetImageManager,
     ContactsManager contactsManager,
     Hodler hodler)
 {
     this.popupManager              = popupManager;
     this.tradableAssetManager      = tradableAssetManager;
     this.tradableAssetImageManager = tradableAssetImageManager;
     this.contactsManager           = contactsManager;
     this.hodler = hodler;
 }
 public void Construct(
     EthereumNetworkManager.Settings networkSettings,
     Hodler hodlerContract,
     UserWalletManager userWalletManager,
     GasPriceObserver gasPriceObserver,
     EtherBalanceObserver etherBalanceObserver)
 {
     this.networkSettings      = networkSettings;
     this.hodlerContract       = hodlerContract;
     this.userWalletManager    = userWalletManager;
     this.gasPriceObserver     = gasPriceObserver;
     this.etherBalanceObserver = etherBalanceObserver;
 }
    public void Construct(
        TradableAssetManager tradableAssetManager,
        TradableAssetImageManager tradableAssetImageManager,
        ContactsManager contactsManager,
        UserWalletManager userWalletManager,
        HopeWalletInfoManager userWalletInfoManager,
        Hodler hodler)
    {
        this.tradableAssetManager      = tradableAssetManager;
        this.tradableAssetImageManager = tradableAssetImageManager;
        this.contactsManager           = contactsManager;
        this.hodler = hodler;

        walletAddress = userWalletManager.GetWalletAddress();
        walletName    = userWalletManager.ActiveWalletType == UserWalletManager.WalletType.Hope ? userWalletInfoManager.GetWalletInfo(walletAddress).WalletName : userWalletManager.ActiveWalletType.ToString();
    }
Example #4
0
    public void Construct(
        TradableAssetPriceManager tradableAssetPriceManager,
        CurrencyManager currencyManager,
        LockPRPSManager lockPRPSManager,
        LockedPRPSManager lockedPRPSManager,
        GasPriceObserver gasPriceObserver,
        EtherBalanceObserver etherBalanceObserver,
        Hodler hodlerContract,
        UserWalletManager userWalletManager,
        ButtonClickObserver buttonClickObserver)
    {
        this.lockedPRPSManager    = lockedPRPSManager;
        this.etherBalanceObserver = etherBalanceObserver;
        this.userWalletManager    = userWalletManager;
        this.hodlerContract       = hodlerContract;
        this.buttonClickObserver  = buttonClickObserver;
        etherBalanceObserver.SubscribeObservable(this);
        buttonClickObserver.SubscribeObservable(this);

        Gas    = new GasManager(tradableAssetPriceManager, currencyManager, lockPRPSManager, gasPriceObserver, slider, transactionFeeText, this);
        Amount = new AmountManager(lockPRPSManager, maxToggle, amountInputField, prpsBalanceText, dubiBalanceText, dubiRewardText, tooltipItems[2]);
        Time   = new TimeManager(Amount, threeMonthsButton, sixMonthsButton, twelveMonthsButton, dubiRewardText);

        if (lockPRPSManager.PRPSBalance == 0)
        {
            maxToggle.SetInteractable(false);
            maxText.color = UIColors.LightGrey;
        }

        bool showTooltips = SecurePlayerPrefs.GetBool(PlayerPrefConstants.SETTING_SHOW_TOOLTIPS);

        foreach (TooltipItem tooltip in tooltipItems)
        {
            if (showTooltips)
            {
                tooltip.PopupManager = popupManager;
            }
            else if (tooltip.infoIcon)
            {
                tooltip.gameObject.SetActive(false);
            }
            else
            {
                tooltip.enabled = false;
            }
        }
    }
    /// <summary>
    /// Initializes the LockPRPSManager with all dependencies.
    /// </summary>
    /// <param name="userWalletManager"> The active UserWalletManager. </param>
    /// <param name="periodicUpdateManager"> The active PeriodicUpdateManager. </param>
    /// <param name="prpsContract"> The active PRPS smart contract. </param>
    /// <param name="dubiContract"> The active DUBI smart contract. </param>
    /// <param name="hodlerContract"> The active Hodler smart contract. </param>
    /// <param name="tradableAssetManager"> The active TradableAssetManager. </param>
    public LockPRPSManager(
        UserWalletManager userWalletManager,
        PeriodicUpdateManager periodicUpdateManager,
        PRPS prpsContract,
        DUBI dubiContract,
        Hodler hodlerContract,
        TradableAssetManager tradableAssetManager)
    {
        this.prpsContract          = prpsContract;
        this.dubiContract          = dubiContract;
        this.hodlerContract        = hodlerContract;
        this.userWalletManager     = userWalletManager;
        this.periodicUpdateManager = periodicUpdateManager;

        tradableAssetManager.OnTradableAssetAdded   += CheckIfPRPSAdded;
        tradableAssetManager.OnTradableAssetRemoved += CheckIfPRPSRemoved;
    }
Example #6
0
        public long NextId()
        {
            long incrementedCurrent = Interlocked.Increment(ref current);

            while (incrementedCurrent > currentMax.Value)
            {
                lock (generatorLock)
                {
                    if (current > currentMax.Value)
                    {
                        currentMax = new Hodler(GetNextMax());
                    }
                    return(Interlocked.Increment(ref current));
                }
            }
            return(incrementedCurrent);
        }
Example #7
0
		public long NextId()
		{
			long incrementedCurrent = Interlocked.Increment(ref current);
			while (incrementedCurrent > currentMax.Value)
			{
				lock (generatorLock)
				{
					if (current > currentMax.Value)
					{
						currentMax = new Hodler(GetNextMax());
					}
					return Interlocked.Increment(ref current);
				}
			}
			return incrementedCurrent;

		}
    public LockedPRPSManager(
        DisposableComponentManager disposableComponentManager,
        UserWalletManager userWalletManager,
        Hodler hodlerContract,
        PRPS prpsContract,
        PeriodicUpdateManager periodicUpdateManager,
        EtherscanApiService apiService,
        TradableAssetManager tradableAssetManager)
    {
        this.userWalletManager     = userWalletManager;
        this.periodicUpdateManager = periodicUpdateManager;
        this.hodlerContract        = hodlerContract;
        this.prpsContract          = prpsContract;
        this.apiService            = apiService;

        disposableComponentManager.AddDisposable(this);

        tradableAssetManager.OnTradableAssetAdded   += CheckIfPRPSAdded;
        tradableAssetManager.OnTradableAssetRemoved += CheckIfPRPSRemoved;
    }
Example #9
0
		public long NextId()
		{
			long incrementedCurrent = Interlocked.Increment(ref current);
			while (incrementedCurrent > currentMax.Value)
			{
				lock (generatorLock)
				{
					if (current > currentMax.Value)
					{
                        using (var locker = Database.DocumentLock.TryLock(250))
                        {
                            if (locker == null)
                                continue;
                            currentMax = new Hodler(GetNextMax());
                        }
					}
					return Interlocked.Increment(ref current);
				}
			}
			return incrementedCurrent;

		}
Example #10
0
        public long NextId()
        {
            long incrementedCurrent = Interlocked.Increment(ref current);

            while (incrementedCurrent > currentMax.Value)
            {
                lock (generatorLock)
                {
                    if (current > currentMax.Value)
                    {
                        using (var locker = Database.DocumentLock.TryLock(250))
                        {
                            if (locker == null)
                            {
                                continue;
                            }
                            currentMax = new Hodler(GetNextMax());
                        }
                    }
                    return(Interlocked.Increment(ref current));
                }
            }
            return(incrementedCurrent);
        }