private void SetString(string psz)
{
if (_Network == null)
{
_Network = Network.GetNetworkFromBase58Data(psz, Type);
if (_Network == null)
{
throw new FormatException("Invalid " + this.GetType().Name);
}
}
byte[] vchTemp = Encoders.Base58Check.DecodeData(psz);
var expectedVersion = _Network.GetVersionBytes(Type, true);
vchVersion = vchTemp.SafeSubarray(0, expectedVersion.Length);
if (!Utils.ArrayEqual(vchVersion, expectedVersion))
{
throw new FormatException("The version prefix does not match the expected one " + String.Join(",", expectedVersion));
}
vchData = vchTemp.SafeSubarray(expectedVersion.Length);
wifData = psz;
if (!IsValid)
{
throw new FormatException("Invalid " + this.GetType().Name);
}
}
public static BitcoinEncryptedSecret Create(string wif, Network network)
{
var raw = Encoders.Base58Check.DecodeData(wif);
var version = raw.Take(2).ToArray();
if (Utils.ArrayEqual(version, network.GetVersionBytes(Base58Type.ENCRYPTED_SECRET_KEY_NO_EC)))
{
return(new BitcoinEncryptedSecretNoEC(wif, network));
}
if (Utils.ArrayEqual(version, network.GetVersionBytes(Base58Type.ENCRYPTED_SECRET_KEY_EC)))
{
return(new BitcoinEncryptedSecretEC(wif, network));
}
throw new FormatException("Invalid encrypted secret");
}
public BitcoinScriptAddress(string base58, Network expectedNetwork)
: base(Validate(base58, ref expectedNetwork), expectedNetwork)
{
var decoded = Encoders.Base58Check.DecodeData(base58);
_Hash = new ScriptId(new uint160(decoded.Skip(expectedNetwork.GetVersionBytes(Base58Type.SCRIPT_ADDRESS, true).Length).ToArray()));
}
public static string GetWrappedBase58(string base58, Network network)
{
byte[] coloredVersion = network.GetVersionBytes(Base58Type.COLORED_ADDRESS, true);
byte[] inner = Encoders.Base58Check.DecodeData(base58);
inner = inner.Skip(coloredVersion.Length).ToArray();
return(Encoders.Base58Check.EncodeData(inner));
}
public static T ToNetwork <T>(this T base58, Network network) where T : Base58Data
{
if (network == null)
{
throw new ArgumentNullException("network");
}
if (base58.Network == network)
{
return(base58);
}
if (base58 == null)
{
throw new ArgumentNullException("base58");
}
var inner = base58.ToBytes();
if (base58.Type != Base58Type.COLORED_ADDRESS)
{
byte[] version = network.GetVersionBytes(base58.Type);
var newBase58 = Encoders.Base58Check.EncodeData(version.Concat(inner).ToArray());
return(Network.CreateFromBase58Data <T>(newBase58, network));
}
else
{
var colored = BitcoinColoredAddress.GetWrappedBase58(base58.ToWif(), base58.Network);
var address = Network.CreateFromBase58Data <BitcoinAddress>(colored).ToNetwork(network);
return((T)(object)address.ToColoredAddress());
}
}
private static string GenerateWif(string passphrase, Network network, LotSequence lotsequence, byte[] ownersalt)
{
bool hasLotSequence = lotsequence != null;
//ownersalt is 8 random bytes
ownersalt = ownersalt ?? RandomUtils.GetBytes(8);
var ownerEntropy = ownersalt;
if (hasLotSequence)
{
ownersalt = ownersalt.Take(4).ToArray();
ownerEntropy = ownersalt.Concat(lotsequence.ToBytes()).ToArray();
}
var prefactor = SCrypt.BitcoinComputeDerivedKey(Encoding.UTF8.GetBytes(passphrase), ownersalt, 32);
var passfactor = prefactor;
if (hasLotSequence)
{
passfactor = Hashes.Hash256(prefactor.Concat(ownerEntropy).ToArray()).ToBytes();
}
var passpoint = new Key(passfactor, fCompressedIn: true).PubKey.ToBytes();
var bytes =
network.GetVersionBytes(Base58Type.PASSPHRASE_CODE)
.Concat(new[] { hasLotSequence ? (byte)0x51 : (byte)0x53 })
.Concat(ownerEntropy)
.Concat(passpoint)
.ToArray();
return(Encoders.Base58Check.EncodeData(bytes));
}
public BitcoinPubKeyAddress(string base58, Network expectedNetwork = null)
: base(Validate(base58, ref expectedNetwork), expectedNetwork)
{
var decoded = (expectedNetwork == null ? Encoders.Base58Check : expectedNetwork.NetworkStringParser.GetBase58CheckEncoder()).DecodeData(base58);
_KeyId = new KeyId(new uint160(decoded.Skip(expectedNetwork.GetVersionBytes(Base58Type.PUBKEY_ADDRESS, true).Length).ToArray()));
}
private static string GenerateWif(Key key, string password, Network network)
{
byte[] vch = key.ToBytes();
//Compute the Bitcoin address (ASCII),
byte[] addressBytes = Encoders.ASCII.DecodeData(key.PubKey.GetAddress(network).ToString());
// and take the first four bytes of SHA256(SHA256()) of it. Let's call this "addresshash".
byte[] addresshash = Hashes.Hash256(addressBytes).ToBytes().SafeSubarray(0, 4);
byte[] derived = SCrypt.BitcoinComputeDerivedKey(Encoding.UTF8.GetBytes(password), addresshash);
byte[] encrypted = EncryptKey(vch, derived);
byte[] version = network.GetVersionBytes(Base58Type.ENCRYPTED_SECRET_KEY_NO_EC, true);
byte flagByte = 0;
flagByte |= 0x0C0;
flagByte |= (key.IsCompressed ? (byte)0x20 : (byte)0x00);
byte[] bytes = version
.Concat(new[] { flagByte })
.Concat(addresshash)
.Concat(encrypted).ToArray();
return(Encoders.Base58Check.EncodeData(bytes));
}
public static string GetWrappedBase58(string base58, Network network)
{
var coloredVersion = network.GetVersionBytes(Base58Type.COLORED_ADDRESS, true);
var inner = network.NetworkStringParser.GetBase58CheckEncoder().DecodeData(base58);
inner = inner.Skip(coloredVersion.Length).ToArray();
return(network.NetworkStringParser.GetBase58CheckEncoder().EncodeData(inner));
}
public BitcoinPubKeyAddress(string base58, Network expectedNetwork)
: base(Validate(base58, expectedNetwork), expectedNetwork)
{
var decoded = Encoders.Base58Check.DecodeData(base58);
this.Hash = new KeyId(new uint160(decoded
.Skip(expectedNetwork.GetVersionBytes(Base58Type.PUBKEY_ADDRESS, true).Length).ToArray()));
}
internal static string CreateBase58(Base58Type type, byte[] bytes, Network network)
{
if (network == null)
throw new ArgumentNullException("network");
if (bytes == null)
throw new ArgumentNullException("bytes");
byte[] versionBytes = network.GetVersionBytes(type, true);
return Encoders.Base58Check.EncodeData(versionBytes.Concat(bytes));
}
public BitcoinBlindedAddress(PubKey blindingKey, TxDestination keyId, Network network)
: base(NotNull(keyId, nameof(keyId)) ??
NotNull(blindingKey, nameof(blindingKey)) ??
Network.CreateBase58(Base58Type.BLINDED_ADDRESS,
network.GetVersionBytes(((IBase58Data)keyId.GetAddress(network)).Type, true)
.Concat(blindingKey.ToBytes())
.Concat(keyId.ToBytes()), network), network)
{
_BlindingKey = blindingKey;
_Hash = keyId;
}
private void SetString(string psz)
{
byte[] vchTemp = Encoders.Base58Check.DecodeData(psz);
var expectedVersion = _Network.GetVersionBytes(Type);
vchVersion = vchTemp.Take((int)expectedVersion.Length).ToArray();
if (!Utils.ArrayEqual(vchVersion, expectedVersion))
{
throw new FormatException("The version prefix does not match the expected one " + String.Join(",", expectedVersion));
}
vchData = vchTemp.Skip((int)expectedVersion.Length).ToArray();
wifData = psz;
if (!IsValid)
{
throw new FormatException("Invalid " + this.GetType().Name);
}
}
private void SetData(byte[] vchData)
{
this.vchData = vchData;
vchVersion = Network.GetVersionBytes(Type, true);
wifData = Network.NetworkStringParser.GetBase58CheckEncoder().EncodeData(vchVersion.Concat(vchData).ToArray());
if (!IsValid)
{
throw new FormatException("Invalid " + GetType().Name);
}
}
public BitcoinPubKeyAddress(string base58, Network expectedNetwork)
: base(Validate(base58, ref expectedNetwork), expectedNetwork)
{
bool fValid = IsValid(base58, ref expectedNetwork);
if (!fValid)
{
throw new Exception("BBP Address is invalid");
}
byte[] decoded = Encoders.Base58Check.DecodeData(base58);
this._KeyId = new KeyId(new uint160(decoded.Skip(expectedNetwork.GetVersionBytes(Base58Type.PUBKEY_ADDRESS, true).Length).ToArray()));
}
private void SetString <T>(string psz) where T : Base58Data
{
if (_Network == null)
{
_Network = Network.GetNetworkFromBase58Data(psz, Type);
if (_Network == null)
{
throw new FormatException("Invalid " + this.GetType().Name);
}
}
byte[] vchTemp = _Network.NetworkStringParser.GetBase58CheckEncoder().DecodeData(psz);
var expectedVersion = _Network.GetVersionBytes(Type, true);
vchVersion = vchTemp.SafeSubarray(0, expectedVersion.Length);
if (!Utils.ArrayEqual(vchVersion, expectedVersion))
{
if (_Network.NetworkStringParser.TryParse(psz, Network, out T other))
{
this.vchVersion = other.vchVersion;
this.vchData = other.vchData;
this.wifData = other.wifData;
}
else
{
throw new FormatException("The version prefix does not match the expected one " + String.Join(",", expectedVersion));
}
}
else
{
vchData = vchTemp.SafeSubarray(expectedVersion.Length);
wifData = psz;
}
if (!IsValid)
{
throw new FormatException("Invalid " + this.GetType().Name);
}
}
public BitcoinPubKeyAddress(string base58, Network expectedNetwork)
: base(Validate(base58, expectedNetwork), expectedNetwork)
{
var decoded = expectedNetwork.NetworkStringParser.GetBase58CheckEncoder().DecodeData(base58);
if (expectedNetwork.GetVersionBytes(Base58Type.PUBKEY_ADDRESS, false) is byte[] bytes)
{
_KeyId = new KeyId(new uint160(decoded.Skip(bytes.Length).ToArray()));
}
else
{
throw expectedNetwork.Base58NotSupported(Base58Type.PUBKEY_ADDRESS);
}
}
internal static string CreateBase58(Base58Type type, byte[] bytes, Network network)
{
if (network == null)
{
throw new ArgumentNullException(nameof(network));
}
if (bytes == null)
{
throw new ArgumentNullException(nameof(bytes));
}
var versionBytes = network.GetVersionBytes(type, true);
return(network.NetworkStringParser.GetBase58CheckEncoder().EncodeData(versionBytes.Concat(bytes)));
}
public BitcoinScriptAddress(string base58, Network expectedNetwork)
: base(Validate(base58, expectedNetwork), expectedNetwork)
{
var decoded = expectedNetwork.NetworkStringParser.GetBase58CheckEncoder().DecodeData(base58);
if (expectedNetwork.GetVersionBytes(Base58Type.SCRIPT_ADDRESS, false) is byte[] v)
{
_Hash = new ScriptId(new uint160(decoded.Skip(v.Length).ToArray()));
}
else
{
throw expectedNetwork.Base58NotSupported(Base58Type.SCRIPT_ADDRESS);
}
}
public static T ToNetwork <T>(this T obj, Network network) where T : IBitcoinString
{
if (network == null)
{
throw new ArgumentNullException(nameof(network));
}
if (obj == null)
{
throw new ArgumentNullException(nameof(obj));
}
if (obj.Network == network)
{
return(obj);
}
if (obj is IBase58Data)
{
var b58 = (IBase58Data)obj;
if (b58.Type != Base58Type.COLORED_ADDRESS)
{
byte[] version = network.GetVersionBytes(b58.Type, true);
var enc = network.NetworkStringParser.GetBase58CheckEncoder();
var inner = enc.DecodeData(b58.ToString()).Skip(version.Length).ToArray();
var newBase58 = enc.EncodeData(version.Concat(inner).ToArray());
return(Network.Parse <T>(newBase58, network));
}
else
{
var colored = BitcoinColoredAddress.GetWrappedBase58(obj.ToString(), obj.Network);
var address = Network.Parse <BitcoinAddress>(colored, obj.Network).ToNetwork(network);
return((T)(object)address.ToColoredAddress());
}
}
else if (obj is IBech32Data)
{
var b32 = (IBech32Data)obj;
var encoder = b32.Network.GetBech32Encoder(b32.Type, true);
byte wit;
var data = encoder.Decode(b32.ToString(), out wit);
encoder = network.GetBech32Encoder(b32.Type, true);
var str = encoder.Encode(wit, data);
return((T)(object)Network.Parse <T>(str, network));
}
else
{
throw new NotSupportedException();
}
}
public static bool IsValid(string base58, Network expectedNetwork)
{
if (base58 == null)
{
throw new ArgumentNullException("base58");
}
byte[] data = Encoders.Base58Check.DecodeData(base58);
byte[] versionBytes = expectedNetwork.GetVersionBytes(Base58Type.PUBKEY_ADDRESS, false);
if (versionBytes != null && data.StartWith(versionBytes))
{
if (data.Length == versionBytes.Length + 20)
{
return(true);
}
}
return(false);
}
private static string Validate(string base58, Network expectedNetwork)
{
if (base58 == null)
{
throw new ArgumentNullException(nameof(base58));
}
if (expectedNetwork == null)
{
throw new ArgumentNullException(nameof(expectedNetwork));
}
var data = expectedNetwork.NetworkStringParser.GetBase58CheckEncoder().DecodeData(base58);
var versionBytes = expectedNetwork.GetVersionBytes(Base58Type.SCRIPT_ADDRESS, false);
if (versionBytes != null && data.StartWith(versionBytes))
{
if (data.Length == versionBytes.Length + 20)
{
return(base58);
}
}
throw new FormatException("Invalid BitcoinScriptAddress");
}
public static T ToNetwork <T>(this T obj, Network network) where T : IBitcoinString
{
if (network == null)
{
throw new ArgumentNullException("network");
}
if (obj == null)
{
throw new ArgumentNullException("obj");
}
if (obj.Network == network)
{
return(obj);
}
if (obj is IBase58Data)
{
var b58 = (IBase58Data)obj;
byte[] version = network.GetVersionBytes(b58.Type, true);
byte[] inner = Encoders.Base58Check.DecodeData(b58.ToString()).Skip(version.Length).ToArray();
string newBase58 = Encoders.Base58Check.EncodeData(version.Concat(inner).ToArray());
return(Network.Parse <T>(newBase58, network));
}
else if (obj is IBech32Data)
{
var b32 = (IBech32Data)obj;
Bech32Encoder encoder = b32.Network.GetBech32Encoder(b32.Type, true);
byte wit;
byte[] data = encoder.Decode(b32.ToString(), out wit);
encoder = network.GetBech32Encoder(b32.Type, true);
string str = encoder.Encode(wit, data);
return((T)(object)Network.Parse <T>(str, network));
}
else
{
throw new NotSupportedException();
}
}
public EncryptedKeyResult GenerateEncryptedSecret(bool isCompressed = true, byte[] seedb = null)
{
//Set flagbyte.
byte flagByte = 0;
//Turn on bit 0x20 if the Bitcoin address will be formed by hashing the compressed public key
flagByte |= isCompressed ? (byte)0x20 : (byte)0x00;
flagByte |= LotSequence != null ? (byte)0x04 : (byte)0x00;
//Generate 24 random bytes, call this seedb. Take SHA256(SHA256(seedb)) to yield 32 bytes, call this factorb.
seedb = seedb ?? RandomUtils.GetBytes(24);
var factorb = Hashes.Hash256(seedb).ToBytes();
//ECMultiply passpoint by factorb.
var curve = ECKey.CreateCurve();
var passpoint = curve.Curve.DecodePoint(Passpoint);
var pubPoint = passpoint.Multiply(new BigInteger(1, factorb));
//Use the resulting EC point as a public key
var pubKey = new PubKey(pubPoint.GetEncoded());
//and hash it into a Bitcoin address using either compressed or uncompressed public key
//This is the generated Bitcoin address, call it generatedaddress.
pubKey = isCompressed ? pubKey.Compress() : pubKey.Decompress();
//call it generatedaddress.
var generatedaddress = pubKey.GetAddress(Network);
//Take the first four bytes of SHA256(SHA256(generatedaddress)) and call it addresshash.
var addresshash = BitcoinEncryptedSecretEC.HashAddress(generatedaddress);
//Derive a second key from passpoint using scrypt
//salt is addresshash + ownerentropy
var derived = BitcoinEncryptedSecretEC.CalculateDecryptionKey(Passpoint, addresshash, OwnerEntropy);
//Now we will encrypt seedb.
var encrypted = BitcoinEncryptedSecret.EncryptSeed
(seedb,
derived);
//0x01 0x43 + flagbyte + addresshash + ownerentropy + encryptedpart1[0...7] + encryptedpart2 which totals 39 bytes
var bytes =
new[] { flagByte }
.Concat(addresshash)
.Concat(this.OwnerEntropy)
.Concat(encrypted.Take(8).ToArray())
.Concat(encrypted.Skip(16).ToArray())
.ToArray();
var encryptedSecret = new BitcoinEncryptedSecretEC(bytes, Network);
return(new EncryptedKeyResult(encryptedSecret, generatedaddress, seedb, () =>
{
//ECMultiply factorb by G, call the result pointb. The result is 33 bytes.
var pointb = new Key(factorb).PubKey.ToBytes();
//The first byte is 0x02 or 0x03. XOR it by (derivedhalf2[31] & 0x01), call the resulting byte pointbprefix.
var pointbprefix = (byte)(pointb[0] ^ (byte)(derived[63] & 0x01));
var pointbx = BitcoinEncryptedSecret.EncryptKey(pointb.Skip(1).ToArray(), derived);
var encryptedpointb = new byte[] { pointbprefix }.Concat(pointbx).ToArray();
var confirmBytes =
Network.GetVersionBytes(Base58Type.CONFIRMATION_CODE)
.Concat(new[] { flagByte })
.Concat(addresshash)
.Concat(OwnerEntropy)
.Concat(encryptedpointb)
.ToArray();
return new BitcoinConfirmationCode(Encoders.Base58Check.EncodeData(confirmBytes), Network);
}));
}
private void SetString <T>(string psz) where T : Base58Data
{
if (_Network == null)
{
_Network = Network.GetNetworkFromBase58Data(psz, Type);
if (_Network == null)
{
throw new FormatException("Invalid " + this.GetType().Name);
}
}
byte[] vchTemp = _Network.NetworkStringParser.GetBase58CheckEncoder().DecodeData(psz);
#if HAS_SPAN
if (!(_Network.GetVersionMemory(Type, false) is ReadOnlyMemory <byte> expectedVersion))
{
throw new FormatException("Invalid " + this.GetType().Name);
}
#else
var expectedVersion = _Network.GetVersionBytes(Type, false);
if (expectedVersion is null)
{
throw new FormatException("Invalid " + this.GetType().Name);
}
#endif
#if HAS_SPAN
var vchTempMemory = vchTemp.AsMemory();
vchVersion = vchTempMemory.Slice(0, expectedVersion.Length);
#else
vchVersion = vchTemp.SafeSubarray(0, expectedVersion.Length);
#endif
#if HAS_SPAN
if (!vchVersion.Span.SequenceEqual(expectedVersion.Span))
#else
if (!Utils.ArrayEqual(vchVersion, expectedVersion))
#endif
{
if (_Network.NetworkStringParser.TryParse(psz, Network, out T other))
{
this.vchVersion = other.vchVersion;
this.vchData = other.vchData;
this.wifData = other.wifData;
}
else
{
#if HAS_SPAN
var expectedVersionHexString = Encoders.Hex.EncodeData(expectedVersion.Span);
#else
var expectedVersionHexString = Encoders.Hex.EncodeData(expectedVersion);
#endif
throw new FormatException($"The version prefix does not match the expected one 0x{expectedVersionHexString}");
}
}
else
{
#if HAS_SPAN
vchData = vchTempMemory.Slice(expectedVersion.Length).ToArray();
#else
vchData = vchTemp.SafeSubarray(expectedVersion.Length);
#endif
wifData = psz;
}
if (!IsValid)
{
throw new FormatException("Invalid " + this.GetType().Name);
}
}
