public void GetHelp()
        {
            JsonRpcResponse <string> response = null;

            response = _Client.Utility.Help();
            ResponseLogger <string> .Log(response);
        }
        public void GetBlockChainParamsTrue()
        {
            JsonRpcResponse <Dictionary <string, object> > response = null;

            response = _Client.Utility.GetBlockChainParams(true);
            ResponseLogger <Dictionary <string, object> > .Log(response);
        }
Beispiel #3
0
        public void Resume()
        {
            JsonRpcResponse <string> response = null;

            response = _Client.Peer.Resume(NodeTask.Mining);
            ResponseLogger <string> .Log(response);
        }
        public void SetRuntimeParams()
        {
            JsonRpcResponse <Dictionary <string, object> > response = null;

            response = _Client.Utility.SetRuntimeParams("miningrequirespeers", "true");
            ResponseLogger <Dictionary <string, object> > .Log(response);
        }
        public void GetInfo()
        {
            JsonRpcResponse <GetInfoResponse> response = new JsonRpcResponse <GetInfoResponse>();

            response = _Client.Utility.GetInfo();
            ResponseLogger <GetInfoResponse> .Log(response);
        }
        public void GetRuntimeParams()
        {
            JsonRpcResponse <Dictionary <string, object> > response = null;

            response = _Client.Utility.GetRuntimeParams();
            ResponseLogger <Dictionary <string, object> > .Log(response);
        }
Beispiel #7
0
        public void ListStreamPublisherItems()
        {
            JsonRpcResponse <List <string> > response = null;

            response = _Client.Stream.ListStreamPublisherItems("Lucid Ocean", TestSettings.Connection.RootNodeAddress, true, 10, 1, true);

            ResponseLogger <List <string> > .Log(response);
        }
Beispiel #8
0
        public void GetStreamItem()
        {
            JsonRpcResponse <ListStreamItemsResponse> response = null;

            response = _Client.Stream.GetStreamItem("Lucid Ocean", "[sometxid]", true);

            ResponseLogger <ListStreamItemsResponse> .Log(response);
        }
Beispiel #9
0
        public void CreateFrom()
        {
            JsonRpcResponse <string> response = null;

            response = _Client.Stream.CreateFrom(TestSettings.Connection.RootNodeAddress, "TestStream", false, new { data = "custom data" });

            ResponseLogger <string> .Log(response);
        }
Beispiel #10
0
        public void ListStreamPublishers()
        {
            JsonRpcResponse <List <string> > response = null;
            List <string> addresses = new List <string>();

            addresses.Add(TestSettings.Connection.RootNodeAddress);
            response = _Client.Stream.ListStreamPublishers("Lucid Ocean", addresses, true, 10, 1, true);

            ResponseLogger <List <string> > .Log(response);
        }
Beispiel #11
0
        public void GrantFrom()
        {
            JsonRpcResponse <string> response = null;

            response = _Client.Permission.GrantFrom(TestSettings.Connection.RootNodeAddress, new List <string>()
            {
                TestSettings.FromAddress
            }, BlockChainPermission.Connect);
            ResponseLogger <string> .Log(response);
        }
Beispiel #12
0
        public void Grant()
        {
            JsonRpcResponse <string> response = null;

            response = _Client.Permission.Grant(new List <string>()
            {
                TestSettings.ToAddress
            }, BlockChainPermission.Connect);
            ResponseLogger <string> .Log(response);
        }
        public void GetAddressesVerboseAsync()
        {
            JsonRpcResponse <List <AddressResponse> > response = null;

            Task.Run(async() =>
            {
                response = await _Client.Wallet.GetAddressesVerboseAsync();
            }).GetAwaiter().GetResult();

            ResponseLogger <List <AddressResponse> > .Log(response);
        }
        public void ListAddressTransactionsAsync()
        {
            JsonRpcResponse <List <AddressTransactionResponse> > response = null;

            Task.Run(async() =>
            {
                response = await _Client.Wallet.ListAddressTransactionsAsync(TestSettings.FromAddress, 10, 0, true);
            }).GetAwaiter().GetResult();

            ResponseLogger <List <AddressTransactionResponse> > .Log(response);
        }
        public void GetTotalBalancesAsync()
        {
            JsonRpcResponse <List <AssetBalanceResponse> > response = null;

            Task.Run(async() =>
            {
                response = await _Client.Wallet.GetTotalBalancesAsync();
            }).GetAwaiter().GetResult();

            ResponseLogger <List <AssetBalanceResponse> > .Log(response);
        }
        public void GetAddressBalancesAsync()
        {
            JsonRpcResponse <List <AssetBalanceResponse> > response = null;

            Task.Run(async() =>
            {
                response = await _Client.Wallet.GetAddressBalancesAsync(TestSettings.Connection.RootNodeAddress);
            }).GetAwaiter().GetResult();

            ResponseLogger <List <AssetBalanceResponse> > .Log(response);
        }
        public void GetWalletInfoAsync()
        {
            JsonRpcResponse <WalletInfoResponse> response = null;

            Task.Run(async() =>
            {
                response = await _Client.Wallet.GetWalletInfoAsync();
            }).GetAwaiter().GetResult();

            ResponseLogger <WalletInfoResponse> .Log(response);
        }
