public static async Task <T> GetBlockExecutedDataAsync <T>(
this IBlockchainExecutedDataService blockchainExecutedDataService,
IBlockIndex chainContext, string key)
{
var byteString = await blockchainExecutedDataService.GetBlockExecutedDataAsync(chainContext, key);
return(SerializationHelper.Deserialize <T>(byteString?.ToByteArray()));
}
public async Task SetSmartContractAddressAsync(IBlockIndex blockIndex, string contractName, Address address)
{
await AddBlockExecutedDataAsync(blockIndex, contractName, new SmartContractAddress
{
Address = address,
BlockHash = blockIndex.BlockHash,
BlockHeight = blockIndex.BlockHeight
});
}
public async Task SetLimitAsync(IBlockIndex blockIndex, int limit)
{
var blockTransactionLimit = new BlockTransactionLimit
{
Value = limit
};
await AddBlockExecutedDataAsync(blockIndex, blockTransactionLimit);
}
public static async Task AddBlockExecutedDataAsync <T>(
this ICachedBlockchainExecutedDataService <T> cachedBlockchainExecutedDataGettingService,
IBlockIndex blockIndex, string key, T blockExecutedData)
{
var dic = new Dictionary <string, T>
{
{ key, blockExecutedData }
};
await cachedBlockchainExecutedDataGettingService.AddBlockExecutedDataAsync(blockIndex, dic);
}
public async Task SetStateSizeLimitAsync(IBlockIndex blockIndex, int stateSizeLimit)
{
if (stateSizeLimit <= 0)
{
return;
}
await AddBlockExecutedDataAsync(blockIndex, new Int32Value { Value = stateSizeLimit });
Logger.LogDebug($"State limit size changed to {stateSizeLimit}");
}
public IExecutionObserverThreshold GetExecutionObserverThreshold(IBlockIndex blockIndex)
{
var branchCountObserverThreshold = GetBlockExecutedData(blockIndex, BranchCountThresholdKey)?.Value ??
SmartContractConstants.ExecutionBranchThreshold;
var callCountObserverThreshold = GetBlockExecutedData(blockIndex, CallCountThresholdKey)?.Value ??
SmartContractConstants.ExecutionBranchThreshold;
return(new ExecutionObserverThreshold
{
ExecutionBranchThreshold = branchCountObserverThreshold,
ExecutionCallThreshold = callCountObserverThreshold
});
}
public async Task AddBlockExecutedDataAsync(IBlockIndex blockIndex, IDictionary <string, T> blockExecutedData)
{
await _blockchainExecutedDataManager.AddBlockExecutedCacheAsync(blockIndex.BlockHash, blockExecutedData.ToDictionary
(pair => pair.Key, pair => Serialize(pair.Value)));
foreach (var pair in blockExecutedData)
{
if (blockIndex.BlockHeight > AElfConstants.GenesisBlockHeight &&
(!_changeHeight.TryGetValue(pair.Key, out var height) || height < blockIndex.BlockHeight))
{
_changeHeight[pair.Key] = blockIndex.BlockHeight;
}
_dictionary.TryRemove(pair.Key, out _);
}
}
public async Task SetExecutionObserverThresholdAsync(IBlockIndex blockIndex,
IExecutionObserverThreshold executionObserverThreshold)
{
if (!ValidateExecutionObserverThreshold(executionObserverThreshold))
{
return;
}
await AddBlockExecutedDataAsync(blockIndex, BranchCountThresholdKey,
new Int32Value { Value = executionObserverThreshold.ExecutionBranchThreshold });
await AddBlockExecutedDataAsync(blockIndex, CallCountThresholdKey,
new Int32Value { Value = executionObserverThreshold.ExecutionCallThreshold });
Logger.LogDebug(
$"ExecutionObserverThreshold has been changed. Branch count threshold is {executionObserverThreshold.ExecutionBranchThreshold}. Call count threshold is {executionObserverThreshold.ExecutionCallThreshold}");
}
public async Task SetLimitAsync(IBlockIndex blockIndex, int limit)
{
if (limit <= _systemTransactionCount)
{
return;
}
var blockTransactionLimit = new Int32Value
{
Value = limit
};
await AddBlockExecutedDataAsync(blockIndex, blockTransactionLimit);
Logger.LogDebug($"BlockTransactionLimit has been changed to {limit}");
}
public T GetBlockExecutedData(IBlockIndex chainContext, string key)
{
if (!_changeHeight.TryGetValue(key, out _) && _dictionary.TryGetValue(key, out var value))
{
return(value);
}
var ret = AsyncHelper.RunSync(() => _blockchainExecutedDataManager.GetExecutedCacheAsync(key,
chainContext.BlockHeight,
chainContext.BlockHash));
var blockExecutedData = Deserialize(ret.Value);
//if executed is in Store, it will not change when forking
if (ret.IsInStore && !_changeHeight.TryGetValue(key, out _))
{
_dictionary[key] = blockExecutedData;
}
return(blockExecutedData);
}
protected T GetBlockExecutedData(IBlockIndex chainContext, string key)
{
return(_cachedBlockchainExecutedDataService.GetBlockExecutedData(chainContext, GetBlockExecutedDataKey(key)));
}
public async Task SetTransactionSizeFeeSymbolsAsync(IBlockIndex blockIndex,
TransactionSizeFeeSymbols transactionSizeFeeSymbols)
{
await AddBlockExecutedDataAsync(blockIndex, transactionSizeFeeSymbols);
}
public async Task SetTotalTransactionFeesMapAsync(IBlockIndex blockIndex,
TotalTransactionFeesMap totalTransactionFeesMap)
{
await AddBlockExecutedDataAsync(blockIndex, totalTransactionFeesMap);
}
public void AddCodeHashCache(IBlockIndex blockIndex, Address address, Hash codeHash)
{
throw new System.NotImplementedException();
}
public virtual async Task SetSmartContractAddressAsync(IBlockIndex blockIndex, string name, Address address)
{
await _smartContractAddressProvider.SetSmartContractAddressAsync(blockIndex, name, address);
}
public Task AddCalculateFunctions(IBlockIndex blockIndex,
Dictionary <string, CalculateFunction> calculateFunctionDictionary)
{
return(Task.CompletedTask);
}
public Task SetTransactionPackingOptionAsync(IBlockIndex blockIndex, bool isTransactionPackable)
{
_isTransactionPackable = isTransactionPackable;
return(Task.CompletedTask);
}
protected async Task AddBlockExecutedDataAsync(IBlockIndex blockIndex, T blockExecutedData)
{
await _cachedBlockchainExecutedDataService.AddBlockExecutedDataAsync(blockIndex,
GetBlockExecutedDataKey(), blockExecutedData);
}
public async Task SetTotalResourceTokensMapsAsync(IBlockIndex blockIndex,
TotalResourceTokensMaps totalResourceTokensMaps)
{
await AddBlockExecutedDataAsync(blockIndex, totalResourceTokensMaps);
}
public Task <int> GetStateSizeLimitAsync(IBlockIndex blockIndex)
{
var stateSizeLimit = GetBlockExecutedData(blockIndex)?.Value ?? SmartContractConstants.StateSizeLimit;
return(Task.FromResult(stateSizeLimit));
}
public async Task SetTransactionPackingOptionAsync(IBlockIndex blockIndex, bool isTransactionPackable)
{
await AddBlockExecutedDataAsync(blockIndex, new BoolValue { Value = isTransactionPackable });
}
/// <summary>
/// Create a txn with provided data.
/// </summary>
/// <param name="from"></param>
/// <param name="methodName"></param>
/// <param name="blockIndex"></param>
/// <param name="bytes"></param>
/// <returns></returns>
private async Task <Transaction> GenerateNotSignedTransactionAsync(Address from, string methodName, IBlockIndex blockIndex, ByteString bytes)
{
var address = await _smartContractAddressService.GetAddressByContractNameAsync(
new ChainContext
{
BlockHash = blockIndex.BlockHash,
BlockHeight = blockIndex.BlockHeight
}, CrossChainSmartContractAddressNameProvider.StringName);
return(new Transaction
{
From = from,
To = address,
RefBlockNumber = blockIndex.BlockHeight,
RefBlockPrefix = ByteString.CopyFrom(blockIndex.BlockHash.Value.Take(4).ToArray()),
MethodName = methodName,
Params = bytes,
});
}
public async Task AddCalculateFunctions(IBlockIndex blockIndex,
Dictionary <string, CalculateFunction> calculateFunctionDictionary)
{
await AddBlockExecutedDataAsync(blockIndex, calculateFunctionDictionary);
}
public async Task SetTotalResourceTokensMapsAsync(IBlockIndex blockIndex,
TotalResourceTokensMaps totalResourceTokensMaps)
{
Logger.LogDebug($"Add TotalResourceTokensMaps: {totalResourceTokensMaps}");
await AddBlockExecutedDataAsync(blockIndex, totalResourceTokensMaps);
}
public async Task <ByteString> GetBlockExecutedDataAsync(IBlockIndex chainContext, string key)
{
return((await _blockchainExecutedDataManager.GetExecutedCacheAsync(key, chainContext.BlockHeight,
chainContext.BlockHash)).Value);
}
public Task <int> GetLimitAsync(IBlockIndex blockIndex)
{
var limit = GetBlockExecutedData(blockIndex);
return(Task.FromResult(limit?.Value ?? int.MaxValue));
}
protected T GetBlockExecutedData(IBlockIndex chainContext, IMessage key = null)
{
return(_cachedBlockchainExecutedDataService.GetBlockExecutedData(chainContext, GetBlockExecutedDataKey(key)));
}
public async Task SetSmartContractRegistrationAsync(IBlockIndex blockIndex, Address address,
SmartContractRegistration smartContractRegistration)
{
await AddBlockExecutedDataAsync(blockIndex, address, smartContractRegistration);
}
protected async Task AddBlockExecutedDataAsync <TKey>(IBlockIndex blockIndex, IDictionary <TKey, T> blockExecutedData)
where TKey : IMessage <TKey>
{
var dic = blockExecutedData.ToDictionary(pair => GetBlockExecutedDataKey(pair.Key), pair => pair.Value);
await _cachedBlockchainExecutedDataService.AddBlockExecutedDataAsync(blockIndex, dic);
}
public async Task SetNonparallelContractCodeAsync(IBlockIndex blockIndex,
IDictionary <Address, NonparallelContractCode> nonparallelContractCodes)
{
await AddBlockExecutedDataAsync(blockIndex, nonparallelContractCodes);
}
