public async Task <IActionResult> GetTickets(string address)
        {
            // validate address
            if (!AddressParser.IsValidAddress(address, _network))
            {
                return(StatusCode(StatusCodes.Status400BadRequest, $"Invalid address {address}"));
            }

            // check contract exists
            var numericAddress = address.ToUint160(_network);

            if (!_stateRepositoryRoot.IsExist(numericAddress))
            {
                return(StatusCode(StatusCodes.Status404NotFound, $"No smart contract found at address {address}"));
            }

            // retrieve value
            var tickets = RetrieveTickets(numericAddress);

            return(Ok(tickets));
        }
        public async Task <IActionResult> SetTicketReleaseFee(string address, SetTicketReleaseFeeRequest setTicketReleaseFeeRequest)
        {
            // validate address
            if (!AddressParser.IsValidAddress(address, _network))
            {
                return(StatusCode(StatusCodes.Status400BadRequest, $"Invalid address {address}"));
            }

            // check contract exists
            var numericAddress = address.ToUint160(_network);

            if (!_stateRepositoryRoot.IsExist(numericAddress))
            {
                return(StatusCode(StatusCodes.Status404NotFound, $"No smart contract found at address {address}"));
            }

            if (HasActiveSale(numericAddress))
            {
                return(StatusCode(StatusCodes.Status409Conflict, "Sale is currently active"));
            }

            // check connections
            if (!_connectionManager.ConnectedPeers.Any())
            {
                _logger.LogTrace("No connected peers");
                return(StatusCode(StatusCodes.Status403Forbidden, "Can't send transaction as the node requires at least one connection."));
            }

            var feeParameter = $"{Serialization.TypeIdentifiers[typeof(ulong)]}#{setTicketReleaseFeeRequest.Fee}";

            // build transaction
            var callTxResponse = _smartContractTransactionService.BuildCallTx(new BuildCallContractTransactionRequest
            {
                AccountName     = setTicketReleaseFeeRequest.AccountName,
                Amount          = "0",
                ContractAddress = address,
                FeeAmount       = "0",
                GasLimit        = SmartContractFormatLogic.GasLimitMaximum,
                GasPrice        = setTicketReleaseFeeRequest.GasPrice,
                MethodName      = nameof(TicketContract.SetTicketReleaseFee),
                Outpoints       = setTicketReleaseFeeRequest.Outpoints,
                Parameters      = new string[] { feeParameter },
                Password        = setTicketReleaseFeeRequest.Password,
                Sender          = setTicketReleaseFeeRequest.Sender,
                WalletName      = setTicketReleaseFeeRequest.WalletName,
            });

            if (!callTxResponse.Success)
            {
                return(StatusCode(StatusCodes.Status400BadRequest, callTxResponse.Message));
            }

            // broadcast transaction
            var transaction = _network.CreateTransaction(callTxResponse.Hex);
            await _broadcasterManager.BroadcastTransactionAsync(transaction);

            var transactionBroadCastEntry = _broadcasterManager.GetTransaction(transaction.GetHash()); // check if transaction was added to mempool

            if (transactionBroadCastEntry?.State == Stratis.Bitcoin.Features.Wallet.Broadcasting.State.CantBroadcast)
            {
                _logger.LogError("Exception occurred: {0}", transactionBroadCastEntry.ErrorMessage);
                return(StatusCode(StatusCodes.Status500InternalServerError, transactionBroadCastEntry.ErrorMessage));
            }

            var transactionHash = transaction.GetHash().ToString();

            return(Created($"/api/smartContracts/receipt?txHash={transactionHash}", transactionHash));
        }