public SendTransactionViewModel(IEthereumHostProvider ethereumHostProvider, IScreen hostScreen = null, CurrentAccountTransactionsService currentAccountTransactionsService = null)
{
this.HostScreen = hostScreen;
_ethereumHostProvider = ethereumHostProvider ?? Locator.Current.GetService <IEthereumHostProvider>();
_currentAccountTransactionsService = currentAccountTransactionsService ?? Locator.Current.GetService <CurrentAccountTransactionsService>();
_ethereumHostProvider.SelectedAccountCallback.Subscribe(x => Address = x);
this._confirmTransfer = new Interaction <string, bool>();
Gas = (ulong)Signer.Transaction.DEFAULT_GAS_LIMIT;
GasPrice = Web3.Web3.Convert.FromWei(Signer.Transaction.DEFAULT_GAS_PRICE, Nethereum.Util.UnitConversion.EthUnit.Gwei);
this.ValidationRule(x => x.AddressTo, address => Util.Utils.IsValidAddress(address), "Address is not valid");
this.ValidationRule(x => x.AmountInEther, amount => amount >= 0, "Amount cannot be negative");
IObservable <IValidationState> balanceValidated =
this.WhenAnyValue(x => x.AmountInEther, x => x.Gas, x => x.GasPrice)
.Throttle(TimeSpan.FromSeconds(1), RxApp.TaskpoolScheduler)
.SelectMany(x => ValidateEnoughBalance(x.Item1, x.Item2, x.Item3))
.ObserveOn(RxApp.MainThreadScheduler);
this.ValidationRule(vm => vm.AmountInEther, balanceValidated);
var canExecuteTransaction = this.IsValid();
var canExecuteTransactionAndEnabled = Observable.CombineLatest(canExecuteTransaction, _ethereumHostProvider.EnabledCallBack, (valid, enabled) => valid && enabled);
this._executeTrasnactionCommand = ReactiveCommand.CreateFromTask(ExecuteAsync, canExecuteTransactionAndEnabled);
this._goBackCommand = ReactiveCommand.CreateFromTask(GoBackAsync);
}
public StandardTokenTransferViewModel(IEthereumHostProvider ethereumHostProvider, IContractService contractService, IScreen screenHost)
{
this._ethereumHostProvider = ethereumHostProvider;
this._contractService = contractService;
this._screenHost = screenHost;
this._contractService.ContractAddress.Subscribe(x => ContractAddress = x);
this.ValidationRule(x => x.AddressTo, address => Nethereum.UI.Util.Utils.IsValidAddress(address), "Address is not valid");
this.ValidationRule(x => x.Amount, amount => amount >= 0, "Amount cannot be negative");
var canExecuteTransaction = this.WhenAnyValue(
x => x.AddressTo,
x => x.Amount,
x => x.ContractAddress,
(addressTo, amount, contractAddress) =>
Nethereum.UI.Util.Utils.IsValidAddress(addressTo) &&
amount != null && amount > 0 &&
contractAddress != null);
var canExecuteAndEnabled = Observable.CombineLatest(canExecuteTransaction, _ethereumHostProvider.EnabledCallBack, (valid, enabled) => valid && enabled);
this._executeTransactionCommand = ReactiveCommand.CreateFromTask(ExecuteAsync, canExecuteAndEnabled);
}
public StandardTokenViewModel(IEthereumHostProvider ethereumHostProvider)
{
this.routingState = new RoutingState();
var provider = ethereumHostProvider ?? Locator.Current.GetService <IEthereumHostProvider>();
var contractService = Locator.Current.GetService <IContractService>();
ContractAdddressViewModel = new ContractAdddressViewModel(contractService);
StandardTokenBalanceOfViewModel = new StandardTokenBalanceOfViewModel(provider, contractService);
StandardTokenTransferViewModel = new StandardTokenTransferViewModel(provider, contractService, this);
}
public TransactionsViewModel(IEthereumHostProvider ethereumHostProvider, CurrentAccountTransactionsService currentAccountTransactionsService)
{
this.currentAccountTransactionsService = currentAccountTransactionsService;
this.currentAccountTransactionsService.Transactions.Connect()
.Transform(transaction => new TransactionViewModel(transaction))
.AutoRefresh()
.Sort(SortExpressionComparer <TransactionViewModel> .Descending(t => t.Status).ThenByDescending(t => t.BlockNumber))
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(out _transactions)
.DisposeMany()
.Subscribe();
}
public CurrentAccountTransactionsService(IEthereumHostProvider ethereumHostProvider, int updateIntervalMilliseconds = 2000)
{
updateInterval = TimeSpan.FromMilliseconds(updateIntervalMilliseconds);
this.ethereumHostProvider = ethereumHostProvider;
this.ethereumHostProvider.SelectedAccountCallback.Subscribe(address =>
{
if (address != currentAccount)
{
currentAccount = address;
_transactions.Clear();
//We should save ... reload
}
});
timer = Observable.Timer(updateInterval, updateInterval, RxApp.MainThreadScheduler)
.Subscribe(async _ => await CheckReceiptsAsync());
}
public StandardTokenBalanceOfViewModel(IEthereumHostProvider ethereumHostProvider, IContractService contractService)
{
this.ethereumHostProvider = ethereumHostProvider;
this.ethereumHostProvider.SelectedAccountCallback.Subscribe(address => AccountAddress = address);
this.contractService = contractService;
this.contractService.ContractAddress.Subscribe(x => ContractAddress = x);
var hasValidAddresses = this.WhenAnyValue(x => x.AccountAddress, x => x.ContractAddress,
(address, contractAddress) => Nethereum.UI.Util.Utils.IsValidAddress(address) && Nethereum.UI.Util.Utils.IsValidAddress(contractAddress));
var isValidRefreshBalance = Observable.CombineLatest(hasValidAddresses, this.ethereumHostProvider.EnabledCallBack, (validAdress, enabled) => validAdress && enabled);
isValidRefreshBalance.Where(x => x == true)
.Subscribe(async _ => await RefreshBalanceAsync());
_refreshBalanceCommand = ReactiveCommand.CreateFromTask(RefreshBalanceAsync, isValidRefreshBalance);
}
public NethereumAuthenticator(IEthereumHostProvider host)
{
_host = host;
}
