private async Task <int> GetPromiseCount(ApplicationUser user)
        {
            var key = await SmartPromiseConverter.GetPromiseCountKeyHex(user.Address, _blockchain);

            var count = await _blockchain.GetStorage(NETWORK_TYPE.TESTNET, key);

            return(count == null? 0 : SmartPromiseConverter.Hex2Num(count));
        }
        public async Task <bool> Add(Promise promise, ApplicationUser user)
        {
            //it's guaranteed it's unique by contract code
            var counter = await GetPromiseCount(user);

            promise.Id = (counter == 0) ? 1 : counter + 1;

            var json    = JsonConvert.SerializeObject(promise);
            var jsonHex = SmartPromiseConverter.Str2Hex(json);
            var revSh   = await SmartPromiseConverter.GetScriptHashReversed(user.Address, _blockchain);

            var res = await _blockchain.InvokeContractAdd(NETWORK_TYPE.TESTNET, user.Wif, revSh, jsonHex, GAS_COST);

            return(res);
        }
        public async Task <IEnumerable <Promise> > GetPromises(ApplicationUser user)
        {
            var count = await GetPromiseCount(user);

            if (count == 0)
            {
                return(null);
            }

            var keys = await Task.WhenAll(Enumerable.Range(1, count)
                                          .Select(i => SmartPromiseConverter.GetPromiseKeyHex(user.Address, i, _blockchain)));

            var promises = await LoadPromises(keys);

            return(promises);
        }
        public async Task <Promise> Get(int id, ApplicationUser user)
        {
            try
            {
                var promiseKeyHex = await SmartPromiseConverter.GetPromiseKeyHex(user.Address, id, _blockchain);

                var promiseJsonHex = await _blockchain.GetStorage(NETWORK_TYPE.TESTNET, promiseKeyHex);

                var promiseJson = SmartPromiseConverter.Hex2Str(promiseJsonHex);
                return(JsonConvert.DeserializeObject <Promise>(promiseJson));
            }
            catch (Exception ex)
            {
                return(null);
            }
        }
        public async Task <bool> SendAsset(NETWORK_TYPE type, ASSET_NAME assetName, string addr, int amount)
        {
            var user = await _userManager.GetUserAsync(User);

            if (assetName == ASSET_NAME.SC)
            {
                var toSh = await SmartPromiseConverter.GetScriptHashReversed(addr, _blockchain);

                var fromSh = await SmartPromiseConverter.GetScriptHashReversed(user.Address, _blockchain);

                var res = await _blockchain.InvokeContractTransfer(type, user.Wif, fromSh, toSh, amount, 1);

                return(res);
            }
            else
            {
                return(await _blockchain.SendAsset(type, user.Wif, assetName, addr, amount));
            }
        }
        public async Task <bool> Complete(int id, string proof, ApplicationUser user)
        {
            var promise = await Get(id, user);

            if (promise == null)
            {
                return(false);
            }

            promise.Status = PROMISE_STATUS.COMPLETED;
            promise.Proof  = proof;
            var json    = JsonConvert.SerializeObject(promise);
            var jsonHex = SmartPromiseConverter.Str2Hex(json);
            var revSh   = await SmartPromiseConverter.GetScriptHashReversed(user.Address, _blockchain);

            var res = await _blockchain.InvokeContractReplace(NETWORK_TYPE.TESTNET, user.Wif, revSh, jsonHex, id, GAS_COST);

            return(res);
        }
        private async Task <IEnumerable <Promise> > LoadPromises(string[] keys)
        {
            var jsonPromisesHex = await Task.WhenAll(
                keys.Select(key => _blockchain.GetStorage(NETWORK_TYPE.TESTNET, key))
                );

            var promises = jsonPromisesHex.ToAsyncEnumerable().Select(p => {
                try
                {
                    return(JsonConvert.DeserializeObject <Promise>(SmartPromiseConverter.Hex2Str(p)));
                }
                catch (Exception)
                {
                    return(new Promise {
                        Title = "Error while loading. Please, try later.",
                        Content = "",
                        Complicity = 0,
                        Status = PROMISE_STATUS.ERROR
                    });
                }
            }).ToEnumerable();

            return(promises);
        }