protected async Task DeployContractsAsync()
{
{
// TokenContract
var category = KernelConstants.CodeCoverageRunnerCategory;
var code = Codes.Single(kv => kv.Key.Split(",").First().EndsWith("MultiToken")).Value;
TokenContractAddress = await DeploySystemSmartContract(category, code, TokenSmartContractAddressNameProvider.Name, DefaultSenderKeyPair);
TokenContractStub =
GetTester <TokenContractContainer.TokenContractStub>(TokenContractAddress, DefaultSenderKeyPair);
AuthorizedTokenContractStub = GetTester <TokenContractContainer.TokenContractStub>(TokenContractAddress, ManagerKeyPair);
}
{
// TokenConverterContract
var category = KernelConstants.CodeCoverageRunnerCategory;
var code = Codes.Single(kv => kv.Key.Split(",").First().EndsWith("TokenConverter")).Value;
TokenConverterContractAddress = await DeploySystemSmartContract(category, code, TokenConverterSmartContractAddressNameProvider.Name, DefaultSenderKeyPair);
DefaultStub = GetTester <TokenConverterContractContainer.TokenConverterContractStub>(
TokenConverterContractAddress, DefaultSenderKeyPair);
AuthorizedTokenConvertStub = GetTester <TokenConverterContractContainer.TokenConverterContractStub>(
TokenConverterContractAddress, ManagerKeyPair);
}
await TokenContractStub.Create.SendAsync(new CreateInput()
{
Symbol = "ELF",
Decimals = 2,
IsBurnable = true,
TokenName = "elf token",
TotalSupply = 1000_0000_0000L,
Issuer = DefaultSender,
LockWhiteList = { TokenConverterContractAddress }
});
public async Task <IEnumerable <Transaction> > GetPreTransactionsAsync(IReadOnlyList <ServiceDescriptor> descriptors, ITransactionContext transactionContext)
{
if (!IsAcs1(descriptors))
{
return(new List <Transaction>());
}
var context = _contextService.Create();
context.TransactionContext = transactionContext;
var selfStub = new FeeChargedContractContainer.FeeChargedContractStub()
{
__factory = new MethodStubFactory(context)
};
var fee = await selfStub.GetMethodFee.CallAsync(new MethodName
{
Name = context.TransactionContext.Transaction.MethodName
});
if (!fee.Amounts.Any())
{
return(new List <Transaction>());
}
var tokenContractAddress = context.GetContractAddressByName(TokenSmartContractAddressNameProvider.Name);
if (tokenContractAddress == null)
{
return(new List <Transaction>());
}
var tokenStub = new TokenContractContainer.TokenContractStub()
{
__factory = new TransactionGeneratingOnlyMethodStubFactory()
{
Sender = transactionContext.Transaction.From,
ContractAddress = tokenContractAddress
}
};
if (transactionContext.Transaction.To == tokenContractAddress &&
transactionContext.Transaction.MethodName == nameof(tokenStub.ChargeTransactionFees))
{
// Skip ChargeTransactionFees itself
return(new List <Transaction>());
}
var chargeFeeTransaction = (await tokenStub.ChargeTransactionFees.SendAsync(new ChargeTransactionFeesInput
{
SymbolToAmount = { fee.Amounts.ToDictionary(a => a.Symbol, a => a.Amount) }
})).Transaction;
return(new List <Transaction>
{
chargeFeeTransaction
});
}
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;
var selfStub = new ThresholdSettingContractContainer.ThresholdSettingContractStub
{
__factory = new MethodStubFactory(context)
};
var threshold = await selfStub.GetMethodCallingThreshold.CallAsync(new StringValue
{
Value = context.TransactionContext.Transaction.MethodName
});
// Generate token contract stub.
var tokenContractAddress = context.GetContractAddressByName(TokenSmartContractAddressNameProvider.Name);
if (tokenContractAddress == null)
{
return(new List <Transaction>());
}
var tokenStub = new TokenContractContainer.TokenContractStub
{
__factory = new TransactionGeneratingOnlyMethodStubFactory
{
Sender = transactionContext.Transaction.To,
ContractAddress = tokenContractAddress
}
};
if (transactionContext.Transaction.To == tokenContractAddress &&
transactionContext.Transaction.MethodName == nameof(tokenStub.CheckThreshold))
{
return(new List <Transaction>());
}
var checkThresholdTransaction = (await tokenStub.CheckThreshold.SendAsync(new CheckThresholdInput
{
Sender = context.Sender,
SymbolToThreshold = { threshold.SymbolToAmount },
IsCheckAllowance = threshold.ThresholdCheckType == ThresholdCheckType.Allowance
})).Transaction;
return(new List <Transaction>
{
checkThresholdTransaction
});
}
public async Task <IEnumerable <Transaction> > GetPreTransactionsAsync(
IReadOnlyList <ServiceDescriptor> descriptors, ITransactionContext transactionContext)
{
if (!IsAcs8(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 TokenContractContainer.TokenContractStub
{
__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
});
}
protected async Task DeployContractsAsync()
{
{
// TokenContract
var category = KernelConstants.CodeCoverageRunnerCategory;
var code = File.ReadAllBytes(typeof(TokenContract).Assembly.Location);
TokenContractAddress = await DeployContractAsync(category, code, DefaultSenderKeyPair);
TokenContractStub =
GetTester <TokenContractContainer.TokenContractStub>(TokenContractAddress, DefaultSenderKeyPair);
await TokenContractStub.Create.SendAsync(new CreateInput()
{
Symbol = "ELF",
Decimals = 2,
IsBurnable = true,
TokenName = "elf token",
TotalSupply = 1000_0000L,
Issuer = DefaultSender
});
protected async Task DeployContractsAsync()
{
{
// TokenContract
var category = KernelConstants.CodeCoverageRunnerCategory;
var code = Codes.Single(kv => kv.Key.Split(",").First().EndsWith("MultiToken")).Value;
TokenContractAddress = await DeployContractAsync(category, code, Hash.FromString("MultiToken"), DefaultSenderKeyPair);
TokenContractStub =
GetTester <TokenContractContainer.TokenContractStub>(TokenContractAddress, DefaultSenderKeyPair);
await TokenContractStub.Create.SendAsync(new CreateInput()
{
Symbol = "ELF",
Decimals = 2,
IsBurnable = true,
TokenName = "elf token",
TotalSupply = 1000_0000L,
Issuer = DefaultSender
});
public async Task <IEnumerable <Transaction> > GetPostTransactionsAsync(
IReadOnlyList <ServiceDescriptor> descriptors, ITransactionContext transactionContext)
{
if (!IsAcs8(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 TokenContractContainer.TokenContractStub
{
__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>());
}
// Transaction size related to NET Token.
var transactionSize = transactionContext.Transaction.Size();
// Transaction trace state set writes count related to STO Token.
var writesCount = transactionContext.Trace.StateSet.Writes.Count;
// Transaction trace state set reads count related to CPU Token.
var readsCount = transactionContext.Trace.StateSet.Reads.Count;
var chargeResourceTokenTransaction = (await tokenStub.ChargeResourceToken.SendAsync(
new ChargeResourceTokenInput
{
TransactionSize = transactionSize,
WritesCount = writesCount,
ReadsCount = readsCount,
Caller = transactionContext.Transaction.From
})).Transaction;
return(new List <Transaction>
{
chargeResourceTokenTransaction
});
}
public async Task <IEnumerable <Transaction> > GetPreTransactionsAsync(
IReadOnlyList <ServiceDescriptor> descriptors, ITransactionContext transactionContext)
{
try
{
var context = _contextService.Create();
if (_transactionFeeExemptionService.IsFree(transactionContext.Transaction))
{
return(new List <Transaction>());
}
context.TransactionContext = transactionContext;
var tokenContractAddress = context.GetContractAddressByName(TokenSmartContractAddressNameProvider.Name);
if (context.CurrentHeight < Constants.GenesisBlockHeight + 1 || tokenContractAddress == null)
{
return(new List <Transaction>());
}
if (!IsAcs1(descriptors) && transactionContext.Transaction.To != tokenContractAddress)
{
return(new List <Transaction>());
}
var tokenStub = new TokenContractContainer.TokenContractStub
{
__factory = new TransactionGeneratingOnlyMethodStubFactory
{
Sender = transactionContext.Transaction.From,
ContractAddress = tokenContractAddress
}
};
if (transactionContext.Transaction.To == tokenContractAddress &&
transactionContext.Transaction.MethodName == nameof(tokenStub.ChargeTransactionFees))
{
// Skip ChargeTransactionFees itself
return(new List <Transaction>());
}
var txSize = transactionContext.Transaction.Size();
var txCost = _calService.CalculateFee(FeeType.Tx, txSize);
var chargeFeeTransaction = (await tokenStub.ChargeTransactionFees.SendAsync(
new ChargeTransactionFeesInput
{
MethodName = transactionContext.Transaction.MethodName,
ContractAddress = transactionContext.Transaction.To,
TransactionSizeFee = txCost,
PrimaryTokenSymbol = await _primaryTokenSymbolProvider.GetPrimaryTokenSymbol()
})).Transaction;
return(new List <Transaction>
{
chargeFeeTransaction
});
}
catch (Exception e)
{
Logger.LogError(e, "Failed to generate ChargeTransactionFees tx.");
throw;
}
}
public async Task <IEnumerable <Transaction> > GetPreTransactionsAsync(
IReadOnlyList <ServiceDescriptor> descriptors, ITransactionContext transactionContext)
{
try
{
var context = _contextService.Create();
var systemContractAddresses = new List <Address>
{
context.GetZeroSmartContractAddress(context.ChainId),
context.GetContractAddressByName(TokenSmartContractAddressNameProvider.Name),
// TODO: Try to use contract address name providers - put providers to one place easy to ref.
context.GetContractAddressByName(Hash.FromString("AElf.ContractNames.Consensus")),
context.GetContractAddressByName(Hash.FromString("AElf.ContractNames.CrossChain")),
context.GetContractAddressByName(Hash.FromString("AElf.ContractNames.Economic")),
};
if (systemContractAddresses.Contains(transactionContext.Transaction.To))
{
if (_systemTransactionMethodNameListProvider.GetSystemTransactionMethodNameList()
.Contains(transactionContext.Transaction.MethodName))
{
return(new List <Transaction>());
}
var methodNameWhiteList = new List <string>
{
nameof(TokenContractContainer.TokenContractStub.Create),
nameof(TokenContractContainer.TokenContractStub.Issue),
nameof(TokenContractContainer.TokenContractStub.CrossChainTransfer),
nameof(TokenContractContainer.TokenContractStub.CrossChainReceiveToken),
"IssueNativeToken"
};
if (methodNameWhiteList.Contains(transactionContext.Transaction.MethodName))
{
return(new List <Transaction>());
}
}
context.TransactionContext = transactionContext;
var tokenContractAddress = context.GetContractAddressByName(TokenSmartContractAddressNameProvider.Name);
if (context.CurrentHeight < Constants.GenesisBlockHeight + 1 || tokenContractAddress == null)
{
return(new List <Transaction>());
}
if (!IsAcs1(descriptors) && transactionContext.Transaction.To != tokenContractAddress)
{
return(new List <Transaction>());
}
var tokenStub = new TokenContractContainer.TokenContractStub
{
__factory = new TransactionGeneratingOnlyMethodStubFactory
{
Sender = transactionContext.Transaction.From,
ContractAddress = tokenContractAddress
}
};
if (transactionContext.Transaction.To == tokenContractAddress &&
transactionContext.Transaction.MethodName == nameof(tokenStub.ChargeTransactionFees))
{
// Skip ChargeTransactionFees itself
return(new List <Transaction>());
}
var unitPrice = await _transactionSizeFeeUnitPriceProvider.GetUnitPriceAsync();
var chargeFeeTransaction = (await tokenStub.ChargeTransactionFees.SendAsync(
new ChargeTransactionFeesInput
{
MethodName = transactionContext.Transaction.MethodName,
ContractAddress = transactionContext.Transaction.To,
TransactionSizeFee = unitPrice * transactionContext.Transaction.Size(),
PrimaryTokenSymbol = await _primaryTokenSymbolProvider.GetPrimaryTokenSymbol()
})).Transaction;
return(new List <Transaction>
{
chargeFeeTransaction
});
}
catch (Exception e)
{
Logger.LogError("Failed to generate ChargeTransactionFees tx.", e);
throw;
}
}
