public void Constructor_WithBytesTest()
{
byte[] data = Helper.GetBytes(10);
var scr = new RedeemScript(data);
Assert.Equal(data, scr.Data);
}
public void SetToMultiSig_OutOfRangeExceptionTest(int m, PublicKey[] pubs, bool comp, string expError)
{
RedeemScript scr = new RedeemScript();
Exception ex = Assert.Throws <ArgumentOutOfRangeException>(() => scr.SetToMultiSig(m, pubs, comp));
Assert.Contains(expError, ex.Message);
}
public void CountSigOps_OverrideMethodTest(IOperation[] ops, int expected)
{
// Make sure the default sigop counter is overriden
var scr = new RedeemScript(ops);
int actual = scr.CountSigOps();
Assert.Equal(expected, actual);
}
public void RedeemScriptSpecialTypeTest(IConsensus c, byte[] data, RedeemScriptSpecialType expected)
{
var scr = new RedeemScript(data);
RedeemScriptSpecialType actual = scr.GetSpecialType(c);
Assert.Equal(expected, actual);
}
public void SetToMultiSigTest(int m, PublicKey[] pubs, bool comp, byte[] expected)
{
RedeemScript scr = new RedeemScript();
scr.SetToMultiSig(m, pubs, comp);
Assert.Equal(expected, scr.Data);
}
public override int GetHashCode()
{
switch (ScriptType)
{
case CfdDescriptorScriptType.Taproot:
return(ScriptType.GetHashCode() + KeyData.GetHashCode() + ScriptTree.GetHashCode());
case CfdDescriptorScriptType.Pk:
case CfdDescriptorScriptType.Pkh:
case CfdDescriptorScriptType.Wpkh:
case CfdDescriptorScriptType.Combo:
return(ScriptType.GetHashCode() + KeyData.GetHashCode());
case CfdDescriptorScriptType.Sh:
case CfdDescriptorScriptType.Wsh:
case CfdDescriptorScriptType.Multi:
case CfdDescriptorScriptType.SortedMulti:
case CfdDescriptorScriptType.Raw:
return(ScriptType.GetHashCode() + RedeemScript.GetHashCode());
case CfdDescriptorScriptType.Addr:
return(ScriptType.GetHashCode() + Address.GetHashCode());
default:
return(ScriptType.GetHashCode());
}
}
public bool Equals(CfdDescriptorScriptData other)
{
if (ScriptType != other.ScriptType)
{
return(false);
}
switch (ScriptType)
{
case CfdDescriptorScriptType.Taproot:
return(KeyData.Equals(other.KeyData) && ScriptTree.Equals(other.ScriptTree));
case CfdDescriptorScriptType.Pk:
case CfdDescriptorScriptType.Pkh:
case CfdDescriptorScriptType.Wpkh:
case CfdDescriptorScriptType.Combo:
return(KeyData.Equals(other.KeyData));
case CfdDescriptorScriptType.Sh:
case CfdDescriptorScriptType.Wsh:
case CfdDescriptorScriptType.Multi:
case CfdDescriptorScriptType.SortedMulti:
case CfdDescriptorScriptType.Raw:
return(RedeemScript.Equals(other.RedeemScript));
case CfdDescriptorScriptType.Addr:
return(Address.Equals(other.Address));
default:
return(false);
}
}
public void CountSigOpsTest(IOperation[] ops, int expected)
{
var scr = new RedeemScript();
int actual = scr.CountSigOps(ops);
Assert.Equal(expected, actual);
}
public void Constructor_WithNullBytesTest()
{
byte[] data = null;
var scr = new RedeemScript(data);
Assert.Empty(scr.Data); // NotNull
}
public void SetToMultiSig_NullExceptionTest()
{
RedeemScript scr = new RedeemScript();
Assert.Throws <ArgumentNullException>(() => scr.SetToMultiSig(1, null, true));
Assert.Throws <ArgumentNullException>(() => scr.SetToMultiSig(1, new PublicKey[0], true));
}
public bool IsRelatedKey(PubKey pk) => HDKeyPaths.ContainsKey(pk) || // in HDKeyPathMap or pk.Hash.ScriptPubKey.Equals(ScriptPubKey) || // matches as p2pkh or pk.WitHash.ScriptPubKey.Equals(ScriptPubKey) || // as p2wpkh or pk.WitHash.ScriptPubKey.Hash.ScriptPubKey.Equals(ScriptPubKey) || // as p2sh-p2wpkh (RedeemScript != null && pk.WitHash.ScriptPubKey.Equals(RedeemScript)) || // as p2sh-p2wpkh or (RedeemScript != null && RedeemScript.GetAllPubKeys().Any(p => p.Equals(pk))) || // more paranoia check (Probably unnecessary) (WitnessScript != null && WitnessScript.GetAllPubKeys().Any(p => p.Equals(pk)));
public void SetToP2SH_P2WPKH_CompTest()
{
RedeemScript scr = new RedeemScript();
scr.SetToP2SH_P2WPKH(KeyHelper.Pub1, true);
byte[] expected = Helper.HexToBytes($"0014{KeyHelper.Pub1CompHashHex}");
Assert.Equal(expected, scr.Data);
}
public void SetToP2SH_P2WSHTest()
{
RedeemScript scr = new RedeemScript();
MockSerializableScript mockScr = new MockSerializableScript(new byte[] { 1, 2, 3 }, 255);
scr.SetToP2SH_P2WSH(mockScr);
byte[] expected = Helper.HexToBytes("0020039058c6f2c0cb492c533b0a4d14ef77cc0f78abccced5287d84a1a2011cfb81");
Assert.Equal(expected, scr.Data);
}
public RedeemScript Add(string hash, long index, string scriptPubKeyHex, BitcoinPrivateKey privateKey)
{
var script = new RedeemScript {
Hash = hash, Index = index, ScriptPubKeyHex = scriptPubKeyHex, PrivateKey = privateKey
};
this.Items.Add(script);
return(script);
}
public void SetToP2SH_P2WPKH_UnCompTest()
{
RedeemScript scr = new RedeemScript();
// This is non-standard
scr.SetToP2SH_P2WPKH(KeyHelper.Pub1, false);
byte[] expected = Helper.HexToBytes($"0014{KeyHelper.Pub1UnCompHashHex}");
Assert.Equal(expected, scr.Data);
}
public bool IsRelatedKey(PubKey pubkey)
{
var scriptPubKey = GetProbableScriptPubKey();
return(HDKeyPaths.ContainsKey(pubkey) || // in HDKeyPathMap or
pubkey.Hash.ScriptPubKey.Equals(scriptPubKey) || // matches as p2pkh or
pubkey.WitHash.ScriptPubKey.Equals(scriptPubKey) || // as p2wpkh or
pubkey.WitHash.ScriptPubKey.Hash.ScriptPubKey.Equals(scriptPubKey) || // as p2sh-p2wpkh
(RedeemScript != null && pubkey.WitHash.ScriptPubKey.Equals(RedeemScript)) || // as p2sh-p2wpkh or
(RedeemScript != null && RedeemScript.GetAllPubKeys().Any(p => p.Equals(pubkey))) || // more paranoia check (Probably unnecessary)
(WitnessScript != null && WitnessScript.GetAllPubKeys().Any(p => p.Equals(pubkey))));
}
internal JObject ToJson()
{
var obj = new JObject();
obj.Add("ScriptPubKey", Encoders.Hex.EncodeData(ScriptPubKey.ToBytes(true)));
obj.Add("IsInternal", IsInternal);
if (RedeemScript != null)
{
obj.Add("RedeemScript", Encoders.Hex.EncodeData(RedeemScript.ToBytes(true)));
}
obj.Add("AddedDate", AddedDate);
obj.Add("Filter", Filter);
obj.Add("Wallet", Wallet);
return(obj);
}
public void SetToP2SH_ExceptionTest()
{
PubkeyScript scr = new PubkeyScript();
byte[] nba = null;
RedeemScript nscr = null;
string naddr = null;
Assert.Throws <ArgumentNullException>(() => scr.SetToP2SH(nba));
Assert.Throws <ArgumentOutOfRangeException>(() => scr.SetToP2SH(new byte[19]));
Assert.Throws <ArgumentNullException>(() => scr.SetToP2SH(nscr));
Assert.Throws <ArgumentNullException>(() => scr.SetToP2SH(naddr));
Assert.Throws <ArgumentNullException>(() => scr.SetToP2SH(""));
Assert.Throws <FormatException>(() => scr.SetToP2SH("$"));
Assert.Throws <FormatException>(() => scr.SetToP2SH(KeyHelper.Pub1CompAddr));
}
/// <summary>
/// Return the pay to witness script hash wrapped in a pay to script hash address from the given <see cref="IScript"/>.
/// </summary>
/// <exception cref="ArgumentException"/>
/// <exception cref="ArgumentNullException"/>
/// <param name="script">Public key to use</param>
/// <param name="witVer">Witness version to use</param>
/// <param name="netType">[Default value = <see cref="NetworkType.MainNet"/>] Network type</param>
/// <returns>The resulting address</returns>
public string GetP2sh_P2wsh(IScript script, byte witVer, NetworkType netType = NetworkType.MainNet)
{
if (script is null)
{
throw new ArgumentNullException(nameof(script), "Script can not be null.");
}
if (witVer != 0)
{
throw new ArgumentException("Currently only address version 0 is defined for P2WSH-P2SH.", nameof(witVer));
}
if (netType != NetworkType.MainNet && netType != NetworkType.TestNet && netType != NetworkType.RegTest)
{
throw new ArgumentException(Err.InvalidNetwork);
}
RedeemScript rdm = new RedeemScript();
rdm.SetToP2SH_P2WSH(script);
return(GetP2sh(rdm, netType));
}
/// <summary>
/// Return the pay to witness public key hash address from the given <see cref="PublicKey"/>.
/// </summary>
/// <exception cref="ArgumentException"/>
/// <exception cref="ArgumentNullException"/>
/// <param name="pubk">Public key to use</param>
/// <param name="witVer">Witness version to use</param>
/// <param name="useCompressed">
/// [Default value = true]
/// Indicates wheter to use compressed or compressed public key to generate the address
/// <para/> Note: using uncompressed public keys makes the output non-standard and can lead to money loss.
/// </param>
/// <param name="netType">[Default value = <see cref="NetworkType.MainNet"/>] Network type</param>
/// <returns>The resulting address</returns>
public string GetP2sh_P2wpkh(PublicKey pubk, byte witVer, bool useCompressed = true,
NetworkType netType = NetworkType.MainNet)
{
if (pubk is null)
{
throw new ArgumentNullException(nameof(pubk), "Public key can not be null.");
}
if (witVer != 0)
{
throw new ArgumentException("Currently only address version 0 is defined for P2WPKH.", nameof(witVer));
}
if (netType != NetworkType.MainNet && netType != NetworkType.TestNet && netType != NetworkType.RegTest)
{
throw new ArgumentException(Err.InvalidNetwork);
}
RedeemScript rdm = new RedeemScript();
rdm.SetToP2SH_P2WPKH(pubk, useCompressed);
return(GetP2sh(rdm, netType));
}
public void ConstructorTest()
{
var scr = new RedeemScript();
Assert.Empty(scr.Data);
}
public void SetToP2SH_P2WSH_ExceptionTest()
{
RedeemScript scr = new RedeemScript();
Assert.Throws <ArgumentNullException>(() => scr.SetToP2SH_P2WSH(null));
}
public void Constructor_OpsTest()
{
var scr = new RedeemScript(new IOperation[] { new DUPOp(), new PushDataOp(new byte[] { 10, 20, 30 }) });
Assert.Equal(new byte[] { (byte)OP.DUP, 3, 10, 20, 30 }, scr.Data);
}
public void Constructor_EmptyOpsTest()
{
var scr = new RedeemScript(new IOperation[0]);
Assert.Equal(new byte[0], scr.Data);
}
