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)); }