Beispiel #18
0
        public void ListStreamItems()
        {
            JsonRpcResponse <List <ListStreamItemsResponse> > response = null;

            Task.Run(async() =>
            {
                response = await _Client.Stream.ListStreamItemsAsync("Lucid Ocean", false);
            }).GetAwaiter().GetResult();

            ResponseLogger <List <ListStreamItemsResponse> > .Log(response);
        }
Beispiel #19
0
        public void AddNodeAsync()
        {
            JsonRpcResponse <string> response = null;

            Task.Run(async() =>
            {
                response = await _Client.Peer.AddNodeAsync("IPAddress", AddNodeParam.Add);
            }).GetAwaiter().GetResult();

            ResponseLogger <string> .Log(response);
        }
        public void GetRuntimeParamsAsync()
        {
            JsonRpcResponse <Dictionary <string, object> > response = null;

            Task.Run(async() =>
            {
                response = await _Client.Utility.GetRuntimeParamsAsync();
            }).GetAwaiter().GetResult();

            ResponseLogger <Dictionary <string, object> > .Log(response);
        }
Beispiel #21
0
        public void GetTxOutSetInfoAsync()
        {
            JsonRpcResponse <TxOutSetInfoResponse> response = null;

            Task.Run(async() =>
            {
                response = await _Client.Block.GetTxOutSetInfoAsync();
            }).GetAwaiter().GetResult();

            ResponseLogger <TxOutSetInfoResponse> .Log(response);
        }
Beispiel #22
0
        public void CreateFromAsync()
        {
            JsonRpcResponse <string> response = null;

            Task.Run(async() =>
            {
                response = await _Client.Stream.CreateFromAsync(TestSettings.Connection.RootNodeAddress, "TestStream", false, new { data = "custom data" });
            }).GetAwaiter().GetResult();

            ResponseLogger <string> .Log(response);
        }
Beispiel #23
0
        public void ListStreamPublisherItemsAsync()
        {
            JsonRpcResponse <List <string> > response = null;

            Task.Run(async() =>
            {
                response = await _Client.Stream.ListStreamPublisherItemsAsync("Lucid Ocean", TestSettings.Connection.RootNodeAddress, true, 10, 1, true);
            }).GetAwaiter().GetResult();

            ResponseLogger <List <string> > .Log(response);
        }
        public void Help_listblocks()
        {
            JsonRpcResponse <string> response = null;

            Task.Run(async() =>
            {
                response = await _Client.Utility.HelpAsync("listblocks");
            }).GetAwaiter().GetResult();

            ResponseLogger <string> .Log(response);
        }
        public void ListLockUnspentAsync()
        {
            JsonRpcResponse <List <string> > response = null;

            Task.Run(async() =>
            {
                response = await _Client.Wallet.ListLockUnspentAsync();
            }).GetAwaiter().GetResult();

            ResponseLogger <List <string> > .Log(response);
        }
Beispiel #26
0
        public void GetAddedNodeInfoDetailsAsync()
        {
            JsonRpcResponse <List <string> > response = null;

            Task.Run(async() =>
            {
                response = await _Client.Peer.GetAddedNodeInfoDetailsAsync();
            }).GetAwaiter().GetResult();

            ResponseLogger <List <string> > .Log(response);
        }
Beispiel #27
0
        public void ListPermissions()
        {
            JsonRpcResponse <List <ListPermissionsResponse> > response = null;

            Task.Run(async() =>
            {
                response = await _Client.Permission.ListPermissionsAsync(TestSettings.FromAddress);
            }).GetAwaiter().GetResult();

            ResponseLogger <List <ListPermissionsResponse> > .Log(response);
        }
Beispiel #28
0
        public void CreateKeyPairsAsync()
        {
            JsonRpcResponse <List <MultiSignatureResponse> > response = null;

            Task.Run(async() =>
            {
                response = await _Client.Address.CreateKeyPairsAsync(1);
            }).GetAwaiter().GetResult();

            ResponseLogger <List <MultiSignatureResponse> > .Log(response);
        }
Beispiel #29
0
        public void GetBlockCountAsync()
        {
            JsonRpcResponse <int> response = null;

            Task.Run(async() =>
            {
                response = await _Client.Block.GetBlockCountAsync();
            }).GetAwaiter().GetResult();

            ResponseLogger <int> .Log(response);
        }
        public void GetInfoAsync()
        {
            JsonRpcResponse <GetInfoResponse> response = new JsonRpcResponse <GetInfoResponse>();

            Task.Run(async() =>
            {
                response = await _Client.Utility.GetInfoAsync();
            }).GetAwaiter().GetResult();

            ResponseLogger <GetInfoResponse> .Log(response);
        }