public async Task RunStreamFilterTestAsync()
        {
            /*
             * Explicit blockchain name test
             */

            // Stage - Create filter
            var expStreamFilter = await _wallet.CreateAsync(_chainName, UUID.NoHyphens, Entity.StreamFilter, StreamFilterEntity.GetUUID(), new { }, JsCode.DummyStreamFilterCode);

            // Act - Execute stream filter
            var expRun = await _blockchain.RunStreamFilterAsync(_chainName, UUID.NoHyphens, expStreamFilter.Result, null, 0);

            // Assert
            Assert.IsTrue(expRun.IsSuccess());
            Assert.IsInstanceOf <RpcResponse <RunStreamFilterResult> >(expRun);

            /*
             * Inferred blockchain name test
             */

            // Stage - Create filter
            var infStreamFilter = await _wallet.CreateAsync(Entity.StreamFilter, StreamFilterEntity.GetUUID(), new { }, JsCode.DummyStreamFilterCode);

            // Act - Execute stream filter
            var infRun = await _blockchain.RunStreamFilterAsync(infStreamFilter.Result, null, 0);

            // Assert
            Assert.IsTrue(infRun.IsSuccess());
            Assert.IsInstanceOf <RpcResponse <RunStreamFilterResult> >(infRun);
        }
        public async Task ApproveFromTestAsync()
        {
            /*
             * Explicit blockchain name test
             */

            // Stage
            var expFilter = await _wallet.CreateAsync(_chainName, UUID.NoHyphens, Entity.TxFilter, StreamFilterEntity.GetUUID(), new { }, JsCode.DummyTxFilterCode);

            // Act
            var expApprove = await _wallet.ApproveFromAsync(_chainName, UUID.NoHyphens, _address, expFilter.Result, true);

            // Assert
            Assert.IsTrue(expApprove.IsSuccess());;
            Assert.IsInstanceOf <RpcResponse <string> >(expApprove);

            /*
             * Inferred blockchain name test
             */

            // Stage
            var infFilter = await _wallet.CreateAsync(Entity.TxFilter, StreamFilterEntity.GetUUID(), new { }, JsCode.DummyTxFilterCode);

            // Act
            var infApprove = await _wallet.ApproveFromAsync(_address, infFilter.Result, true);

            // Assert
            Assert.IsTrue(infApprove.IsSuccess());
            Assert.IsInstanceOf <RpcResponse <string> >(infApprove);
        }
        public async Task GetFilterCodeTestAsync()
        {
            /*
             * Explicit blockchain name test
             */

            // Stage - Create filter
            var expFilter = await _wallet.CreateAsync(_chainName, UUID.NoHyphens, Entity.TxFilter, StreamFilterEntity.GetUUID(), new { }, JsCode.DummyTxFilterCode);


            // Act - Retrieve filtercode by name, txid, or reference
            var expGet = await _blockchain.GetFilterCodeAsync(_chainName, UUID.NoHyphens, expFilter.Result);

            // Assert
            Assert.IsTrue(expGet.IsSuccess());
            Assert.IsInstanceOf <RpcResponse <string> >(expGet);

            /*
             * Inferred blockchain name test
             */

            // Stage - Create filter
            var infFilter = await _wallet.CreateAsync(Entity.TxFilter, StreamFilterEntity.GetUUID(), new { }, JsCode.DummyTxFilterCode);


            // Act - Retrieve filtercode by name, txid, or reference
            var infGet = await _blockchain.GetFilterCodeAsync(infFilter.Result);

            // Assert
            Assert.IsTrue(infGet.IsSuccess());
            Assert.IsInstanceOf <RpcResponse <string> >(infGet);
        }
Exemplo n.º 4
0
 /// <summary>
 /// Create stream filter from an address; Blockchain name is explicit
 /// </summary>
 /// <param name="client"></param>
 /// <param name="blockchainName"></param>
 /// <param name="fromAddress"></param>
 /// <param name="streamFilterEntity"></param>
 /// <returns></returns>
 public static Task <CliResponse <string> > CreateStreamFilterFrom(this IMultiChainCliWallet client, string blockchainName, string fromAddress, StreamFilterEntity streamFilterEntity) =>
 client.CreateFromAsync(blockchainName, fromAddress, streamFilterEntity.EntityType, streamFilterEntity.Name, streamFilterEntity.Restrictions, streamFilterEntity.JavaScriptCode);
Exemplo n.º 5
0
        // *** Create Stream Filter extension methods

        /// <summary>
        /// Create stream filter; Blockchain name is inferred
        /// </summary>
        /// <param name="client"></param>
        /// <param name="streamFilterEntity"></param>
        /// <returns></returns>
        public static Task <CliResponse <string> > CreateStreamFilter(this IMultiChainCliWallet client, StreamFilterEntity streamFilterEntity) =>
        client.CreateAsync(streamFilterEntity.EntityType, streamFilterEntity.Name, streamFilterEntity.Restrictions, streamFilterEntity.JavaScriptCode);