public byte[] Encode(params dynamic[] values)
{
MemoryStream stream = new MemoryStream();
if (values.Length == this._definition.inputs.Length)
{
try
{
AbiInputParameter[] parameters = new AbiInputParameter[values.Length];
for (int index = 0; index < values.Length; index++)
{
parameters[index] = new AbiInputParameter(this._definition.inputs[index], values[index]);
}
stream.Append(this._definition.Sha3Signature);
stream.Append(AbiParameterCoder.EncodeParames(parameters));
}
catch
{
throw new ArgumentException("input values invalid");
}
}
else
{
throw new ArgumentException("values number not match");
}
return(stream.ToArray());
}
private byte[][] Encode(Dictionary <string, dynamic> args)
{
List <byte[]> topics = new List <byte[]>();
if (!this._definition.Anonymous)
{
topics.Add(this._definition.Sha3Signature);
}
foreach (var input in this._definition.inputs)
{
if (!input.Indexed)
{
continue;
}
if (args.ContainsKey(input.Name) && args[input.Name] == null)
{
topics.Add(null);
}
else
{
var arg = args[input.Name];
if (this.IsDynamicType(input.ABIType))
{
if (input.ABIType == "string")
{
byte[] topic = Keccack256.CalculateHash(arg.ToString());
topics.Add(topic);
}
else
{
if ((arg is string) && (arg as string).IsHexString())
{
byte[] topic = Keccack256.CalculateHash(arg);
topics.Add(topic);
}
else
{
throw new ArgumentException(string.Format("invalid {0} value", input.ABIType));
}
}
}
else
{
byte[] topic = AbiParameterCoder.EncodeParame(new AbiInputParameter(input, arg));
topics.Add(topic);
}
}
}
return(topics.ToArray());
}
public byte[] EncodeConstructorWithParameter(params dynamic[] values)
{
if (this._definition.Constructor == null)
{
throw new ArgumentException("Constructor havn’t parameter");
}
List <AbiInputParameter> parameters = new List <AbiInputParameter>();
for (int index = 0; index < values.Length; index++)
{
IAbiParameterDefinition parameDefinition = this._definition.Constructor.inputs[0];
parameters.Add(new AbiInputParameter(parameDefinition, values[index]));
}
return(AbiParameterCoder.EncodeParames(parameters.ToArray()));
}
public AbiOutputParameter[] Decode(byte[] outputdata)
{
return(AbiParameterCoder.DecodeParames(this._definition.outputs, outputdata));
}
public static AbiOutputParameter[] DecodeParames(IAbiParameterDefinition[] parameters, byte[] data)
{
return(AbiParameterCoder.Decode(parameters, data));
}
public static AbiOutputParameter DecodeParame(IAbiParameterDefinition definition, byte[] data)
{
AbiOutputParameter[] outputs = AbiParameterCoder.Decode(new[] { definition }, data);
return(outputs.Length > 0 ? outputs[0] : null);
}
public static byte[] EncodeParames(AbiInputParameter[] parameters)
{
return(AbiParameterCoder.Encode(parameters));
}
public static byte[] EncodeParame(AbiInputParameter parameter)
{
return(AbiParameterCoder.Encode(new[] { parameter }));
}
