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 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))));
}
/// <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(encoder.Encode(data, (byte)scrT, hrp));
}
public void EncodeTest(byte[] data, byte witVer, string hrp, string expected)
{
string actual = encoder.Encode(data, witVer, hrp);
Assert.Equal(expected, actual, ignoreCase: true);
}
public override string ToString()
{
var data = new byte[] { (byte)WitnessVersion }.Concat(ConvertBits(WitnessProgram, 8, 5, true));
return($"{Hrp}1{Bech32.Encode(Hrp, data)}");
}
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 Encode_OutOfRangeExceptionTests(byte wver)
{
Exception ex = Assert.Throws <ArgumentOutOfRangeException>(() => Bech32.Encode(new byte[1], Bech32.Mode.B32, wver, "bc"));
Assert.Contains("Witness version can not be bigger than 31.", ex.Message);
}
public void Encode_NullExceptionTests(byte[] data)
{
Exception ex = Assert.Throws <ArgumentNullException>(() => Bech32.Encode(data, Bech32.Mode.B32, 0, "bc"));
Assert.Contains("Data can not be null or empty.", ex.Message);
}
public void EncodeTest(byte[] data, Bech32.Mode mode, byte witVer, string hrp, string expected)
{
string actual = Bech32.Encode(data, mode, witVer, hrp);
Assert.Equal(expected, actual, ignoreCase: true);
}
public string BuildP2WPKH(byte[] data)
{
return(b32Encoder.Encode(data, 0, hrp_MainNet));
}
/// <summary>
///
/// </summary>
/// <param name="hrp"></param>
/// <param name="s"></param>
/// <returns></returns>
public static string EncodeString(string hrp, string s)
{
//var data = ByteSquasher(Encoding.Default.GetBytes(s), 8, 5);
return(Bech32.Encode(hrp, Encoding.UTF8.GetBytes(s)));
}
public static string PublicKeyToAddress(byte[] publicKey)
{
return(Bech32.Encode("io", Hash.Hash160B(publicKey.Slice(1))));
}
private void Initialise(EthECKey key)
{
PrivateKey = key.GetPrivateKey();
PublicKey = key.GetPubKey().ToHex();
Address = Bech32.Encode("io", Hash.Hash160B(key.GetPubKey().Slice(1)));
}
