public void Validate(string address)
{
if (string.IsNullOrEmpty(address))
{
AddError(nameof(address), "Address can not be empty!");
return;
}
if (!address.StartsWith("F") && !address.StartsWith("3") && !address.StartsWith("grs1"))
{
AddError(nameof(address), "Address must start with F or 3!");
return;
}
if (address.StartsWith("grs1"))
{
var errors = Bech32.Verify(address, NetworkType.Mainnet);
if (errors.Any())
{
foreach (var error in errors)
{
AddError(nameof(address), error);
}
return;
}
}
else
{
try {
Groestlcoin.GroestlEncoder.Instance.DecodeData(address);
}
catch (Exception e) {
AddError(nameof(address), e.Message);
}
}
}
public void Validate(string address)
{
if (string.IsNullOrEmpty(address))
{
AddError(nameof(address), "Address can not be empty!");
}
else if (address.StartsWith("1") || address.StartsWith("3"))
{
Base58 b58enc = new Base58();
if (b58enc.IsValid(address))
{
RemoveError(nameof(address), "");
}
else
{
AddError(nameof(address), "Invalid Base58 encoded address!");
}
}
else if (address.StartsWith("bc"))
{
Bech32 b32enc = new Bech32();
if (b32enc.IsValid(address))
{
RemoveError(nameof(address), "");
}
else
{
AddError(nameof(address), "Invalid Bech32 encoded address!");
}
}
else
{
AddError(nameof(address), "Invalid address format!");
}
}
public Rep <Transaction.Transaction> GetTransaction32(string hash)
{
Rep <Transaction.Transaction> rep = GetTransaction(hash);
rep.Result.ToAddr = Bech32.ToBech32Address(rep.Result.ToAddr);
return(rep);
}
public void TestValidChecksum()
{
foreach (var t in ValidCheckSum)
{
Bech32.Decode(t);
}
}
public void TestInvalidChecksum()
{
foreach (var(t, i) in InvalidChecksum.Select((value, i) => (value, i)))
{
Console.WriteLine($"i: {i}");
Assert.Throws <Exception>(() => Bech32.Decode(t));
}
}
public void DecodeTest(byte[] expBa, Bech32.Mode mode, byte expWitVer, string expHrp, string bechStr)
{
byte[] actualBa = Bech32.Decode(bechStr, mode, out byte actualWitVer, out string actualHrp);
Assert.Equal(expBa, actualBa);
Assert.Equal(expWitVer, actualWitVer);
Assert.Equal(expHrp, actualHrp);
}
/// <summary>
/// Converts the special bech-32 encoded private key back to its byte array representation.
/// </summary>
/// <param name="bech">Special bech-32 encoded private key</param>
/// <param name="scrT">Corresponding script type</param>
/// <param name="hrp">Human readable part</param>
/// <param name="creationDate">The time this key was created (can help speed up re-scanning)</param>
/// <returns>Private key as an array of bytes</returns>
public byte[] Decode(string bech, out ScriptType scrT, out string hrp, out DateTime creationDate)
{
var data = Bech32.Decode(bech, Bech32.Mode.B32m, out byte ver, out hrp);
scrT = (ScriptType)ver;
creationDate = UnixTimeStamp.EpochToTime(data[32] |
(long)data[33] << 8 |
(long)data[34] << 16 |
(long)data[35] << 24 |
(long)data[36] << 32);
return(data.SubArray(0, 32));
}
public Address(ScriptPubKey scriptPubKey, TxnType txnType)
{
byte[] pushData = Script.FromScriptPubKey(scriptPubKey, txnType);
List <byte> hash;
byte prefix = 0x00;
switch (txnType)
{
case TxnType.P2SH:
hash = new List <byte>(pushData);
prefix = (byte)Prefix.TestnetP2SH;
break;
case TxnType.P2WPKH:
hash = new List <byte>(pushData);
break;
case TxnType.P2WSH:
hash = new List <byte>(pushData);
break;
case TxnType.P2PKH:
hash = new List <byte>(pushData);
prefix = (byte)Prefix.TestnetP2PKH;
break;
case TxnType.P2PK:
hash = Crypto.DoubleHash(pushData);
prefix = (byte)Prefix.TestnetP2PKH;
break;
default:
hash = null;
break;
}
if (hash != null)
{
if (txnType == TxnType.P2WPKH || txnType == TxnType.P2WSH)
{
address = Bech32.Encode(0, hash.ToArray(), false);
}
else
{
hash.Insert(0, prefix);
Crypto.AddChecksum(ref hash);
address = Base58Check.Encode(hash.ToArray());
}
}
}
public AddressType GetAddressType(string address)
{
if (string.IsNullOrWhiteSpace(address))
{
return(AddressType.Invalid);
}
try
{
byte[] decoded = Base58.DecodeWithChecksum(address);
if (decoded.Length == Hash160.HashByteSize + 1)
{
if (decoded[0] == versionByte_P2pkh_MainNet ||
decoded[0] == versionByte_P2pkh_TestNet ||
decoded[0] == versionByte_P2pkh_RegTest)
{
return(AddressType.P2PKH);
}
else if (decoded[0] == versionByte_P2sh_MainNet ||
decoded[0] == versionByte_P2sh_TestNet ||
decoded[0] == versionByte_P2sh_RegTest)
{
return(AddressType.P2SH);
}
}
return(AddressType.Invalid);
}
catch (Exception) { }
try
{
byte[] decoded = Bech32.Decode(address, Bech32.Mode.B32, out byte witVer, out string hrp);
if (witVer == 0 &&
hrp == hrp_MainNet || hrp == hrp_TestNet || hrp == hrp_RegTest)
{
if (decoded.Length == Hash160.HashByteSize)
{
return(AddressType.P2WPKH);
}
else if (decoded.Length == witHashFunc.BlockByteSize)
{
return(AddressType.P2WSH);
}
}
}
catch (Exception) { }
return(AddressType.Invalid);
}
public string Recover(string message, byte[] signature, bool preFixed)
{
var bytes = Encoding.ASCII.GetBytes(message);
if (!preFixed)
{
bytes = this.HashMessage(bytes);
}
var ecdaSignature = EthECDSASignatureFactory.ExtractECDSASignature(signature.ToHex());
return(Bech32.Encode("io",
Hash.Hash160B(EthECKey.RecoverFromSignature(ecdaSignature, bytes).GetPubKey().Slice(1))));
}
public static string Bech32ToBase16Address(string address)
{
var res = "0x";
bool lower = false, upper = false;
Bech32 data = Decode(address);
for (int i = 0; i < address.Length; ++i)
{
char c = address.ToCharArray()[i];
if (c < 33 || c > 126)
{
throw new ArgumentException($"Invalid character {c}");
}
if (c >= 'a' && c <= 'z')
{
if (upper)
{
throw new ArgumentException($"Invalid character {c}");
}
lower = true;
}
if (c >= 'A' && c <= 'Z')
{
if (lower)
{
throw new ArgumentException($"Invalid character {c}");
}
upper = true;
}
}
if (data.hrp != HRP)
{
throw new Exception("Expected hrp to be zil");
}
List <int> bits = ByteUtil.ConvertBits(data.data, 5, 8, false);
byte[] buf = new byte[bits.Count];
for (int i = 0; i < bits.Count; i++)
{
buf[i] = BitConverter.GetBytes(bits[i])[0];
}
if (null == buf || buf.Length == 0)
{
throw new Exception("Could not convert buffer to bytes");
}
res += ByteUtil.ByteArrayToHexString(buf);
return(res);
}
public static string NormaliseAddress(string address)
{
if (Validation.IsBech32(address))
{
return(Bech32.FromBech32Address(address));
}
if (Validation.IsValidChecksumAddress(address))
{
return(ToCheckSumAddress(address).Substring(2));
}
throw new Exception("Address format is invalid");
}
public void FromBech32AddressTest()
{
string address = Bech32.FromBech32Address("zil1n0lvw9dxh4jcljmzkruvexl69t08zs62ds9ats");
Assert.AreEqual(address.ToLower(), "9bfec715a6bd658fcb62b0f8cc9bfa2ade71434a");
Assert.AreEqual(Bech32.FromBech32Address("zil1fwh4ltdguhde9s7nysnp33d5wye6uqpugufkz7").ToUpper(), "4BAF5FADA8E5DB92C3D3242618C5B47133AE003C");
Assert.AreEqual(Bech32.FromBech32Address("zil1gjpxry26srx7n008c7nez6zjqrf6p06wur4x3m").ToUpper(), "448261915A80CDE9BDE7C7A791685200D3A0BF4E");
Assert.AreEqual(Bech32.FromBech32Address("zil1mmgzlktelsh9tspy80f02t0sytzq4ks79zdnkk").ToUpper(), "DED02FD979FC2E55C0243BD2F52DF022C40ADA1E");
Assert.AreEqual(Bech32.FromBech32Address("zil1z0cxucpf004x50zq9ahkf3qk56e3ukrwaty4g8").ToUpper(), "13F06E60297BEA6A3C402F6F64C416A6B31E586E");
Assert.AreEqual(Bech32.FromBech32Address("zil1r2gvy5c8c0x8r9v2s0azzw3rvtv9nnenynd33g").ToUpper(), "1A90C25307C3CC71958A83FA213A2362D859CF33");
Assert.AreEqual(Bech32.FromBech32Address("zil1vfdt467c0khf4vfg7we6axtg3qfan3wlf9yc6y").ToUpper(), "625ABAEBD87DAE9AB128F3B3AE99688813D9C5DF");
Assert.AreEqual(Bech32.FromBech32Address("zil1x6argztlscger3yvswwfkx5ttyf0tq703v7fre").ToUpper(), "36BA34097F861191C48C839C9B1A8B5912F583CF");
Assert.AreEqual(Bech32.FromBech32Address("zil16fzn4emvn2r24e2yljnfnk7ut3tk4me6qx08ed").ToUpper(), "D2453AE76C9A86AAE544FCA699DBDC5C576AEF3A");
Assert.AreEqual(Bech32.FromBech32Address("zil1wg3qapy50smprrxmckqy2n065wu33nvh35dn0v").ToUpper(), "72220E84947C36118CDBC580454DFAA3B918CD97");
Assert.AreEqual(Bech32.FromBech32Address("zil12rujxpxgjtv55wzu5m8xe454pn56x6pedpl554").ToUpper(), "50F92304C892D94A385CA6CE6CD6950CE9A36839");
}
public void Decode_ExceptionTests(string bech, Bech32.Mode mode, byte expWitVer, string expHrp, string expErr)
{
byte actWitVer = 255;
string actHrp = ".";
Exception ex = Assert.Throws <FormatException>(() => Bech32.Decode(bech, mode, out actWitVer, out actHrp));
Assert.Equal(expWitVer, actWitVer);
Assert.Equal(expHrp, actHrp);
Assert.Contains(expErr, ex.Message);
bool b = Bech32.TryDecode(bech, mode, out byte[] result, out actWitVer, out actHrp);
Assert.False(b);
Assert.Null(result);
Assert.Equal(0, actWitVer);
}
public Address()
{
b58Encoder = new Base58();
b32Encoder = new Bech32();
hashFunc = new Ripemd160Sha256() /*coin.AddressHashFunction*/;
witHashFunc = new Sha256(); // TODO: set this from ICoin
versionByte_P2pkh_MainNet = 0;
versionByte_P2pkh_TestNet = 111;
versionByte_P2pkh_RegTest = 0;
versionByte_P2sh_MainNet = 5;
versionByte_P2sh_TestNet = 196;
versionByte_P2sh_RegTest = 5;
hrp_MainNet = "bc";
hrp_TestNet = "tb";
hrp_RegTest = "bcrt";
}
/// <summary>
/// Converts the given private key WIF to a special bech-32 encoded string with script type, time and a checksum.
/// </summary>
/// <param name="wif">Wallet import format</param>
/// <param name="scrT">Corresponding script type</param>
/// <param name="creationDate"></param>
/// <param name="netType">The time this key was created (can help speed up re-scanning)</param>
/// <param name="hrp">Human readable part</param>
/// <returns>A special bech-32 encoded private key</returns>
public string Encode(string wif, ScriptType scrT, DateTime creationDate,
NetworkType netType = NetworkType.MainNet, string hrp = "bprv")
{
using PrivateKey key = new PrivateKey(wif, netType);
byte[] data = new byte[32 + 5];
Buffer.BlockCopy(key.ToBytes(), 0, data, 0, 32);
long val = UnixTimeStamp.TimeToEpoch(creationDate);
data[32] = (byte)val;
data[33] = (byte)(val >> 8);
data[34] = (byte)(val >> 16);
data[35] = (byte)(val >> 24);
data[36] = (byte)(val >> 32);
return(Bech32.Encode(data, Bech32.Mode.B32m, (byte)scrT, hrp));
}
public Bech32Address(string addr)
{
var data = Bech32.Decode(addr);
WitnessVersion = data.Item2[0];
Hrp = data.Item1;
//Decoded bytes contains version byte, remove this
var pg = new byte[data.Item2.Length - 1];
Array.Copy(data.Item2, 1, pg, 0, pg.Length);
//convert back to witness program
WitnessProgram = ConvertBits(pg, 5, 8, false);
Network = GetNetworkFromHrp(Hrp);
ValidateAddress();
}
public Address()
{
b58Encoder = new Base58();
b32Encoder = new Bech32();
hashFunc = new Ripemd160Sha256();
witHashFunc = new Sha256();
versionByte_P2pkh_MainNet = 0;
versionByte_P2pkh_TestNet = 111;
versionByte_P2pkh_RegTest = 0;
versionByte_P2sh_MainNet = 5;
versionByte_P2sh_TestNet = 196;
versionByte_P2sh_RegTest = 5;
hrp_MainNet = "bc";
hrp_TestNet = "tb";
hrp_RegTest = "bcrt";
}
public void Bech32_Parse()
{
//from BIP 0173
var main_p2wpkh = "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4";
var test_p2wpkh = "tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx";
var main_p2wsh = "bc1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3qccfmv3";
var test_p2wsh = "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7";
//check for exceptions
Bech32.Decode(main_p2wpkh);
Bech32.Decode(test_p2wpkh);
Bech32.Decode(main_p2wsh);
Bech32.Decode(test_p2wsh);
//verify checksum fails ↓ this 'a' is supposed to be 'r'
var check_fail = "bc1qw508d6qejxtdg4y5r3aarvary0c5xw7kv8f3t4";
Assert.ThrowsAny <Exception>(() => Bech32.Decode(check_fail));
}
public Transaction.Transaction Sign(Transaction.Transaction transaction)
{
if (transaction.ToAddr.ToUpper().StartsWith("0X"))
{
transaction.ToAddr = transaction.ToAddr.Substring(2);
}
if (!Validation.IsBech32(transaction.ToAddr) && !Validation.IsValidChecksumAddress("0x" + transaction.ToAddr))
{
throw new Exception("not checksum address or bech32");
}
if (Validation.IsBech32(transaction.ToAddr))
{
transaction.ToAddr = Bech32.FromBech32Address(transaction.ToAddr);
}
if (Validation.IsValidChecksumAddress("0x" + transaction.ToAddr))
{
transaction.ToAddr = "0x" + transaction.ToAddr;
}
TxParams txParams = transaction.ToTransactionParam();
if (txParams != null && !string.IsNullOrEmpty(txParams.SenderPubKey))
{
string address = KeyTools.GetAddressFromPublicKey(txParams.SenderPubKey).ToUpper();
Account account = accounts[address];
if (account == null)
{
throw new Exception("Could not sign the transaction with" + address + " as it does not exist");
}
return(SignWith(transaction, account));
}
if (defaultAccount == null)
{
throw new Exception("This wallet has no default account.");
}
return(this.SignWith(transaction, this.defaultAccount));
}
public void IsValid_Fail_SpecialCaseTest()
{
// HRP has an out of range character
Assert.False(Bech32.IsValid($"{(char)0x20}1nwldj5", Bech32.Mode.B32));
Assert.False(Bech32.IsValid($"{(char)0x20}1nwldj5", Bech32.Mode.B32m));
Assert.False(Bech32.IsValid($"{(char)0x20}1xj0phk", Bech32.Mode.B32));
Assert.False(Bech32.IsValid($"{(char)0x20}1xj0phk", Bech32.Mode.B32m));
Assert.False(Bech32.IsValid($"{(char)0x7F}1axkwrx", Bech32.Mode.B32));
Assert.False(Bech32.IsValid($"{(char)0x7F}1axkwrx", Bech32.Mode.B32m));
Assert.False(Bech32.IsValid($"{(char)0x7F}1g6xzxy", Bech32.Mode.B32));
Assert.False(Bech32.IsValid($"{(char)0x7F}1g6xzxy", Bech32.Mode.B32m));
Assert.False(Bech32.IsValid($"{(char)0x80}1eym55h", Bech32.Mode.B32));
Assert.False(Bech32.IsValid($"{(char)0x80}1eym55h", Bech32.Mode.B32m));
Assert.False(Bech32.IsValid($"{(char)0x80}1vctc34", Bech32.Mode.B32));
Assert.False(Bech32.IsValid($"{(char)0x80}1vctc34", Bech32.Mode.B32m));
// Invalid character in checksum
Assert.False(Bech32.IsValid($"de1lg7wt{(char)0xFF}", Bech32.Mode.B32));
Assert.False(Bech32.IsValid($"de1lg7wt{(char)0xFF}", Bech32.Mode.B32m));
}
public Rep <BalanceResult> GetBalance32(string address)
{
return(GetBalance(Bech32.FromBech32Address(address)));
}
public static bool IsAddress(string _address, out byte?_version)
{
try
{
if (_address.StartsWith("bc1") || _address.StartsWith("tb1"))
{
#region Bech32
if (_address.Length == 42)
{
_version = (byte?)(_address.StartsWith("bc1") ? 0x00 : 0x6F);
}
else if (_address.Length == 62)
{
_version = (byte?)(_address.StartsWith("bc1") ? 0x05 : 0xC4);
}
else
{
_version = null;
return(false);
}
try
{
Bech32.Bech32Decode(_address, out byte[] _hrp);
return(true);
}
catch
{
return(false);
}
#endregion
}
else
{
#region Base58
byte[] _bytes = Base58.Decode(_address);
if (_bytes.Length != 25)
{
throw new Exception();
}
_version = _bytes[0];
byte[] _byteBody = new byte[21];
Array.Copy(_bytes, 0, _byteBody, 0, 21);
byte[] _byteCheck = new byte[4];
Array.Copy(_bytes, 21, _byteCheck, 0, 4);
string _checkSum = HexPlus.ByteArrayToHexString(_byteCheck);
byte[] _sha256A = SHA.EncodeSHA256(_byteBody);
byte[] _sha256B = SHA.EncodeSHA256(_sha256A);
Array.Copy(_sha256B, 0, _byteCheck, 0, 4);
string _caleSum = HexPlus.ByteArrayToHexString(_byteCheck);
return(_checkSum == _caleSum);
#endregion
}
}
catch
{
_version = null;
return(false);
}
}
private static bool ValidateBech32Address(string address)
{
return(Bech32.Decode(address) != null);
}
public void IsValid_FailTest(string input, Bech32.Mode mode)
{
Assert.False(Bech32.IsValid(input, mode));
}
public override string ToString()
{
var data = new byte[] { (byte)WitnessVersion }.Concat(ConvertBits(WitnessProgram, 8, 5, true));
return($"{Hrp}1{Bech32.Encode(Hrp, data)}");
}
public static string Encode(Bech32 bech32, int length = 42)
{
return(Encode(bech32.hrp, bech32.data).Substring(0, length));
}
public void Encode_FormatExceptionTests(string hrp)
{
Exception ex = Assert.Throws <FormatException>(() => Bech32.Encode(new byte[1], Bech32.Mode.B32, 0, hrp));
Assert.Contains("Invalid HRP.", ex.Message);
}
public void ToBech32AddressTest()
{
string bech32 = Bech32.ToBech32Address("0x9bfec715a6bd658fcb62b0f8cc9bfa2ade71434a");
Assert.AreEqual(bech32.ToLower(), "zil1n0lvw9dxh4jcljmzkruvexl69t08zs62ds9ats");
}
public void IsValidTest(string input, Bech32.Mode mode)
{
Assert.True(Bech32.IsValid(input, mode));
}
