public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
reader.AssertJsonType(JsonToken.String);
try
{
var bytes = Encoders.Hex.DecodeData((string)reader.Value);
if (objectType == typeof(Key))
{
return(new Key(bytes));
}
else if (objectType == typeof(PubKey))
{
return(new PubKey(bytes));
}
else if (objectType == typeof(TaprootPubKey))
{
return(new TaprootPubKey(bytes));
}
else
{
return(new TaprootInternalPubKey(bytes));
}
}
catch (EndOfStreamException)
{
}
catch (FormatException)
{
}
throw new JsonObjectException("Invalid bitcoin object of type " + objectType.Name, reader);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
reader.AssertJsonType(JsonToken.String);
var network = (string)reader.Value;
if (network == null)
{
return(null);
}
if (network.Equals("MainNet", StringComparison.OrdinalIgnoreCase) || network.Equals("main", StringComparison.OrdinalIgnoreCase))
{
return(Network.Main);
}
if (network.Equals("TestNet", StringComparison.OrdinalIgnoreCase) || network.Equals("test", StringComparison.OrdinalIgnoreCase))
{
return(Network.TestNet);
}
if (network.Equals("RegTest", StringComparison.OrdinalIgnoreCase) || network.Equals("reg", StringComparison.OrdinalIgnoreCase))
{
return(Network.RegTest);
}
var net = Network.GetNetwork(network);
if (net != null)
{
return(net);
}
throw new JsonObjectException("Unknown network (valid values : main, test, reg)", reader);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
reader.AssertJsonType(JsonToken.String);
try
{
if (objectType == typeof(KeyId))
{
return(new KeyId(Encoders.Hex.DecodeData((string)reader.Value)));
}
if (objectType == typeof(ScriptId))
{
return(new ScriptId(Encoders.Hex.DecodeData((string)reader.Value)));
}
if (objectType == typeof(WitKeyId))
{
return(new WitKeyId(Encoders.Hex.DecodeData((string)reader.Value)));
}
if (objectType == typeof(WitScriptId))
{
return(new WitScriptId(Encoders.Hex.DecodeData((string)reader.Value)));
}
}
catch
{
}
throw new JsonObjectException("Invalid signature", reader);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
reader.AssertJsonType(new[] { JsonToken.Integer, JsonToken.Float });
try
{
if (reader.TokenType == JsonToken.Integer)
{
return(new FeeRate(Money.Satoshis((long)reader.Value), 1));
}
if (reader.TokenType == JsonToken.Float)
{
if (reader.Value is decimal v)
{
return(new FeeRate(v));
}
if (reader.Value is double d)
{
return(new FeeRate((decimal)d));
}
return(new FeeRate((decimal)(double)reader.Value));
}
throw new JsonObjectException("Fee rate amount should be in satoshi", reader);
}
catch (InvalidCastException)
{
throw new JsonObjectException("Fee rate should be in satoshi", reader);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
reader.AssertJsonType(JsonToken.String);
try
{
IBitcoinString result = Network.Parse(reader.Value.ToString(), objectType);
if (result == null)
{
throw new JsonObjectException("Invalid BitcoinString network", reader);
}
if (!objectType.GetTypeInfo().IsAssignableFrom(result.GetType().GetTypeInfo()))
{
throw new JsonObjectException("Invalid BitcoinString type expected " + objectType.Name + ", actual " + result.GetType().Name, reader);
}
return(result);
}
catch (FormatException ex)
{
throw new JsonObjectException(ex.Message, reader);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
reader.AssertJsonType(JsonToken.String);
try
{
IBitcoinSerializable obj = null;
var bytes = Encoders.Hex.DecodeData((string)reader.Value);
if (!Network.Consensus.ConsensusFactory.TryCreateNew(objectType, out obj))
{
if (objectType == typeof(PubKey))
{
obj = new PubKey(bytes);
}
else
{
obj = (IBitcoinSerializable)Activator.CreateInstance(objectType);
}
}
obj.ReadWrite(bytes, Network);
return(obj);
}
catch (EndOfStreamException)
{
}
catch (FormatException)
{
}
throw new JsonObjectException("Invalid bitcoin object of type " + objectType.Name, reader);
}
public override ChainName ReadJson(JsonReader reader, Type objectType, ChainName existingValue, bool hasExistingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
reader.AssertJsonType(JsonToken.String);
var v = (string)reader.Value;
if (v.Length == 0)
{
return(null);
}
return(new ChainName(v));
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
try
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
reader.AssertJsonType(JsonToken.String);
return(Encoders.Hex.DecodeData((string)reader.Value));
}
catch
{
throw new JsonObjectException("Invalid hex", reader);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
try
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
reader.AssertJsonType(JsonToken.Integer);
return(new Money((long)reader.Value));
}
catch (InvalidCastException)
{
throw new JsonObjectException("Money amount should be in satoshi", reader);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
reader.AssertJsonType(JsonToken.String);
try
{
var value = reader.Value.ToString();
return(new BitcoinAssetId(value, Network).AssetId);
}
catch (FormatException)
{
throw new JsonObjectException("Invalid BitcoinAssetId ", reader);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
reader.AssertJsonType(JsonToken.String);
try
{
return(PSBT.Parse((string)reader.Value, Network));
}
catch (EndOfStreamException)
{
}
catch (FormatException)
{
}
throw new JsonObjectException("Invalid PSBT", reader);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
reader.AssertJsonType(JsonToken.String);
try
{
return(uint256.Parse((string)reader.Value));
}
catch (EndOfStreamException)
{
}
catch (FormatException)
{
}
throw new JsonObjectException("Invalid bitcoin object of type " + objectType.Name, reader);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.Value == null)
{
return(null);
}
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
reader.AssertJsonType(JsonToken.Integer);
var result = Utils.UnixTimeToDateTime((ulong)(long)reader.Value);
if (objectType == typeof(DateTime))
{
return(result.UtcDateTime);
}
return(result);
}
public override object?ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
reader.AssertJsonType(JsonToken.String);
try
{
if (!OutputDescriptor.TryParse((string)reader.Value, Network, out var od, _requireChecksum, _signingRepository))
{
throw new JsonObjectException("Invalid OutputDescriptor", reader);
}
return(od);
}
catch (FormatException ex)
{
throw new JsonObjectException($"Invalid OutputDescriptor {ex}", reader);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
reader.AssertJsonType(JsonToken.String);
try
{
if (!OutPoint.TryParse((string)reader.Value, out var outpoint))
{
throw new JsonObjectException("Invalid bitcoin object of type OutPoint", reader);
}
return(outpoint);
}
catch (EndOfStreamException)
{
}
throw new JsonObjectException("Invalid bitcoin object of type OutPoint", reader);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
try
{
var nullable = objectType == typeof(LockTime?);
if (reader.TokenType == JsonToken.Null)
{
if (nullable)
{
return(null);
}
return(LockTime.Zero);
}
reader.AssertJsonType(JsonToken.Integer);
return(new LockTime((uint)(long)reader.Value));
}
catch
{
throw new JsonObjectException("Invalid locktime", reader);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
reader.AssertJsonType(JsonToken.String);
try
{
if (objectType == typeof(Script))
{
return(Script.FromBytesUnsafe(Encoders.Hex.DecodeData((string)reader.Value)));
}
if (objectType == typeof(WitScript))
{
return(new WitScript(Encoders.Hex.DecodeData((string)reader.Value)));
}
}
catch (FormatException)
{
}
throw new JsonObjectException("A script should be a byte string", reader);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
reader.AssertJsonType(JsonToken.String);
if (typeof(KeyPath).GetTypeInfo().IsAssignableFrom(objectType.GetTypeInfo()))
{
if (KeyPath.TryParse(reader.Value.ToString(), out var k))
{
return(k);
}
throw new JsonObjectException("Invalid key path", reader);
}
else
{
if (RootedKeyPath.TryParse(reader.Value.ToString(), out var k))
{
return(k);
}
throw new JsonObjectException("Invalid rooted key path", reader);
}
}
