public MultiTokenContractTestBase()
        {
            TokenContractStub =
                GetTester <TokenContractImplContainer.TokenContractImplStub>(TokenContractAddress, DefaultKeyPair);
            Acs2BaseStub = GetTester <ACS2BaseContainer.ACS2BaseStub>(TokenContractAddress, DefaultKeyPair);

            TreasuryContractStub = GetTester <TreasuryContractImplContainer.TreasuryContractImplStub>(
                TreasuryContractAddress,
                DefaultKeyPair);

            TokenConverterContractStub = GetTester <TokenConverterContractImplContainer.TokenConverterContractImplStub>(
                TokenConverterContractAddress,
                DefaultKeyPair);

            BasicFunctionContractAddress = SystemContractAddresses[BasicFunctionContractName];
            BasicFunctionContractStub    = GetTester <BasicFunctionContractContainer.BasicFunctionContractStub>(
                BasicFunctionContractAddress, DefaultKeyPair);

            OtherBasicFunctionContractAddress = SystemContractAddresses[OtherBasicFunctionContractName];
            OtherBasicFunctionContractStub    = GetTester <BasicFunctionContractContainer.BasicFunctionContractStub>(
                OtherBasicFunctionContractAddress, DefaultKeyPair);

            ParliamentContractStub = GetTester <ParliamentContractImplContainer.ParliamentContractImplStub>(
                ParliamentContractAddress, DefaultKeyPair);
        }
        public async Task <IEnumerable <Transaction> > GetPreTransactionsAsync(
            IReadOnlyList <ServiceDescriptor> descriptors, ITransactionContext transactionContext)
        {
            if (!IsTargetAcsSymbol(descriptors))
            {
                return(new List <Transaction>());
            }

            var context = _contextService.Create();

            context.TransactionContext = transactionContext;

            // Generate token contract stub.
            var tokenContractAddress = context.GetContractAddressByName(TokenSmartContractAddressNameProvider.Name);

            if (tokenContractAddress == null)
            {
                return(new List <Transaction>());
            }

            var tokenStub = new TokenContractImplContainer.TokenContractImplStub
            {
                __factory = new TransactionGeneratingOnlyMethodStubFactory
                {
                    Sender          = transactionContext.Transaction.To,
                    ContractAddress = tokenContractAddress
                }
            };

            if (transactionContext.Transaction.To == tokenContractAddress &&
                transactionContext.Transaction.MethodName == nameof(tokenStub.ChargeResourceToken))
            {
                return(new List <Transaction>());
            }

            if (transactionContext.Transaction.To == context.Self &&
                transactionContext.Transaction.MethodName == nameof(ResourceConsumptionContractContainer
                                                                    .ResourceConsumptionContractStub.BuyResourceToken))
            {
                return(new List <Transaction>());
            }

            var checkResourceTokenTransaction =
                (await tokenStub.CheckResourceToken.SendAsync(new Empty())).Transaction;

            return(new List <Transaction>
            {
                checkResourceTokenTransaction
            });
        }