public void FromJson(string jsonValue)
{
switch (jsonValue)
{
case string earliest when string.Equals(earliest, "earliest", StringComparison.InvariantCultureIgnoreCase):
Type = BlockParameterType.Earliest;
return;
case string pending when string.Equals(pending, "pending", StringComparison.InvariantCultureIgnoreCase):
Type = BlockParameterType.Pending;
return;
case string latest when string.Equals(latest, "latest", StringComparison.InvariantCultureIgnoreCase):
Type = BlockParameterType.Latest;
return;
case string empty when string.IsNullOrWhiteSpace(empty):
Type = BlockParameterType.Latest;
return;
case null:
Type = BlockParameterType.Latest;
return;
default:
Type = BlockParameterType.BlockNumber;
BlockNumber = LongConverter.FromString(jsonValue.Trim('"'));
return;
}
}
public override BlockParameter ReadJson(JsonReader reader, Type objectType, BlockParameter existingValue, bool hasExistingValue, JsonSerializer serializer)
{
if (reader.Value == null)
{
return(BlockParameter.Latest);
}
if (reader.Value.IsNonStringValueType())
{
return(new BlockParameter((long)reader.Value));
}
string value = reader.Value as string;
switch (value)
{
case "":
case { } latest when latest.Equals("latest", StringComparison.InvariantCultureIgnoreCase):
return(BlockParameter.Latest);
case { } latest when latest.Equals("earliest", StringComparison.InvariantCultureIgnoreCase):
return(BlockParameter.Earliest);
case { } latest when latest.Equals("pending", StringComparison.InvariantCultureIgnoreCase):
return(BlockParameter.Pending);
default:
return(new BlockParameter(LongConverter.FromString(value)));
}
}
public void Convert_ThrowsException_WhenNotInteger()
{
var py = Python.Instance();
var pyStr = py.Eval("\"omershelef\"");
var converter = new LongConverter();
Assert.Throws<ConversionException>(() => converter.Convert(pyStr));
}
public void LongConverter(object input, long?expected)
{
var converter = new LongConverter();
var result = converter.Convert(input);
Assert.AreEqual(expected, result);
}
public void Convert_ReturnLong_WhenLong()
{
var py = Python.Instance();
var pyLong = py.Eval("12345678910");
var converter = new LongConverter();
Assert.AreEqual(12345678910L, converter.Convert(pyLong));
}
public void Convert_ReturnLong_WhenInt()
{
var py = Python.Instance();
var pyInt = py.Eval("55");
var converter = new LongConverter();
NUnit.Framework.Assert.AreEqual(55, converter.Convert(pyInt));
}
public void LongConverterFromDecimal()
{
var converter = new LongConverter();
var result = converter.Convert(77.5);
Assert.AreEqual(78L, result);
}
public static BlockParameter FromJson(string jsonValue)
{
switch (jsonValue)
{
case { } earliest when string.Equals(earliest, "earliest", StringComparison.InvariantCultureIgnoreCase):
return(Earliest);
case { } pending when string.Equals(pending, "pending", StringComparison.InvariantCultureIgnoreCase):
return(Pending);
case { } latest when string.Equals(latest, "latest", StringComparison.InvariantCultureIgnoreCase):
return(Latest);
case { } empty when string.IsNullOrWhiteSpace(empty):
return(Latest);
case null:
return(Latest);
case { } hash when hash.Length == 66 && hash.StartsWith("0x"):
return(Latest);
default:
return(new BlockParameter(LongConverter.FromString(jsonValue.Trim('"'))));
}
}
public AddBlockResult Insert(Block block)
{
if (!CanAcceptNewBlocks)
{
return(AddBlockResult.CannotAccept);
}
if (block.Number == 0)
{
throw new InvalidOperationException("Genesis block should not be inserted.");
}
Rlp newRlp = _blockDecoder.Encode(block);
_blockDb.Set(block.Hash, newRlp.Bytes);
long expectedNumber = (LowestInsertedBody?.Number - 1 ?? LongConverter.FromString(_syncConfig.PivotNumber ?? "0"));
if (block.Number != expectedNumber)
{
throw new InvalidOperationException($"Trying to insert out of order block {block.Number} when expected number was {expectedNumber}");
}
if (block.Number < (LowestInsertedBody?.Number ?? long.MaxValue))
{
LowestInsertedBody = block;
}
return(AddBlockResult.Added);
}
public void Test_roundtrip(NumberConversion numberConversion)
{
LongConverter converter = new LongConverter(numberConversion);
TestConverter(int.MaxValue, (a, b) => a.Equals(b), converter);
TestConverter(1L, (a, b) => a.Equals(b), converter);
TestConverter(0L, (a, b) => a.Equals(b), converter);
}
public void Unknown_not_supported(NumberConversion notSupportedConversion)
{
LongConverter converter = new LongConverter(notSupportedConversion);
Assert.Throws <NotSupportedException>(
() => TestConverter(int.MaxValue, (a, b) => a.Equals(b), converter));
Assert.Throws <NotSupportedException>(
() => TestConverter(1L, (a, b) => a.Equals(b), converter));
}
public void Throws_on_null()
{
LongConverter converter = new LongConverter();
JsonReader reader = new JsonTextReader(new StringReader("null"));
reader.ReadAsString();
Assert.Throws <JsonException>(
() => converter.ReadJson(reader, typeof(long), 0L, false, JsonSerializer.CreateDefault()));
}
public void Regression_0xa00000()
{
LongConverter converter = new LongConverter();
JsonReader reader = new JsonTextReader(new StringReader("0xa00000"));
reader.ReadAsString();
long result = converter.ReadJson(reader, typeof(long), 0, false, JsonSerializer.CreateDefault());
Assert.AreEqual(10485760, result);
}
public void CanSerializeAndDeserialize()
{
long value = long.MaxValue;
LongConverter converter = new LongConverter();
byte[] bytes = converter.Serialize(value);
long valueFromBytes = converter.Deserialize(bytes);
Assert.Equal(valueFromBytes, value);
}
public void Can_read_0()
{
LongConverter converter = new LongConverter();
JsonReader reader = new JsonTextReader(new StringReader("0"));
reader.ReadAsString();
long result = converter.ReadJson(reader, typeof(long), 0L, false, JsonSerializer.CreateDefault());
Assert.AreEqual(long.Parse("0"), result);
}
public void LongConverter_CorrectConversionTest()
{
Array[] data = new long[][]
{
new long[] { long.MinValue, long.MaxValue },
new long[] { -30000, 60000 },
};
var converter = new LongConverter();
var sut = converter.Convert(data, 2, 2);
var expectation = new ushort[] { 0, ushort.MaxValue, 32767, 32767 };
sut.Should().BeEquivalentTo(expectation);
}
private void LoadEngine(ChainSpecJson chainSpecJson, ChainSpec chainSpec)
{
if (chainSpecJson.Engine?.AuthorityRound != null)
{
chainSpec.SealEngineType = SealEngineType.AuRa;
}
else if (chainSpecJson.Engine?.Clique != null)
{
chainSpec.SealEngineType = SealEngineType.Clique;
chainSpec.Clique = new CliqueParameters();
chainSpec.Clique.Epoch = chainSpecJson.Engine.Clique.Epoch;
chainSpec.Clique.Period = chainSpecJson.Engine.Clique.Period;
chainSpec.Clique.Reward = chainSpecJson.Engine.Clique.BlockReward ?? UInt256.Zero;
}
else if (chainSpecJson.Engine?.Ethash != null)
{
chainSpec.SealEngineType = SealEngineType.Ethash;
chainSpec.Ethash = new EthashParameters();
chainSpec.Ethash.MinimumDifficulty = chainSpecJson.Engine.Ethash.MinimumDifficulty ?? 0L;
chainSpec.Ethash.DifficultyBoundDivisor = chainSpecJson.Engine.Ethash.DifficultyBoundDivisor ?? 0x0800L;
chainSpec.Ethash.DurationLimit = chainSpecJson.Engine.Ethash.DurationLimit ?? 13L;
chainSpec.Ethash.HomesteadTransition = chainSpecJson.Engine.Ethash.HomesteadTransition ?? 0;
chainSpec.Ethash.DaoHardforkTransition = chainSpecJson.Engine.Ethash.DaoHardforkTransition;
chainSpec.Ethash.DaoHardforkBeneficiary = chainSpecJson.Engine.Ethash.DaoHardforkBeneficiary;
chainSpec.Ethash.DaoHardforkAccounts = chainSpecJson.Engine.Ethash.DaoHardforkAccounts ?? new Address[0];
chainSpec.Ethash.Eip100bTransition = chainSpecJson.Engine.Ethash.Eip100bTransition ?? 0L;
chainSpec.Ethash.BlockRewards = new Dictionary <long, UInt256>();
foreach (KeyValuePair <string, UInt256> reward in chainSpecJson.Engine.Ethash.BlockReward)
{
chainSpec.Ethash.BlockRewards.Add(LongConverter.FromString(reward.Key), reward.Value);
}
chainSpec.Ethash.DifficultyBombDelays = new Dictionary <long, long>();
foreach (KeyValuePair <string, long> reward in chainSpecJson.Engine.Ethash.DifficultyBombDelays)
{
chainSpec.Ethash.DifficultyBombDelays.Add(LongConverter.FromString(reward.Key), reward.Value);
}
}
else if (chainSpecJson.Engine?.NethDev != null)
{
chainSpec.SealEngineType = SealEngineType.NethDev;
}
else
{
throw new NotSupportedException("unknown seal engine in chainspec");
}
}
private void LoadLowestInsertedHeader()
{
long left = 0L;
long right = LongConverter.FromString(_syncConfig.PivotNumber ?? "0x0");
ChainLevelInfo lowestInsertedLevel = null;
while (left != right)
{
if (_logger.IsTrace)
{
_logger.Trace($"Finding lowest inserted header - L {left} | R {right}");
}
long index = left + (right - left) / 2 + 1;
ChainLevelInfo level = LoadLevel(index, true);
if (level == null)
{
left = index;
}
else
{
lowestInsertedLevel = level;
right = index - 1L;
}
}
if (lowestInsertedLevel == null)
{
if (_logger.IsTrace)
{
_logger.Trace($"Lowest inserted header is null - L {left} | R {right}");
}
LowestInsertedHeader = null;
}
else
{
BlockInfo blockInfo = lowestInsertedLevel.BlockInfos[0];
LowestInsertedHeader = FindHeader(blockInfo.BlockHash);
if (_logger.IsDebug)
{
_logger.Debug($"Lowest inserted header is {LowestInsertedHeader?.ToString(BlockHeader.Format.Short)} {right} - L {left} | R {right}");
}
}
}
private void LoadLowestInsertedBody()
{
long left = 0L;
long right = LongConverter.FromString(_syncConfig.PivotNumber ?? "0x0");
Block lowestInsertedBlock = null;
while (left != right)
{
if (_logger.IsDebug)
{
_logger.Debug($"Finding lowest inserted body - L {left} | R {right}");
}
long index = left + (right - left) / 2 + 1;
ChainLevelInfo level = LoadLevel(index, true);
Block block = level == null ? null : FindBlock(level.BlockInfos[0].BlockHash, false);
if (block == null)
{
left = index;
}
else
{
lowestInsertedBlock = block;
right = index - 1;
}
}
if (lowestInsertedBlock == null)
{
if (_logger.IsTrace)
{
_logger.Trace($"Lowest inserted body is null - L {left} | R {right}");
}
LowestInsertedBody = null;
}
else
{
if (_logger.IsDebug)
{
_logger.Debug($"Lowest inserted body is {LowestInsertedBody?.ToString(Block.Format.Short)} {right} - L {left} | R {right}");
}
LowestInsertedBody = lowestInsertedBlock;
}
}
public override ChainSpecJson.BlockRewardJson ReadJson(JsonReader reader, Type objectType, ChainSpecJson.BlockRewardJson existingValue, bool hasExistingValue, JsonSerializer serializer)
{
existingValue ??= new ChainSpecJson.BlockRewardJson();
if (reader.TokenType == JsonToken.String || reader.TokenType == JsonToken.Integer)
{
var blockReward = serializer.Deserialize <UInt256>(reader);
existingValue.Add(0, blockReward);
}
else
{
var blockRewards = serializer.Deserialize <Dictionary <string, UInt256> >(reader);
foreach (var blockReward in blockRewards ?? throw new ArgumentException("Cannot deserialize BlockReward."))
{
existingValue.Add(LongConverter.FromString(blockReward.Key), blockReward.Value);
}
}
return(existingValue);
}
public override ChainSpecJson.AuraEngineParamsJson.StepDurationJson ReadJson(JsonReader reader, Type objectType, ChainSpecJson.AuraEngineParamsJson.StepDurationJson existingValue, bool hasExistingValue, JsonSerializer serializer)
{
existingValue ??= new ChainSpecJson.AuraEngineParamsJson.StepDurationJson();
if (reader.TokenType == JsonToken.String || reader.TokenType == JsonToken.Integer)
{
var stepDuration = serializer.Deserialize <long>(reader);
existingValue.Add(0, stepDuration);
}
else
{
var stepDurations = serializer.Deserialize <Dictionary <string, long> >(reader);
foreach (var stepDuration in stepDurations ?? throw new ArgumentException("Cannot deserialize StepDuration."))
{
existingValue.Add(LongConverter.FromString(stepDuration.Key), stepDuration.Value);
}
}
return(existingValue);
}
public virtual IList <MetricsIntervalResultDto> interval(UriInfo uriInfo)
{
MultivaluedMap <string, string> queryParameters = uriInfo.QueryParameters;
MetricsQuery query = processEngine.ManagementService.createMetricsQuery().name(queryParameters.getFirst(QUERY_PARAM_NAME)).reporter(queryParameters.getFirst(QUERY_PARAM_REPORTER));
applyQueryParams(query, queryParameters);
IList <MetricIntervalValue> metrics;
LongConverter longConverter = new LongConverter();
longConverter.ObjectMapper = objectMapper;
if (queryParameters.getFirst(QUERY_PARAM_INTERVAL) != null)
{
long interval = longConverter.convertQueryParameterToType(queryParameters.getFirst(QUERY_PARAM_INTERVAL)).Value;
metrics = query.interval(interval);
}
else
{
metrics = query.interval();
}
return(convertToDtos(metrics));
}
/// <summary>
/// Converts array element into a long or returns default value if conversion is not possible.
/// </summary>
/// <param name="index">an index of element to get.</param>
/// <param name="defaultValue">the default value</param>
/// <returns>long value of element or default value if conversion is not supported.</returns>
/// See <see cref="LongConverter.ToLongWithDefault(object, long)"/>
public long GetAsLongWithDefault(int index, long defaultValue)
{
return(LongConverter.ToLongWithDefault(this[index], defaultValue));
}
/// <summary>
/// Converts array element into a long or returns null if conversion is not possible.
/// </summary>
/// <param name="index">an index of element to get.</param>
/// <returns>long value of element or null if conversion is not supported.</returns>
/// See <see cref="LongConverter.ToNullableLong(object)"/>
public long?GetAsNullableLong(int index)
{
return(LongConverter.ToNullableLong(this[index]));
}
private void LoadEngine(ChainSpecJson chainSpecJson, ChainSpec chainSpec)
{
AuRaParameters.Validator LoadValidator(ChainSpecJson.AuRaValidatorJson validatorJson, int level = 0)
{
var validatorType = validatorJson.GetValidatorType();
var validator = new AuRaParameters.Validator()
{
ValidatorType = validatorType
};
switch (validator.ValidatorType)
{
case AuRaParameters.ValidatorType.List:
validator.Addresses = validatorJson.List;
break;
case AuRaParameters.ValidatorType.Contract:
validator.Addresses = new[] { validatorJson.SafeContract };
break;
case AuRaParameters.ValidatorType.ReportingContract:
validator.Addresses = new[] { validatorJson.Contract };
break;
case AuRaParameters.ValidatorType.Multi:
if (level != 0)
{
throw new ArgumentException("AuRa multi validator cannot be inner validator.");
}
validator.Validators = validatorJson.Multi
.ToDictionary(kvp => kvp.Key, kvp => LoadValidator(kvp.Value, level + 1))
.ToImmutableSortedDictionary();
break;
default:
throw new ArgumentOutOfRangeException();
}
return(validator);
}
if (chainSpecJson.Engine?.AuthorityRound != null)
{
chainSpec.SealEngineType = SealEngineType.AuRa;
chainSpec.AuRa = new AuRaParameters
{
MaximumUncleCount = chainSpecJson.Engine.AuthorityRound.MaximumUncleCount,
MaximumUncleCountTransition = chainSpecJson.Engine.AuthorityRound.MaximumUncleCountTransition,
StepDuration = chainSpecJson.Engine.AuthorityRound.StepDuration,
BlockReward = chainSpecJson.Engine.AuthorityRound.BlockReward,
BlockRewardContractAddress = chainSpecJson.Engine.AuthorityRound.BlockRewardContractAddress,
BlockRewardContractTransition = chainSpecJson.Engine.AuthorityRound.BlockRewardContractTransition,
BlockRewardContractTransitions = chainSpecJson.Engine.AuthorityRound.BlockRewardContractTransitions,
ValidateScoreTransition = chainSpecJson.Engine.AuthorityRound.ValidateScoreTransition,
ValidateStepTransition = chainSpecJson.Engine.AuthorityRound.ValidateStepTransition,
Validators = LoadValidator(chainSpecJson.Engine.AuthorityRound.Validator),
RandomnessContractAddress = chainSpecJson.Engine.AuthorityRound.RandomnessContractAddress,
BlockGasLimitContractTransitions = chainSpecJson.Engine.AuthorityRound.BlockGasLimitContractTransitions,
};
}
else if (chainSpecJson.Engine?.Clique != null)
{
chainSpec.SealEngineType = SealEngineType.Clique;
chainSpec.Clique = new CliqueParameters
{
Epoch = chainSpecJson.Engine.Clique.Epoch,
Period = chainSpecJson.Engine.Clique.Period,
Reward = chainSpecJson.Engine.Clique.BlockReward ?? UInt256.Zero
};
}
else if (chainSpecJson.Engine?.Ethash != null)
{
chainSpec.SealEngineType = SealEngineType.Ethash;
chainSpec.Ethash = new EthashParameters
{
MinimumDifficulty = chainSpecJson.Engine.Ethash.MinimumDifficulty ?? 0L,
DifficultyBoundDivisor = chainSpecJson.Engine.Ethash.DifficultyBoundDivisor ?? 0x0800L,
DurationLimit = chainSpecJson.Engine.Ethash.DurationLimit ?? 13L,
HomesteadTransition = chainSpecJson.Engine.Ethash.HomesteadTransition ?? 0,
DaoHardforkTransition = chainSpecJson.Engine.Ethash.DaoHardforkTransition,
DaoHardforkBeneficiary = chainSpecJson.Engine.Ethash.DaoHardforkBeneficiary,
DaoHardforkAccounts = chainSpecJson.Engine.Ethash.DaoHardforkAccounts ?? new Address[0],
Eip100bTransition = chainSpecJson.Engine.Ethash.Eip100bTransition ?? 0L,
BlockRewards = new Dictionary <long, UInt256>()
};
foreach (KeyValuePair <string, UInt256> reward in chainSpecJson.Engine.Ethash.BlockReward)
{
chainSpec.Ethash.BlockRewards.Add(LongConverter.FromString(reward.Key), reward.Value);
}
chainSpec.Ethash.DifficultyBombDelays = new Dictionary <long, long>();
foreach (KeyValuePair <string, long> reward in chainSpecJson.Engine.Ethash.DifficultyBombDelays)
{
chainSpec.Ethash.DifficultyBombDelays.Add(LongConverter.FromString(reward.Key), reward.Value);
}
}
else if (chainSpecJson.Engine?.NethDev != null)
{
chainSpec.SealEngineType = SealEngineType.NethDev;
}
else
{
throw new NotSupportedException("unknown seal engine in chainspec");
}
}
/**
* Matches a signature to the MsArg and if the signature matches unpacks the component values of a MsgArg into an object.
* This function resolved through variants, so if the MsgArg is a variant that references a 32 bit integer is can be unpacked
* directly into a 32 bit integer pointer.
*
* - @c 'a' An object containing an array
* - @c 'b' An object containing a bool
* - @c 'd' An object containing a double (64 bits)
* - @c 'g' An object containing a string that represents an AllJoyn signature
* - @c 'h' An object containing a Socket file desciptor
* - @c 'i' An object containing an int
* - @c 'n' An object containing a short
* - @c 'o' An object containing a string that represents the name of an AllJoyn object
* - @c 'q' An object containing a ushort
* - @c 's' An object containing a string
* - @c 't' An object containing a ulong
* - @c 'u' An object containing a uint
* - @c 'v' An object containing a MsgArg
* - @c 'x' An object containing a long
* - @c 'y' An object containing a byte
*
* - @c '(' and @c ')' An object containing a struct
* - @c '{' and @c '}' An object containing the key and value pair of a dictonary
*
* - @c '*' This matches any value type. This should not show up in a signature it is used by AllJoyn for matching
*
* @param sig The signature for MsgArg value
* @param[out] value object to hold the values unpacked from the MsgArg
* @return
* - QStatus.OK if the signature matched and MsgArg was successfully unpacked.
* - QStatus.BUS_SIGNATURE_MISMATCH if the signature did not match.
* - An error status otherwise
*/
//TODO add in examples into the Get documentation
public QStatus Get(string sig, out object value)
{
QStatus status = QStatus.OK;
value = null;
// handle multiple signatures in one get command
if (sig.Length > 1)
{
string[] sigs = splitSignature(sig);
if (sigs.Length > 1)
{
//is the signature larger than the passed in MsgArg?
if (sigs.Length > _length)
{
return AllJoyn.QStatus.BUS_BAD_SIGNATURE;
}
object[] values = new object[sigs.Length];
for (int j = 0; j < sigs.Length; ++j)
{
status = this[j].Get(sigs[j], out values[j]);
if (AllJoyn.QStatus.OK != status)
{
return status;
}
}
value = values;
return status;
}
}
switch ((AllJoynTypeId)sig[0])
{
case AllJoynTypeId.ALLJOYN_BYTE:
byte y;
status = alljoyn_msgarg_get_uint8(_msgArg, out y);
value = y;
break;
case AllJoynTypeId.ALLJOYN_BOOLEAN:
bool b;
status = alljoyn_msgarg_get_bool(_msgArg, out b);
value = b;
break;
case AllJoynTypeId.ALLJOYN_INT16:
short n;
status = alljoyn_msgarg_get_int16(_msgArg, out n);
value = n;
break;
case AllJoynTypeId.ALLJOYN_UINT16:
ushort q;
status = alljoyn_msgarg_get_uint16(_msgArg, out q);
value = q;
break;
case AllJoynTypeId.ALLJOYN_INT32:
int i;
status = alljoyn_msgarg_get_int32(_msgArg, out i);
value = i;
break;
case AllJoynTypeId.ALLJOYN_UINT32:
uint u;
status = alljoyn_msgarg_get_uint32(_msgArg, out u);
value = u;
break;
case AllJoynTypeId.ALLJOYN_INT64:
long x;
status = alljoyn_msgarg_get_int64(_msgArg, out x);
value = x;
break;
case AllJoynTypeId.ALLJOYN_UINT64:
ulong t;
status = alljoyn_msgarg_get_uint64(_msgArg, out t);
value = t;
break;
case AllJoynTypeId.ALLJOYN_DOUBLE:
double d;
status = alljoyn_msgarg_get_double(_msgArg, out d);
value = d;
break;
case AllJoynTypeId.ALLJOYN_STRING:
IntPtr s;
status = alljoyn_msgarg_get_string(_msgArg, out s);
value = Marshal.PtrToStringAnsi(s);
break;
case AllJoynTypeId.ALLJOYN_OBJECT_PATH:
IntPtr o;
status = alljoyn_msgarg_get_objectpath(_msgArg, out o);
value = Marshal.PtrToStringAnsi(o);
break;
case AllJoynTypeId.ALLJOYN_SIGNATURE:
IntPtr g;
status = alljoyn_msgarg_get_signature(_msgArg, out g);
value = Marshal.PtrToStringAnsi(g);
break;
case AllJoynTypeId.ALLJOYN_VARIANT:
IntPtr v;
status = alljoyn_msgarg_get_variant(_msgArg, out v);
if (status)
{
value = new MsgArg(v);
}
break;
case AllJoynTypeId.ALLJOYN_ARRAY:
int length;
switch ((AllJoynTypeId)sig[1])
{
case AllJoynTypeId.ALLJOYN_BYTE:
IntPtr ay;
status = alljoyn_msgarg_get_uint8_array(_msgArg, out length, out ay);
byte[] ay_result = new byte[length];
Marshal.Copy(ay, ay_result, 0, length);
value = ay_result;
break;
case AllJoynTypeId.ALLJOYN_BOOLEAN:
IntPtr ab;
status = alljoyn_msgarg_get_bool_array(_msgArg, out length, out ab);
int[] ab_result = new int[length];
Marshal.Copy(ab, ab_result, 0, length);
bool[] ab_retValue = new bool[length];
for (int j = 0; j < length; j++)
{
if (ab_result[j] == 0)
{
ab_retValue[j] = false;
}
else
{
ab_retValue[j] = true;
}
}
value = ab_retValue;
break;
case AllJoynTypeId.ALLJOYN_INT16:
IntPtr an;
status = alljoyn_msgarg_get_int16_array(_msgArg, out length, out an);
short[] an_result = new short[length];
Marshal.Copy(an, an_result, 0, length);
value = an_result;
break;
case AllJoynTypeId.ALLJOYN_UINT16:
IntPtr aq;
status = alljoyn_msgarg_get_uint16_array(_msgArg, out length, out aq);
short[] aq_result = new short[length];
Marshal.Copy(aq, aq_result, 0, length);
ShortConverter shortConverter = new ShortConverter();
shortConverter.Shorts = aq_result;
value = shortConverter.UShorts;
break;
case AllJoynTypeId.ALLJOYN_INT32:
IntPtr ai;
status = alljoyn_msgarg_get_int32_array(_msgArg, out length, out ai);
int[] ai_result = new int[length];
Marshal.Copy(ai, ai_result, 0, length);
value = ai_result;
break;
case AllJoynTypeId.ALLJOYN_UINT32:
IntPtr au;
status = alljoyn_msgarg_get_uint32_array(_msgArg, out length, out au);
int[] au_result = new int[length];
Marshal.Copy(au, au_result, 0, length);
IntConverter intConverter = new IntConverter();
intConverter.Ints = au_result;
value = intConverter.UInts;
break;
case AllJoynTypeId.ALLJOYN_INT64:
IntPtr ax;
status = alljoyn_msgarg_get_int64_array(_msgArg, out length, out ax);
long[] ax_result = new long[length];
Marshal.Copy(ax, ax_result, 0, length);
value = ax_result;
break;
case AllJoynTypeId.ALLJOYN_UINT64:
IntPtr at;
status = alljoyn_msgarg_get_uint64_array(_msgArg, out length, out at);
long[] at_result = new long[length];
Marshal.Copy(at, at_result, 0, length);
LongConverter longConverter = new LongConverter();
longConverter.Longs = at_result;
value = longConverter.ULongs;
break;
case AllJoynTypeId.ALLJOYN_DOUBLE:
IntPtr ad;
status = alljoyn_msgarg_get_double_array(_msgArg, out length, out ad);
double[] ad_result = new double[length];
Marshal.Copy(ad, ad_result, 0, length);
value = ad_result;
break;
case AllJoynTypeId.ALLJOYN_STRING:
IntPtr sa;
status = alljoyn_msgarg_get_variant_array(_msgArg, "as", out length, out sa);
if (status)
{
string[] as_result = new string[length];
for (int j = 0; j < length; ++j)
{
if (status)
{
IntPtr inner_s;
status = alljoyn_msgarg_get_string(alljoyn_msgarg_array_element(sa, (UIntPtr)j), out inner_s);
as_result[j] = Marshal.PtrToStringAnsi(inner_s);
}
else
{
break;
}
}
value = as_result;
}
break;
case AllJoynTypeId.ALLJOYN_OBJECT_PATH:
IntPtr ao;
status = alljoyn_msgarg_get_variant_array(_msgArg, "ao", out length, out ao);
if (status)
{
string[] ao_result = new string[length];
for (int j = 0; j < length; ++j)
{
if (status)
{
IntPtr inner_o;
status = alljoyn_msgarg_get_objectpath(alljoyn_msgarg_array_element(ao, (UIntPtr)j), out inner_o);
ao_result[j] = Marshal.PtrToStringAnsi(inner_o);
}
else
{
break;
}
}
value = ao_result;
}
break;
case AllJoynTypeId.ALLJOYN_SIGNATURE:
IntPtr ag;
status = alljoyn_msgarg_get_variant_array(_msgArg, "ag", out length, out ag);
if (status)
{
string[] ag_result = new string[length];
for (int j = 0; j < length; ++j)
{
if (status)
{
IntPtr inner_g;
status = alljoyn_msgarg_get_signature(alljoyn_msgarg_array_element(ag, (UIntPtr)j), out inner_g);
ag_result[j] = Marshal.PtrToStringAnsi(inner_g);
}
else
{
break;
}
}
value = ag_result;
}
break;
case AllJoynTypeId.ALLJOYN_VARIANT:
IntPtr av;
status = alljoyn_msgarg_get_variant_array(_msgArg, "av", out length, out av);
if (status)
{
MsgArg av_result = new MsgArg(av);
av_result._length = length;
value = av_result;
}
break;
case AllJoynTypeId.ALLJOYN_DICT_ENTRY_OPEN:
int dict_size = alljoyn_msgarg_get_array_numberofelements(_msgArg);
System.Collections.Generic.Dictionary<object, object> dict = new System.Collections.Generic.Dictionary<object, object>();
// signature of form a{KV} where key is always one letter value
// just must be a complete signature lenght - 1 for K - 2 for 'a{' and '}'
string key_sig = sig.Substring(2, 1);
string value_sig = sig.Substring(3, sig.Length - 4);
if (key_sig == null || value_sig == null)
{
status = AllJoyn.QStatus.BUS_SIGNATURE_MISMATCH;
}
for (int j = 0; j < dict_size; ++j)
{
IntPtr inner_data_ptr;
alljoyn_msgarg_get_array_element(_msgArg, (UIntPtr)j, out inner_data_ptr);
Object actualKey;
Object actualValue;
MsgArg key_MsgArg = new MsgArg(alljoyn_msgarg_getkey(inner_data_ptr));
MsgArg value_MsgArg = new MsgArg(alljoyn_msgarg_getvalue(inner_data_ptr));
key_MsgArg.Get(key_sig, out actualKey);
value_MsgArg.Get(value_sig, out actualValue);
dict.Add(actualKey, actualValue);
}
value = dict;
break;
case AllJoynTypeId.ALLJOYN_STRUCT_OPEN:
int struct_array_size = alljoyn_msgarg_get_array_numberofelements(_msgArg);
MsgArg struct_array = new MsgArg(struct_array_size);
for (int j = 0; j < struct_array_size; ++j)
{
IntPtr struct_array_ptr;
alljoyn_msgarg_get_array_element(_msgArg, (UIntPtr)j, out struct_array_ptr);
AllJoyn.MsgArg tmp = new MsgArg(struct_array_ptr);
struct_array[j] = tmp;
}
value = struct_array;
break;
case AllJoynTypeId.ALLJOYN_ARRAY:
int outer_array_size = alljoyn_msgarg_get_array_numberofelements(_msgArg);
object[] outerArray = new object[outer_array_size];
for (int j = 0; j < outer_array_size; j++)
{
if (status)
{
IntPtr inner_data_ptr;
alljoyn_msgarg_get_array_element(_msgArg, (UIntPtr)j, out inner_data_ptr);
MsgArg tmp = new MsgArg(inner_data_ptr);
string inner_array_sig = Marshal.PtrToStringAnsi(alljoyn_msgarg_get_array_elementsignature(_msgArg, (UIntPtr)j));
status = tmp.Get(inner_array_sig, out outerArray[j]);
}
else
{
break;
}
}
value = outerArray;
break;
default:
status = QStatus.WRITE_ERROR;
break;
}
break;
case AllJoynTypeId.ALLJOYN_STRUCT_OPEN:
if ((AllJoynTypeId)sig[sig.Length - 1] != AllJoynTypeId.ALLJOYN_STRUCT_CLOSE)
{
return AllJoyn.QStatus.BUS_BAD_SIGNATURE;
}
string[] struct_sigs = splitSignature(sig.Substring(1, sig.Length - 2));
if (struct_sigs == null)
{
return AllJoyn.QStatus.BUS_BAD_SIGNATURE;
}
int numMembers = alljoyn_msgarg_getnummembers(_msgArg);
if (numMembers != struct_sigs.Length)
{
return AllJoyn.QStatus.BUS_BAD_SIGNATURE;
}
object[] structObjects = new object[numMembers];
for (int j = 0; j < struct_sigs.Length; ++j)
{
MsgArg arg = new MsgArg(alljoyn_msgarg_getmember(_msgArg, (UIntPtr)j));
status = arg.Get(struct_sigs[j], out structObjects[j]);
if (AllJoyn.QStatus.OK != status)
{
return status;
}
}
value = structObjects;
break;
case AllJoynTypeId.ALLJOYN_DICT_ENTRY_OPEN:
// A dictionary entry must start with 'a' followed by '{'
// if it starts with '{' it is an invalid signature.
status = QStatus.BUS_BAD_SIGNATURE;
break;
default:
status = QStatus.WRITE_ERROR;
break;
}
return status;
}
/// <summary>
/// Converts map element into a long or returns default value if conversion is not possible.
/// </summary>
/// <param name="key">a key of element to get.</param>
/// <param name="defaultValue">the default value</param>
/// <returns>long value of the element or default value if conversion is not supported.</returns>
/// See <see cref="LongConverter.ToLongWithDefault(object, long)"/>
public long GetAsLongWithDefault(string key, long defaultValue)
{
var value = Get(key);
return(LongConverter.ToLongWithDefault(value, defaultValue));
}
/// <summary>
/// Converts map element into a long or returns null if conversion is not possible.
/// </summary>
/// <param name="key">a key of element to get.</param>
/// <returns>long value of the element or null if conversion is not supported.</returns>
/// See <see cref="LongConverter.ToNullableLong(object)"/>
public long?GetAsNullableLong(string key)
{
var value = Get(key);
return(LongConverter.ToNullableLong(value));
}
internal static LongConverter Get(byte[] bytes)
{
LongConverter converter = new LongConverter();
converter.Bytes = bytes;
return converter;
}
/// <summary>
/// Creates a new instance and sets its values.
/// </summary>
/// <param name="skip">the number of items to skip.</param>
/// <param name="take">the number of items to return.</param>
/// <param name="total">true to return the total number of items.</param>
public PagingParams(object skip, object take, object total = null)
{
Skip = LongConverter.ToNullableLong(skip);
Take = LongConverter.ToNullableLong(take);
Total = BooleanConverter.ToBooleanWithDefault(total, false);
}
private int InsertBodies(BodiesSyncBatch batch)
{
List <Block> validResponses = new List <Block>();
for (int i = 0; i < batch.Response.Length; i++)
{
BlockBody blockBody = batch.Response[i];
if (blockBody == null)
{
break;
}
Block block = new Block(batch.Headers[i], blockBody.Transactions, blockBody.Ommers);
if (new TxTrie(block.Transactions).RootHash != block.TxRoot ||
OmmersHash.Calculate(block) != block.OmmersHash)
{
if (_logger.IsWarn)
{
_logger.Warn($"{batch} - reporting INVALID - tx or ommers");
}
_syncPeerPool.ReportBreachOfProtocol(batch.ResponseSourcePeer, $"invalid tx or ommers root");
break;
}
validResponses.Add(block);
}
int validResponsesCount = validResponses.Count;
if (validResponses.Count < batch.Request.Length)
{
BodiesSyncBatch fillerBatch = new BodiesSyncBatch();
fillerBatch.MinNumber = batch.MinNumber;
int originalLength = batch.Request.Length;
fillerBatch.Request = new Keccak[originalLength - validResponsesCount];
fillerBatch.Headers = new BlockHeader[originalLength - validResponsesCount];
for (int i = validResponsesCount; i < originalLength; i++)
{
fillerBatch.Request[i - validResponsesCount] = batch.Request[i];
fillerBatch.Headers[i - validResponsesCount] = batch.Headers[i];
}
if (_logger.IsDebug)
{
_logger.Debug($"{batch} -> FILLER {fillerBatch}");
}
_pending.Enqueue(fillerBatch);
}
if (validResponses.Any())
{
long expectedNumber = _blockTree.LowestInsertedBody?.Number - 1 ?? LongConverter.FromString(_syncConfig.PivotNumber ?? "0");
if (validResponses.Last().Number != expectedNumber)
{
_dependencies.TryAdd(validResponses.Last().Number, validResponses);
}
else
{
validResponses.Reverse();
InsertBlocks(validResponses);
}
if (_blockTree.LowestInsertedBody != null)
{
_syncReport.FastBlocksBodies.Update(_pivotNumber - _blockTree.LowestInsertedBody.Number + 1);
}
}
if (_logger.IsDebug)
{
_logger.Debug($"LOWEST_INSERTED {_blockTree.LowestInsertedBody?.Number} | HANDLED {batch}");
}
_syncReport.BodiesInQueue.Update(BodiesInQueue);
return(validResponsesCount);
}
public void ValidateConvertToObjectFromString()
{
var val = new LongConverter("4294967296").ConvertToObject("", CultureInfo.CurrentCulture);
Assert.AreEqual(0x100000000, val);
}
static AuRaParameters.Validator LoadValidator(ChainSpecJson.AuRaValidatorJson validatorJson, int level = 0)
{
AuRaParameters.ValidatorType validatorType = validatorJson.GetValidatorType();
AuRaParameters.Validator validator = new() { ValidatorType = validatorType };
switch (validator.ValidatorType)
{
case AuRaParameters.ValidatorType.List:
validator.Addresses = validatorJson.List;
break;
case AuRaParameters.ValidatorType.Contract:
validator.Addresses = new[] { validatorJson.SafeContract };
break;
case AuRaParameters.ValidatorType.ReportingContract:
validator.Addresses = new[] { validatorJson.Contract };
break;
case AuRaParameters.ValidatorType.Multi:
if (level != 0)
{
throw new ArgumentException("AuRa multi validator cannot be inner validator.");
}
validator.Validators = validatorJson.Multi
.ToDictionary(kvp => kvp.Key, kvp => LoadValidator(kvp.Value, level + 1))
.ToImmutableSortedDictionary();
break;
default:
throw new ArgumentOutOfRangeException();
}
return(validator);
}
if (chainSpecJson.Engine?.AuthorityRound != null)
{
chainSpec.SealEngineType = SealEngineType.AuRa;
chainSpec.AuRa = new AuRaParameters
{
MaximumUncleCount = chainSpecJson.Engine.AuthorityRound.MaximumUncleCount,
MaximumUncleCountTransition = chainSpecJson.Engine.AuthorityRound.MaximumUncleCountTransition,
StepDuration = chainSpecJson.Engine.AuthorityRound.StepDuration,
BlockReward = chainSpecJson.Engine.AuthorityRound.BlockReward,
BlockRewardContractAddress = chainSpecJson.Engine.AuthorityRound.BlockRewardContractAddress,
BlockRewardContractTransition = chainSpecJson.Engine.AuthorityRound.BlockRewardContractTransition,
BlockRewardContractTransitions = chainSpecJson.Engine.AuthorityRound.BlockRewardContractTransitions,
ValidateScoreTransition = chainSpecJson.Engine.AuthorityRound.ValidateScoreTransition,
ValidateStepTransition = chainSpecJson.Engine.AuthorityRound.ValidateStepTransition,
Validators = LoadValidator(chainSpecJson.Engine.AuthorityRound.Validator),
RandomnessContractAddress = chainSpecJson.Engine.AuthorityRound.RandomnessContractAddress,
BlockGasLimitContractTransitions = chainSpecJson.Engine.AuthorityRound.BlockGasLimitContractTransitions,
TwoThirdsMajorityTransition = chainSpecJson.Engine.AuthorityRound.TwoThirdsMajorityTransition ?? AuRaParameters.TransitionDisabled,
PosdaoTransition = chainSpecJson.Engine.AuthorityRound.PosdaoTransition ?? AuRaParameters.TransitionDisabled,
RewriteBytecode = chainSpecJson.Engine.AuthorityRound.RewriteBytecode,
};
}
else if (chainSpecJson.Engine?.Clique != null)
{
chainSpec.SealEngineType = SealEngineType.Clique;
chainSpec.Clique = new CliqueParameters
{
Epoch = chainSpecJson.Engine.Clique.Epoch,
Period = chainSpecJson.Engine.Clique.Period,
Reward = chainSpecJson.Engine.Clique.BlockReward ?? UInt256.Zero
};
}
else if (chainSpecJson.Engine?.Ethash != null)
{
chainSpec.SealEngineType = SealEngineType.Ethash;
chainSpec.Ethash = new EthashParameters
{
MinimumDifficulty = chainSpecJson.Engine.Ethash.MinimumDifficulty ?? 0L,
DifficultyBoundDivisor = chainSpecJson.Engine.Ethash.DifficultyBoundDivisor ?? 0x0800L,
DurationLimit = chainSpecJson.Engine.Ethash.DurationLimit ?? 13L,
HomesteadTransition = chainSpecJson.Engine.Ethash.HomesteadTransition ?? 0,
DaoHardforkTransition = chainSpecJson.Engine.Ethash.DaoHardforkTransition,
DaoHardforkBeneficiary = chainSpecJson.Engine.Ethash.DaoHardforkBeneficiary,
DaoHardforkAccounts = chainSpecJson.Engine.Ethash.DaoHardforkAccounts ?? Array.Empty <Address>(),
Eip100bTransition = chainSpecJson.Engine.Ethash.Eip100bTransition ?? 0L,
FixedDifficulty = chainSpecJson.Engine.Ethash.FixedDifficulty,
BlockRewards = chainSpecJson.Engine.Ethash.BlockReward
};
chainSpec.Ethash.DifficultyBombDelays = new Dictionary <long, long>();
if (chainSpecJson.Engine.Ethash.DifficultyBombDelays != null)
{
foreach (KeyValuePair <string, long> reward in chainSpecJson.Engine.Ethash.DifficultyBombDelays)
{
chainSpec.Ethash.DifficultyBombDelays.Add(LongConverter.FromString(reward.Key), reward.Value);
}
}
}
else if (chainSpecJson.Engine?.NethDev != null)
{
chainSpec.SealEngineType = SealEngineType.NethDev;
}
var customEngineType = chainSpecJson.Engine?.CustomEngineData?.FirstOrDefault().Key;
if (!string.IsNullOrEmpty(customEngineType))
{
chainSpec.SealEngineType = customEngineType;
}
if (string.IsNullOrEmpty(chainSpec.SealEngineType))
{
throw new NotSupportedException("unknown seal engine in chainspec");
}
}
public long?GetAsNullableLong()
{
return(LongConverter.ToNullableLong(Value));
}
public long GetAsLongWithDefault(long defaultValue)
{
return(LongConverter.ToLongWithDefault(Value, defaultValue));
}
static MyJsonResult()
{
LongConverter = new LongConverter();
IsoDateTimeConverterMap = new Dictionary <string, IsoDateTimeConverter>();
}
