public void Construct(
PlayerPrefPasswordDerivation playerPrefPasswordDerivation,
UserWalletManager userWalletManager,
HopeWalletInfoManager hopeWalletInfoManager,
WalletPasswordVerification walletPasswordVerification,
ContactsManager contactsManager,
DynamicDataCache dynamicDataCache,
ButtonClickObserver buttonClickObserver,
CurrencyManager currencyManager,
LogoutHandler logoutHandler)
{
this.playerPrefPasswordDerivation = playerPrefPasswordDerivation;
this.userWalletManager = userWalletManager;
this.hopeWalletInfoManager = hopeWalletInfoManager;
this.walletPasswordVerification = walletPasswordVerification;
this.contactsManager = contactsManager;
this.dynamicDataCache = dynamicDataCache;
this.buttonClickObserver = buttonClickObserver;
this.currencyManager = currencyManager;
this.logoutHandler = logoutHandler;
buttonClickObserver.SubscribeObservable(this);
defaultCurrencyOptions.ButtonClicked((int)currencyManager.ActiveCurrency);
walletName = hopeWalletInfoManager.GetWalletInfo(userWalletManager.GetWalletAddress()).WalletName;
deleteWalletButton.onClick.AddListener(() => popupManager.GetPopup <GeneralOkCancelPopup>(true)
.SetSubText($"Are you sure you want to delete wallet '{walletName}'?\nThis cannot be undone!")
.OnOkClicked(() => DeleteWallet(userWalletManager, hopeWalletInfoManager, logoutHandler))
.DisableEnterButton());
}
public void Construct(
CurrencyManager currencyManager,
UserWalletManager userWalletManager,
TradableAssetManager tradableAssetManager,
TradableAssetPriceManager tradableAssetPriceManager,
EthereumTransactionButtonManager ethereumTransactionButtonManager,
EtherBalanceObserver etherBalanceObserver,
GasPriceObserver gasPriceObserver,
UpdateManager updateManager,
DynamicDataCache dynamicDataCache,
PeriodicUpdateManager periodicUpdateManager,
ContactsManager contactsManager,
ButtonClickObserver buttonClickObserver,
RestrictedAddressManager restrictedAddressManager)
{
this.ethereumTransactionButtonManager = ethereumTransactionButtonManager;
this.userWalletManager = userWalletManager;
this.dynamicDataCache = dynamicDataCache;
this.buttonClickObserver = buttonClickObserver;
Asset = new AssetManager(tradableAssetManager, etherBalanceObserver, updateManager, assetSymbol, assetBalance, assetImage);
Gas = new GasManager(tradableAssetManager, tradableAssetPriceManager, currencyManager, gasPriceObserver, periodicUpdateManager, advancedModeToggle, transactionSpeedSlider, gasLimitField, gasPriceField, transactionFee);
Address = new AddressManager(addressField, contactName, contactsManager, restrictedAddressManager);
Amount = new AmountManager(currencyManager, tradableAssetPriceManager, maxToggle, maxText, amountField, currencyText, oppositeCurrencyAmountText, currencyButton, assetSymbol.text);
Gas.SetupDependencies(Amount);
Amount.SetupDependencies(Gas, Asset);
simpleModeSelectableFields.Add(addressField.InputFieldBase);
simpleModeSelectableFields.Add(amountField.InputFieldBase);
advancedModeSelectableFields.AddRange(simpleModeSelectableFields);
advancedModeSelectableFields.Add(gasLimitField.InputFieldBase);
advancedModeSelectableFields.Add(gasPriceField.InputFieldBase);
}
public void Construct(
EthereumTransactionManager ethereumTransactionManager,
EthereumNetworkManager.Settings ethereumNetworkSettings,
EthereumPendingTransactionManager ethereumPendingTransactionManager,
TokenContractManager tokenContractManager,
TradableAssetManager tradableAssetManager,
TradableAssetPriceManager tradableAssetPriceManager,
TradableAssetNotificationManager notificationManager,
LockedPRPSManager lockedPrpsManager,
PRPS prpsContract,
CurrencyManager currencyManager,
HopeWalletInfoManager hopeWalletInfoManager,
UserWalletManager userWalletManager,
LogoutHandler logoutHandler)
{
this.ethereumNetworkSettings = ethereumNetworkSettings;
this.ethereumTransactionManager = ethereumTransactionManager;
this.ethereumPendingTransactionManager = ethereumPendingTransactionManager;
this.tokenContractManager = tokenContractManager;
this.tradableAssetManager = tradableAssetManager;
this.tradableAssetPriceManager = tradableAssetPriceManager;
this.notificationManager = notificationManager;
this.lockedPrpsManager = lockedPrpsManager;
this.prpsContract = prpsContract;
this.currencyManager = currencyManager;
this.hopeWalletInfoManager = hopeWalletInfoManager;
this.userWalletManager = userWalletManager;
this.logoutHandler = logoutHandler;
}
public PasswordSection(
PlayerPrefPasswordDerivation playerPrefPasswordDerivation,
UserWalletManager userWalletManager,
HopeWalletInfoManager hopeWalletInfoManager,
DynamicDataCache dynamicDataCache,
SettingsPopupAnimator settingsPopupAnimator,
HopeInputField newPasswordField,
HopeInputField confirmPasswordField,
Button saveButton,
GameObject loadingIcon)
{
this.playerPrefPasswordDerivation = playerPrefPasswordDerivation;
this.hopeWalletInfoManager = hopeWalletInfoManager;
this.dynamicDataCache = dynamicDataCache;
this.settingsPopupAnimator = settingsPopupAnimator;
this.newPasswordField = newPasswordField;
this.confirmPasswordField = confirmPasswordField;
this.saveButton = saveButton;
this.loadingIcon = loadingIcon;
walletEncryptor = new WalletEncryptor(playerPrefPasswordDerivation, dynamicDataCache);
walletDecryptor = new WalletDecryptor(playerPrefPasswordDerivation, dynamicDataCache);
walletInfo = hopeWalletInfoManager.GetWalletInfo(userWalletManager.GetWalletAddress());
newPasswordField.OnInputUpdated += _ => PasswordsUpdated();
confirmPasswordField.OnInputUpdated += _ => PasswordsUpdated();
saveButton.onClick.AddListener(SavePasswordButtonClicked);
}
/// <summary>
/// Initializes this TradableAsset with the address of 0x0 and the symbol ETH.
/// </summary>
/// <param name="onAssetCreated"> Callback to execute once this asset has been created and the current balance received. </param>
/// <param name="tradableAssetImageManager"> The active TradableAssetImageManager. </param>
/// <param name="userWalletManager"> The active UserWalletManager. </param>
public EtherAsset(
Action <TradableAsset> onAssetCreated,
TradableAssetImageManager tradableAssetImageManager,
UserWalletManager userWalletManager) : base(ETHER_ADDRESS, "ETH", "Ether", 18, tradableAssetImageManager, userWalletManager)
{
InitializeBasicInfo(onAssetCreated);
}
/// <summary>
/// Initializes the EthereumTransactionManager by initializing all collections and adding the proper methods to the events needed.
/// </summary>
/// <param name="disposableComponentManager"> The active DisposableComponentManager. </param>
/// <param name="periodicUpdateManager"> The PeriodicUpdateManager to use when periodically checking for new transactions. </param>
/// <param name="updateManager"> The UpdateManager to use when getting the transactions for each asset. </param>
/// <param name="userWalletManager"> The active UserWalletManager. </param>
/// <param name="apiService"> The active EtherscanApiService. </param>
/// <param name="tradableAssetManager"> The active TradableAssetManager. </param>
public EthereumTransactionManager(
DisposableComponentManager disposableComponentManager,
PeriodicUpdateManager periodicUpdateManager,
UpdateManager updateManager,
TradableAssetManager tradableAssetManager,
UserWalletManager userWalletManager,
EtherscanApiService apiService)
{
tradableAssetManager.OnTradableAssetAdded += AddAssetToScrape;
OptimizedScrollview.OnOptimizedScrollviewInitialized += optimizedScrollview =>
{
if (optimizedScrollview.scrollviewKey.Equals("asset_scrollview"))
{
scrollview = optimizedScrollview;
scrollview.OnVisibleItemsChanged += OnVisibleAssetsChanged;
periodicUpdateManager.AddPeriodicUpdater(this);
}
};
this.tradableAssetManager = tradableAssetManager;
this.userWalletManager = userWalletManager;
this.apiService = apiService;
disposableComponentManager.AddDisposable(this);
updateManager.AddUpdater(this);
}
public void ProcessQueueMessage([QueueTrigger("%azure-queue-accessdata%")] string message, TextWriter log)
{
try
{
UserWalletManager userWalletManager = new UserWalletManager();
MailManager mailManager = new MailManager();
Notification notification = userWalletManager.GetNotification(message);
var user = aspNetUserManager.GetById(notification.IdUser);
var wallet = Task.Run(() => NethereumHelper.CreateUserWallet()).Result;
user.TokenAddress = wallet.blobname;
user.WalletAddress = wallet.walletaddress;
aspNetUserManager.Update(user);
MailMessage mailMessage = new MailMessage()
{
Body = notification.MailContent,
Destination = user.Email,
Subject = "Confirm your email"
};
mailManager.SendAsync(mailMessage);
}
catch (Exception ex)
{
var messageException = telemetria.MakeMessageException(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
telemetria.Critical(messageException);
}
}
public TradableAssetNotificationManager(
EthereumNetworkManager.Settings networkSettings,
DisposableComponentManager disposableComponentManager,
UserWalletManager userWalletManager,
TradableAssetManager tradableAssetManager,
EthereumTransactionManager ethereumTransactionManager,
LockedPRPSManager lockedPrpsManager,
PRPS prpsContract)
{
this.networkSettings = networkSettings;
this.userWalletManager = userWalletManager;
this.ethereumTransactionManager = ethereumTransactionManager;
this.lockedPrpsManager = lockedPrpsManager;
this.prpsContract = prpsContract;
disposableComponentManager.AddDisposable(this);
UserWalletManager.OnWalletLoadSuccessful += LoadNewNotificationList;
tradableAssetManager.OnTradableAssetAdded += AssetAdded;
tradableAssetManager.OnTradableAssetRemoved += AssetRemoved;
ethereumTransactionManager.OnTransactionsAdded += TransactionsUpdated;
lockedPrpsManager.OnLockedPRPSUpdated += TransactionsUpdated;
}
public WalletNameSection(
HopeWalletInfoManager hopeWalletInfoManager,
WalletPasswordVerification walletPasswordVerification,
ContactsManager contactsManager,
DynamicDataCache dynamicDataCache,
UserWalletManager userWalletManager,
SettingsPopupAnimator settingsPopupAnimator,
GameObject currentPasswordSection,
GameObject walletNameSection,
GameObject loadingIcon,
HopeInputField currentPasswordField,
HopeInputField currentWalletNameField,
HopeInputField newWalletNameField,
Button nextButton,
Button saveButton,
GameObject[] hopeOnlyCategoryButtons)
{
this.hopeWalletInfoManager = hopeWalletInfoManager;
this.walletPasswordVerification = walletPasswordVerification;
this.contactsManager = contactsManager;
this.dynamicDataCache = dynamicDataCache;
this.settingsPopupAnimator = settingsPopupAnimator;
this.currentPasswordSection = currentPasswordSection;
this.walletNameSection = walletNameSection;
this.loadingIcon = loadingIcon;
this.currentPasswordField = currentPasswordField;
this.currentWalletNameField = currentWalletNameField;
this.newWalletNameField = newWalletNameField;
this.nextButton = nextButton;
this.saveButton = saveButton;
this.hopeOnlyCategoryButtons = hopeOnlyCategoryButtons;
walletInfo = hopeWalletInfoManager.GetWalletInfo(userWalletManager.GetWalletAddress());
SetListeners();
}
public void Construct(TradableAssetManager tradableAssetManager,
TradableAssetImageManager tradableAssetImageManager,
UserWalletManager userWalletManager)
{
this.tradableAssetManager = tradableAssetManager;
this.tradableAssetImageManager = tradableAssetImageManager;
this.userWalletManager = userWalletManager;
}
/// <summary>
/// Initializes this TradableAsset with the TokenContract of the token.
/// </summary>
/// <param name="erc20TokenContract"> The TokenContract of this asset. </param>
/// <param name="onAssetCreated"> Callback to execute once the asset has been initialized and the current balance received. </param>
/// <param name="tradableAssetImageManager"> The active TradableAssetImageManager. </param>
/// <param name="userWalletManager"> The active UserWalletManager. </param>
public ERC20TokenAsset(
ERC20 erc20TokenContract,
Action <TradableAsset> onAssetCreated,
TradableAssetImageManager tradableAssetImageManager,
UserWalletManager userWalletManager) :
base(erc20TokenContract.ContractAddress, erc20TokenContract.Symbol, erc20TokenContract.Name, erc20TokenContract.Decimals.Value, tradableAssetImageManager, userWalletManager)
{
this.erc20TokenContract = erc20TokenContract;
InitializeBasicInfo(onAssetCreated);
}
/// <summary>
/// Creates an instance of a <see cref="ContractFunction"/> of type <typeparamref name="T"/> to use to send a contract message.
/// </summary>
/// <typeparam name="T"> The concrete type of <see cref="ContractFunction"/>. </typeparam>
/// <param name="userWalletManager"> The active <see cref="UserWalletManager"/> instance. </param>
/// <param name="gasPrice"> The <see cref="HexBigInteger"/> gas price to use with the transaction when the function is executed. </param>
/// <param name="gasLimit"> The <see cref="HexBigInteger"/> gas limit to use with the transaction when the function is executed. </param>
/// <param name="functionInput"> The input parameters to pass through the function. </param>
/// <returns> The newly created instance of <see cref="ContractFunction"/> of type <typeparamref name="T"/>. </returns>
public static T CreateFunction <T>(UserWalletManager userWalletManager, HexBigInteger gasPrice, HexBigInteger gasLimit, params object[] functionInput) where T : ContractFunction
{
T func = CreateFunction <T>(functionInput);
func.FromAddress = userWalletManager.GetWalletAddress();
func.GasPrice = gasPrice.Value;
func.Gas = gasLimit.Value;
return(func);
}
public void Construct(
UserWalletManager userWalletManager,
HopeWalletInfoManager walletInfoManager,
EthereumNetworkManager.Settings ethereumNetworkSettings)
{
this.userWalletManager = userWalletManager;
this.walletInfoManager = walletInfoManager;
this.ethereumNetworkSettings = ethereumNetworkSettings;
networkSettingDropdown.value = ethereumNetworkSettings.networkType == EthereumNetworkManager.NetworkType.Mainnet ? 0 : 1;
}
/// <summary>
/// Initializes the TokenContractManager by creating all collections and getting the settings.
/// </summary>
/// <param name="popupManager"> The active PopupManager. </param>
/// <param name="tradableAssetImageManager"> The active TradableAssetImageManager. </param>
/// <param name="userWalletManager"> The active UserWalletManager. </param>
/// <param name="networkSettings"> The current EthereumNetworkManager settings. </param>
public TokenContractManager(PopupManager popupManager,
TradableAssetImageManager tradableAssetImageManager,
UserWalletManager userWalletManager,
EthereumNetworkManager.Settings networkSettings)
{
this.popupManager = popupManager;
this.tradableAssetImageManager = tradableAssetImageManager;
this.userWalletManager = userWalletManager;
tokens = new SecurePlayerPrefList <TokenInfo>(PlayerPrefConstants.SAVED_TOKEN_CONTRACTS, (int)networkSettings.networkType);
networkSettings.OnNetworkChanged += network => tokens = new SecurePlayerPrefList <TokenInfo>(PlayerPrefConstants.SAVED_TOKEN_CONTRACTS, (int)network);
}
public void Construct(
UIManager uiManager,
UserWalletManager userWalletManager,
DynamicDataCache dynamicDataCache,
ButtonClickObserver buttonClickObserver,
WalletPasswordVerification walletPasswordVerification)
{
this.uiManager = uiManager;
this.userWalletManager = userWalletManager;
this.dynamicDataCache = dynamicDataCache;
this.buttonClickObserver = buttonClickObserver;
this.walletPasswordVerification = walletPasswordVerification;
}
private void DeleteWallet(UserWalletManager userWalletManager, HopeWalletInfoManager hopeWalletInfoManager, LogoutHandler logoutHandler)
{
var wallets = hopeWalletInfoManager.Wallets;
var walletToDelete = hopeWalletInfoManager.GetWalletInfo(userWalletManager.GetWalletAddress());
for (int i = wallets.IndexOf(walletToDelete) + 1; i < wallets.Count; i++)
{
hopeWalletInfoManager.UpdateWalletInfo(wallets[i].WalletNum, new WalletInfo(wallets[i].EncryptedWalletData, wallets[i].WalletName, wallets[i].WalletAddresses, wallets[i].WalletNum - 1));
}
hopeWalletInfoManager.DeleteWalletInfo(walletToDelete);
logoutHandler.Logout();
}
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;
}
/// <summary>
/// Transfers a specified amount of ether from the input UserWallet to a specified address.
/// </summary>
/// <param name="userWalletManager"> The wallet to send the ether from. </param>
/// <param name="gasLimit"> The gas limit to use for this ether send transaction. </param>
/// <param name="gasPrice"> The gas price to use for this ether send transaction. </param>
/// <param name="address"> The address to send the ether to. </param>
/// <param name="amount"> The amount of ether to send. </param>
public override void Transfer(UserWalletManager userWalletManager, HexBigInteger gasLimit, HexBigInteger gasPrice, string address, decimal amount)
{
userWalletManager.SignTransaction <ConfirmTransactionPopup>(
request => EthUtils.SendEther(request, gasLimit, gasPrice, userWalletManager.GetWalletAddress(), address, amount),
gasLimit,
gasPrice,
SolidityUtils.ConvertToUInt(amount, 18),
address,
"",
address,
AssetAddress,
amount,
"ETH");
}
public void Construct(UserWalletManager userWalletManager)
{
this.userWalletManager = userWalletManager;
if (userWalletManager.ActiveWalletType != UserWalletManager.WalletType.Hope)
{
confirmText.SetActive(true);
exitButton.SetActive(true);
exitButton.GetComponent <Button>().onClick.AddListener(CancelButton);
}
else if (!SecurePlayerPrefs.GetBool(PlayerPrefConstants.SETTING_COUNTDOWN_TIMER))
{
okButton.GetComponent <Button>().interactable = true;
}
}
/// <summary>
/// Initializes the TradableAsset by setting up the address and symbol.
/// </summary>
/// <param name="address"> The address of this asset. </param>
/// <param name="symbol"> The symbol of this asset. </param>
/// <param name="name"> The name of this asset. </param>
/// <param name="decimals"> The number of decimal places of the asset. </param>
/// <param name="tradableAssetImageManager"> The active TradableAssetImageManager. </param>
/// <param name="userWalletManager"> The active UserWalletManager. </param>
protected TradableAsset(
string address,
string symbol,
string name,
int decimals,
TradableAssetImageManager tradableAssetImageManager,
UserWalletManager userWalletManager)
{
AssetAddress = address.ToLower();
AssetSymbol = symbol;
AssetName = name;
AssetDecimals = decimals;
this.tradableAssetImageManager = tradableAssetImageManager;
this.userWalletManager = userWalletManager;
}
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();
}
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>
/// Releases some purpose from the Hodler smart contract.
/// </summary>
/// <param name="userWalletManager"> The class managing the wallet. </param>
/// <param name="gasLimit"> The gas limit to send with the transaction. </param>
/// <param name="gasPrice"> The gas price to send with the transaction. </param>
/// <param name="id"> The id of the locked purpose item. </param>
/// <param name="amountToRelease"> The amount of purpose that will be released. </param>
public void Release(UserWalletManager userWalletManager, HexBigInteger gasLimit, HexBigInteger gasPrice, BigInteger id, decimal amountToRelease)
{
var transactionInput = ContractFunction.CreateFunction <Messages.Release>(
userWalletManager,
gasPrice,
gasLimit,
id).CreateTransactionInput(ContractAddress);
userWalletManager.SignTransaction <ConfirmReleasePopup>(
request => ContractUtils.SendContractMessage("Releasing PRPS", transactionInput, request),
gasLimit,
gasPrice,
0,
ContractAddress,
transactionInput.Data,
amountToRelease);
}
/// <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;
}
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;
}
public void Construct(
HopeWalletInfoManager hopeWalletInfoManager,
UserWalletManager userWalletManager,
WalletPasswordVerification walletPasswordVerification,
LogoutHandler logoutHandler,
DynamicDataCache dynamicDataCache,
ButtonClickObserver buttonClickObserver)
{
this.walletPasswordVerification = walletPasswordVerification;
this.logoutHandler = logoutHandler;
this.dynamicDataCache = dynamicDataCache;
this.buttonClickObserver = buttonClickObserver;
walletName = hopeWalletInfoManager.GetWalletInfo(userWalletManager.GetWalletAddress()).WalletName;
formTitle.text = walletName;
SetMessageText();
(dynamicDataCache.GetData("pass") as ProtectedString)?.SetValue(RandomBytes.Secure.SHA3.GetBytes(16));
}
/// <summary>
/// Locks a certain amount of purpose into the Hodler smart contract.
/// </summary>
/// <param name="userWalletManager"> The class managing the wallet. </param>
/// <param name="gasLimit"> The gas limit to send with the transaction. </param>
/// <param name="gasPrice"> The gas price to send with the transaction. </param>
/// <param name="id"> The id of the lock function call. </param>
/// <param name="value"> The amount of purpose to lock. </param>
/// <param name="monthsToLock"> How many months the purpose should be locked for. </param>
public void Hodl(UserWalletManager userWalletManager, HexBigInteger gasLimit, HexBigInteger gasPrice, BigInteger id, decimal value, int monthsToLock)
{
var transactionInput = ContractFunction.CreateFunction <Messages.Hodl>(
userWalletManager,
gasPrice,
gasLimit,
id,
SolidityUtils.ConvertToUInt(value, 18),
new BigInteger(monthsToLock)).CreateTransactionInput(ContractAddress);
userWalletManager.SignTransaction <ConfirmLockPopup>(
request => ContractUtils.SendContractMessage("Locking PRPS", transactionInput, request),
gasLimit,
gasPrice,
0,
ContractAddress,
transactionInput.Data,
monthsToLock,
value);
}
public void Construct(
TokenListManager tokenListManager,
TokenContractManager tokenContractManager,
TradableAssetImageManager tradableAssetImageManager,
UserWalletManager userWalletManager,
AddableTokenButton.Factory addableTokenButtonFactory,
ButtonClickObserver buttonClickObserver)
{
this.tokenListManager = tokenListManager;
this.tokenContractManager = tokenContractManager;
this.tradableAssetImageManager = tradableAssetImageManager;
this.userWalletManager = userWalletManager;
this.addableTokenButtonFactory = addableTokenButtonFactory;
this.buttonClickObserver = buttonClickObserver;
buttonClickObserver.SubscribeObservable(this);
selectableFields.Add(addressField.InputFieldBase);
selectableFields.Add(symbolField.InputFieldBase);
selectableFields.Add(decimalsField.InputFieldBase);
}
/// <summary>
/// Transfers a certain number of tokens of this contract from a wallet to another address.
/// </summary>
/// <param name="userWalletManager"> The wallet to transfer the tokens from. </param>
/// <param name="gasLimit"> The gas limit to use when sending the tokens. </param>
/// <param name="gasPrice"> The gas price to use when sending the tokens. </param>
/// <param name="address"> The address to transfer the tokens to. </param>
/// <param name="amount"> The amount of tokens to transfer. </param>
public void Transfer(UserWalletManager userWalletManager, HexBigInteger gasLimit, HexBigInteger gasPrice, string address, decimal amount)
{
var transactionInput = ContractFunction.CreateFunction <Messages.Transfer>(
userWalletManager,
gasPrice,
gasLimit,
address,
SolidityUtils.ConvertToUInt(amount, Decimals.Value)).CreateTransactionInput(ContractAddress);
userWalletManager.SignTransaction <ConfirmTransactionPopup>(
request => ContractUtils.SendContractMessage($"Sending {Symbol}", transactionInput, request),
gasLimit,
gasPrice,
0,
ContractAddress,
transactionInput.Data,
address,
ContractAddress,
amount,
Symbol);
}
/// <summary>
/// Adds contact under the newly created wallet name and address
/// </summary>
/// <param name="userWalletManager"> The active UserWalletManager </param>
/// <param name="userWalletInfoManager"> The active UserWalletInfoManager </param>
/// <param name="settings"> The settings for the ContactsManager. </param>
/// <param name="networkSettings"> The settings for the EthereumNetworkManager. </param>
public ContactsManager(
UserWalletManager userWalletManager,
HopeWalletInfoManager userWalletInfoManager,
EthereumNetworkManager.Settings networkSettings)
{
UserWalletManager.OnWalletLoadSuccessful += () =>
{
ContactList = new SecurePlayerPrefList <ContactInfo>(PlayerPrefConstants.CONTACT_LIST, (int)networkSettings.networkType);
var walletAddress = userWalletManager.GetWalletAddress();
if (!ContactList.Contains(walletAddress.ToLower()))
{
var info = userWalletInfoManager.GetWalletInfo(walletAddress);
if (!string.IsNullOrEmpty(info?.WalletName))
{
AddContact(walletAddress.ToLower(), info.WalletName);
}
}
};
}
