protected override NetworkBuilder CreateRegtest()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 150,
MajorityEnforceBlockUpgrade = 108,
MajorityRejectBlockOutdated = 108,
MajorityWindow = 108,
PowLimit = new Target(new uint256("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(60),
PowTargetSpacing = TimeSpan.FromSeconds(60),
PowAllowMinDifficultyBlocks = true,
CoinbaseMaturity = 500,
PowNoRetargeting = false,
ConsensusFactory = AlthashConsensusFactory.Instance,
LitecoinWorkCalculation = false,
SupportSegwit = true
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 120 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 110 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 239 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("qcrt"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("qcrt"))
.SetMagic(0x6c5d4e3f)
.SetPort(24888)
.SetRPCPort(14889)
.SetMaxP2PVersion(70018)
.SetName("althash-reg")
.AddAlias("althash-regtest")
.AddSeeds(new NetworkAddress[0])
// Incorrect, using mainnet for now
.SetGenesis("010000000000000000000000000000000000000000000000000000000000000000000000681f98dd984a3a860269b17d5dba8de354c619b34f073cc2bf1e6f7e97607bb080f5c659ffff001fa3700100e965ffd002cd6ad0e2dc402b8044de833e06b23127ea8c3d80aec9141077149556e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b4210000000000000000000000000000000000000000000000000000000000000000ffffffff000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff3f0004bf91221d01043642424320392f32342f32303137204765726d616e7920656c656374696f6e204d65726b656c2077696e7320666f75727468207465726dffffffff0100e1f50500000000434104e67225ab32299deaf6312b5b77f0cd2a5264f3757c9663f8dc401ff8b3ad8b012fde713be690ab819f977f84eaef078767168aeb1cb1287941b6319b76d8e582ac00000000");
return(builder);
}
protected override NetworkBuilder CreateTestnet()
{
var builder = new NetworkBuilder();
var res = builder.SetConsensus(new Consensus()
{
MajorityEnforceBlockUpgrade = 4320,
MajorityRejectBlockOutdated = 5472,
MajorityWindow = 5760,
PowTargetTimespan = TimeSpan.FromSeconds(60),
PowTargetSpacing = TimeSpan.FromSeconds(90),
PowAllowMinDifficultyBlocks = false,
CoinbaseMaturity = 15,
ConsensusFactory = FeirmConsensusFactory.Instance,
SupportSegwit = false
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 98 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 12 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 108 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("txfe"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("txfe"))
.SetMagic(0x5CBB1A33)
.SetPort(34912)
.SetRPCPort(14000)
.SetMaxP2PVersion(70917)
.SetName("feirm-test")
.AddAlias("feirm-testnet")
.AddDNSSeeds(new[]
{
new DNSSeedData("0", "seed1.feirm.com"),
new DNSSeedData("1", "seed2.feirm.com"),
new DNSSeedData("2", "seed3.feirm.com"),
new DNSSeedData("3", "seed4.feirm.com"),
})
.AddSeeds(new NetworkAddress[0])
.SetGenesis("e824b4355bb73c6072808d5bbb1624719c2d03d2c13429970a648efd2d4ceb08");
return(builder);
}
protected override NetworkBuilder CreateTestnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 210240,
MajorityEnforceBlockUpgrade = 51,
MajorityRejectBlockOutdated = 75,
MajorityWindow = 100,
BIP34Hash = new uint256("0x0000047d24635e347be3aaaeb66c26be94901a2f962feccd4f95090191f208c1"),
PowLimit = new Target(new uint256("0x00000fffff000000000000000000000000000000000000000000000000000000")),
MinimumChainWork = new uint256("0x000000000000000000000000000000000000000000000000000924e924a21715"),
PowTargetTimespan = TimeSpan.FromSeconds(24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(2 * 60),
PowAllowMinDifficultyBlocks = true,
CoinbaseMaturity = 15,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 1512,
MinerConfirmationWindow = 2016,
ConsensusFactory = PolisConsensusFactory.Instance,
SupportSegwit = false
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 140 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 19 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 239 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("tpolis"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("tpolis"))
.SetMagic(0xFFCAE2CE)
.SetPort(24130)
.SetRPCPort(24131)
.SetMaxP2PVersion(70211)
.SetName("polis-test")
.AddAlias("polis-testnet")
.AddSeeds(new NetworkAddress[0])
.SetGenesis("010000000000000000000000000000000000000000000000000000000000000000000000fc4b8cb903aed54e11e1ae8a5b7ad097ade34988a84500ad2d80e4d1f5bcc95d678f875af0ff0f1e94ba01000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2404ffff001d01041c506f6c69732c2066726f6d2070656f706c6520746f2070656f706c65ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000");
return(builder);
}
protected override NetworkBuilder CreateRegtest()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 150,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
BIP34Hash = new uint256(),
PowLimit = new Target(new uint256("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
MinimumChainWork = new uint256("0x0000000000000000000000000000000000000000000000000000000000000000"),
PowTargetTimespan = TimeSpan.FromSeconds(24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(2 * 60),
PowAllowMinDifficultyBlocks = true,
CoinbaseMaturity = 100,
PowNoRetargeting = true,
RuleChangeActivationThreshold = 108,
MinerConfirmationWindow = 144,
ConsensusFactory = MonoeciConsensusFactory.Instance,
SupportSegwit = false
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 140 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 19 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 239 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("txmcc"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("txmcc"))
.SetMagic(0xDCB7C1FC)
.SetPort(44157)
.SetRPCPort(18332)
.SetMaxP2PVersion(70208)
.SetName("monoeci-reg")
.AddAlias("monoeci-regtest")
.AddSeeds(new NetworkAddress[0])
.SetGenesis("010000000000000000000000000000000000000000000000000000000000000000000000aa991b3e07b573c8c71273100a0bfebd19a7bdc37e8a13a07c7022eacad69c3661304058f0ff0f1e21970d000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff5704ffff001d01044c4e4d6f6e61636f206f627469656e74206f6666696369656c6c656d656e7420736f6e20696e64c3a970656e64616e6365206475205361696e742d456d7069726520726f6d61696e20656e2031353234ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000");
return(builder);
}
protected override NetworkBuilder CreateRegtest()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 150,
MajorityEnforceBlockUpgrade = 51,
MajorityRejectBlockOutdated = 75,
MajorityWindow = 144,
PowLimit = new Target(new uint256("00ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(1.1 * 24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(1),
PowAllowMinDifficultyBlocks = true,
MinimumChainWork = uint256.Zero,
PowNoRetargeting = true,
RuleChangeActivationThreshold = 108,
MinerConfirmationWindow = 144,
CoinbaseMaturity = 120,
LitecoinWorkCalculation = true,
ConsensusFactory = GroestlcoinConsensusFactory.Instance
})
.SetNetworkStringParser(GroestlcoinStringParser.Instance)
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 111 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 196 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 239 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("grsrt"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("grsrt"))
.SetMagic(0xdab5bffa)
.SetPort(18888)
.SetRPCPort(18443)
.SetName("groestl-reg")
.AddAlias("groestl-regtest")
.AddAlias("groestlcoin-reg")
.AddAlias("groestlcoin-regtest")
.SetGenesis("030000000000000000000000000000000000000000000000000000000000000000000000bb2866aaca46c4428ad08b57bc9d1493abaf64724b6c3052a7c8f958df68e93c02a8d455ffff001e950a64000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff3a04ffff001d0104325072657373757265206d75737420626520707574206f6e20566c6164696d697220507574696e206f766572204372696d6561ffffffff010000000000000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000");
return(builder);
}
protected override NetworkBuilder CreateMainnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 1050000,
MajorityEnforceBlockUpgrade = 4050,
MajorityRejectBlockOutdated = 5130,
MajorityWindow = 5400,
PowLimit = new Target(new uint256("0x00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(60),
PowTargetSpacing = TimeSpan.FromSeconds(120),
PowAllowMinDifficultyBlocks = false,
CoinbaseMaturity = 10,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 10752,
MinerConfirmationWindow = 13440,
ConsensusFactory = FeirmConsensusFactory.Instance,
SupportSegwit = false
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 12 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 57 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 55 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x88, 0xB2, 0x1E })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x88, 0xAD, 0xE4 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("xfe"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("xfe"))
.SetMagic(0x9FA4FB4D)
.SetPort(4918)
.SetRPCPort(14000)
.SetMaxP2PVersion(70917)
.SetName("feirm-main")
.AddAlias("feirm-mainnet")
.AddDNSSeeds(new DNSSeedData[0])
.AddSeeds(new NetworkAddress[0])
.SetGenesis("e824b4355bb73c6072808d5bbb1624719c2d03d2c13429970a648efd2d4ceb08");
return(builder);
}
protected override NetworkBuilder CreateRegtest()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 150,
MajorityEnforceBlockUpgrade = 51,
MajorityRejectBlockOutdated = 75,
MajorityWindow = 144,
PowLimit = new Target(new uint256("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(14 * 24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(10 * 60),
PowAllowMinDifficultyBlocks = true,
MinimumChainWork = uint256.Zero,
PowNoRetargeting = true,
RuleChangeActivationThreshold = 108,
MinerConfirmationWindow = 144,
CoinbaseMaturity = 100,
LitecoinWorkCalculation = true,
ConsensusFactory = TDCoinConsensusFactory.Instance
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 111 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 90 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 239 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("tdrt"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("tdrt"))
.SetMagic(0xdab5bffa)
.SetPort(19444)
.SetRPCPort(19443)
.SetName("tdc-reg")
.AddAlias("tdc-regtest")
.AddAlias("TDCoin-reg")
.AddAlias("TDCoin-regtest")
.SetGenesis("0100000000000000000000000000000000000000000000000000000000000000000000004ade933b9e1c7ad4d879f9f56b30ba19ee2fea9a55e184c4ad1008810962ba6c217ab15cffff7f20000000000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4804ffff001d010440342d31322d31392041797261742056205a616b69722c2063726561746f72206f662054415444696720456e67696e6520616e642054616e676b7961206e65742effffffff0100d6117e03000000434104486940951aad21ee9646dd1fc43ec8bf01723cdd95661741034888ffa1f21b837c0a59b9c3b625d66379d35055a389ff3f3d849105ee9da67eb82d13d7cdde67ac00000000");
return(builder);
}
public CirrusAddressValidationNetwork(string name) : base()
{
this.Name = name;
this.Base58Prefixes = new byte[12][];
switch (name)
{
case "CirrusMain":
this.Base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS] = new byte[] { 28 }; // C
this.Base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS] = new byte[] { 88 }; // c
break;
case "CirrusTest":
this.Base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS] = new byte[] { 127 }; // t
this.Base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS] = new byte[] { 137 }; // x
break;
case "CirrusRegTest":
this.Base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS] = new byte[] { 55 }; // P
this.Base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS] = new byte[] { 117 }; // p
break;
}
this.Base58Prefixes[(int)Base58Type.SECRET_KEY] = new byte[] { (239) };
this.Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_NO_EC] = new byte[] { 0x01, 0x42 };
this.Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_EC] = new byte[] { 0x01, 0x43 };
this.Base58Prefixes[(int)Base58Type.EXT_PUBLIC_KEY] = new byte[] { (0x04), (0x35), (0x87), (0xCF) };
this.Base58Prefixes[(int)Base58Type.EXT_SECRET_KEY] = new byte[] { (0x04), (0x35), (0x83), (0x94) };
this.Base58Prefixes[(int)Base58Type.PASSPHRASE_CODE] = new byte[] { 0x2C, 0xE9, 0xB3, 0xE1, 0xFF, 0x39, 0xE2 };
this.Base58Prefixes[(int)Base58Type.CONFIRMATION_CODE] = new byte[] { 0x64, 0x3B, 0xF6, 0xA8, 0x9A };
this.Base58Prefixes[(int)Base58Type.STEALTH_ADDRESS] = new byte[] { 0x2b };
this.Base58Prefixes[(int)Base58Type.ASSET_ID] = new byte[] { 115 };
this.Base58Prefixes[(int)Base58Type.COLORED_ADDRESS] = new byte[] { 0x13 };
Bech32Encoder encoder = Encoders.Bech32("tb");
this.Bech32Encoders = new Bech32Encoder[2];
this.Bech32Encoders[(int)Bech32Type.WITNESS_PUBKEY_ADDRESS] = encoder;
this.Bech32Encoders[(int)Bech32Type.WITNESS_SCRIPT_ADDRESS] = encoder;
}
protected override NetworkBuilder CreateRegtest()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 150,
MajorityEnforceBlockUpgrade = 51,
MajorityRejectBlockOutdated = 75,
MajorityWindow = 144,
PowLimit = new Target(new uint256("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(3.5 * 24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(2.5 * 60),
PowAllowMinDifficultyBlocks = true,
MinimumChainWork = uint256.Zero,
PowNoRetargeting = true,
RuleChangeActivationThreshold = 108,
MinerConfirmationWindow = 2016,
CoinbaseMaturity = 100,
LitecoinWorkCalculation = true,
ConsensusFactory = LitecoinConsensusFactory.Instance
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 111 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 58 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 239 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("tltc"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("tltc"))
.SetMagic(0xdab5bffa)
.SetPort(19444)
.SetRPCPort(19332)
.SetName("ltc-reg")
.AddAlias("ltc-regtest")
.AddAlias("litecoin-reg")
.AddAlias("litecoin-regtest")
.SetGenesis("010000000000000000000000000000000000000000000000000000000000000000000000d9ced4ed1130f7b7faad9be25323ffafa33232a17c3edf6cfd97bee6bafbdd97dae5494dffff7f20000000000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4804ffff001d0104404e592054696d65732030352f4f63742f32303131205374657665204a6f62732c204170706c65e280997320566973696f6e6172792c2044696573206174203536ffffffff0100f2052a010000004341040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9ac00000000");
return(builder);
}
protected override NetworkBuilder CreateRegtest()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 420000,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
PowLimit = new Target(new uint256("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(60 * 60 * 1000),
PowTargetSpacing = TimeSpan.FromSeconds(1),
PowAllowMinDifficultyBlocks = true,
MinimumChainWork = uint256.Zero,
PowNoRetargeting = true,
RuleChangeActivationThreshold = 108,
MinerConfirmationWindow = 144,
CoinbaseMaturity = 100,
ConsensusFactory = ZCoinConsensusFactory.Instance
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 65 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 178 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 239 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("txzc"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("txzc"))
.SetMagic(0xDAB5BFFA) //defined in inverted direction, 0xFABFB5DA
.SetPort(18444)
.SetRPCPort(28888)
.SetMaxP2PVersion(80000)
.SetName("xzc-reg")
.AddAlias("xzc-regtest")
.AddAlias("zcoin-reg")
.AddAlias("zcoin-regtest")
.SetGenesis("010000000000000000000000000000000000000000000000000000000000000000000000b8b7f5efce3af62564cb2b1035c711d9add9f59b38721e316ba6c70bd661b325dec55354ffff7f201ba4ae180101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff5a04f0ff0f1e01044c4c54696d657320323031342f31302f3331204d61696e65204a756467652053617973204e75727365204d75737420466f6c6c6f772045626f6c612051756172616e74696e6520666f72204e6f770408000000ffffffff0100000000000000000000000000");
return(builder);
}
protected override NetworkBuilder CreateRegtest()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 150,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
PowLimit = new Target(new uint256("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(60),
PowAllowMinDifficultyBlocks = true,
CoinbaseMaturity = 100,
PowNoRetargeting = true,
RuleChangeActivationThreshold = 108,
MinerConfirmationWindow = 144,
ConsensusFactory = EnergiConsensusFactory.Instance,
SupportSegwit = false,
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 127 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 19 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 239 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("tnrg"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("tnrg"))
.SetMagic(0x7F6C89EF)
.SetPort(39797)
.SetRPCPort(8332)
.SetMaxP2PVersion(70212)
.SetName("nrg-reg")
.AddAlias("nrg-regtest")
.AddDNSSeeds(new DNSSeedData[0])
.AddSeeds(new NetworkAddress[0])
.SetGenesis("0100000000000000000000000000000000000000000000000000000000000000000000009e66e4b752f3469f19130525455b4ffc61d3ea6140a0aef1e49166b9f377e034c0a8da5affff7f2000000000ad052da0b7df5e7766c48cab6be5790ae9b80b312e7c2cc65b4b9b802d2c567e0c000000000000000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff1304ffff7f2001040b576f726c6420506f776572ffffffff0100022e1b0000000043410479619b3615fc9f03aace413b9064dc97d4b6f892ad541e5a2d8a3181517443840a79517fb1a308e834ac3c53da86de69a9bcce27ae01cf77d9b2b9d7588d122aac00000000");
return(builder);
}
protected override NetworkBuilder CreateRegtest()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
PowLimit = new Target(new uint256("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(16 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(60),
PowAllowMinDifficultyBlocks = true,
MinimumChainWork = uint256.Zero,
PowNoRetargeting = true,
RuleChangeActivationThreshold = 108,
MinerConfirmationWindow = 144,
CoinbaseMaturity = 110,
LitecoinWorkCalculation = true,
ConsensusFactory = BitcoinplusConsensusFactory.Instance,
SupportSegwit = true
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 111 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 196 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 239 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("txbc"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("txbc"))
.SetMagic(0xdab5bffa)
.SetPort(18444)
.SetRPCPort(18445)
.SetName("xbc-reg")
.AddAlias("xbc-regtest")
.AddAlias("Bitcoinplus-reg")
.AddAlias("Bitcoinplus-regtest")
.SetGenesis("010000000000000000000000000000000000000000000000000000000000000000000000da64b72ffb5a9f067e39f5d0d67efe353c5f051b30f213f3b7e3a4ffe847c348dae5494dffff7f20000000000101000000dae5494d010000000000000000000000000000000000000000000000000000000000000000ffffffff3100012a2d424243204e6577733a2043616d65726f6e206c61756e6368657320656c656374696f6e2063616d706169676e2effffffff010000000000000000000000000000");
return(builder);
}
protected override NetworkBuilder CreateRegtest()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 150,
MajorityEnforceBlockUpgrade = 51,
MajorityRejectBlockOutdated = 75,
MajorityWindow = 144,
PowLimit = new Target(new uint256("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(14 * 24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(2.5 * 60),
PowAllowMinDifficultyBlocks = true,
MinimumChainWork = uint256.Zero,
PowNoRetargeting = true,
RuleChangeActivationThreshold = 108,
MinerConfirmationWindow = 144,
CoinbaseMaturity = 100,
ConsensusFactory = BitcoreConsensusFactory.Instance
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 111 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 196 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 239 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("tbtx"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("tbtx"))
.SetMagic(0xDAB5BFFA) //defined in inverted direction, 0xFABFB5DA
.SetPort(19444)
.SetRPCPort(19332)
.SetMaxP2PVersion(80000)
.SetName("btx-reg")
.AddAlias("btx-regtest")
.AddAlias("bitcore-reg")
.AddAlias("bitcore-regtest")
.SetGenesis("010000000000000000000000000000000000000000000000000000000000000000000000c787795041016d5ee652e55e3a6aeff6c8019cf0c525887337e0b4206552691613f7fc58f0ff0f1ea12400000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4004ffff001d010438506f77657264652062792042697473656e642d4575726f7065636f696e2d4469616d6f6e642d4d41432d42332032332f4170722f32303137ffffffff010000000000000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000");
return(builder);
}
protected override NetworkBuilder CreateRegtest()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 150,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
BIP34Hash = new uint256(),
PowLimit = new Target(new uint256("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(14 * 24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(10 * 60),
PowNoRetargeting = false,
PowAllowMinDifficultyBlocks = true,
RuleChangeActivationThreshold = 108,
MinerConfirmationWindow = 144,
MinimumChainWork = new uint256("0000000000000000000000000000000000000000000000000000000000000000"),
ConsensusFactory = BitcoinAtomConsensusFactory.Instance,
SupportSegwit = true,
CoinbaseMaturity = 100
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 111 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 196 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 239 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("bcart"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("bcart"))
.SetPort(18444)
.SetRPCPort(18443)
.SetMagic(0xcad71f4a)
.SetName("bca-reg")
.AddSeeds(new NetworkAddress[0])
.SetGenesis("0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4adae5494dffff7f20020000000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000");
return(builder);
}
protected override NetworkBuilder CreateRegtest()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 150,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
PowLimit = new Target(new uint256("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(1 * 24),
PowAllowMinDifficultyBlocks = true,
MinimumChainWork = uint256.Zero,
PowNoRetargeting = true,
RuleChangeActivationThreshold = 2700,
MinerConfirmationWindow = 3600,
CoinbaseMaturity = 100,
LitecoinWorkCalculation = true,
ConsensusFactory = ViacoinConsensusFactory.Instance
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 111 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 196 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 239 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("tvia"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("tvia"))
.SetMagic(0x377b972d)
.SetPort(15224)
.SetRPCPort(15223)
.SetName("via-reg")
.AddAlias("via-regtest")
.AddAlias("viacoin-reg")
.AddAlias("viacoin-regtest")
.SetGenesis("01000000000000000000000000000000000000000000000000000000000000000000000000522753002939c78659b4fdc6ed56c6b6aacdc7586facf2f6ada2012ed31703d321c153ffff7f20000000000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff5704ffff001d01044c4e426c6f636b20233331303337393a30303030303030303030303030303030323431323532613762623237626539376265666539323138633132393064666633366331666631323965633732313161ffffffff01000000000000000043410459934a6a228ce9716fa0b13aa1cdc01593fca5f8599473c803a5109ff834dfdaf4c9ee35f2218c9ee3e7cf7db734e1179524b9d6ae8ebbeba883d4cb89b6c7bfac00000000");
return(builder);
}
protected override NetworkBuilder CreateRegtest()
{
var builder = new NetworkBuilder();
var res = builder.SetConsensus(new Consensus
{
SubsidyHalvingInterval = 150,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
PowLimit = new Target(0 >> 1),
MinimumChainWork = new uint256("0000000000000000000000000000000000000000000000000000000000000000"),
PowTargetTimespan = TimeSpan.FromSeconds(24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(1 * 60),
PowAllowMinDifficultyBlocks = false,
CoinbaseMaturity = 0,
PowNoRetargeting = true,
ConsensusFactory = MonetaryUnitConsensusFactory.Instance,
SupportSegwit = false
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 139 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 19 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 239 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x3A, 0x80, 0x61, 0xA0 })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x3A, 0x80, 0x58, 0x37 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("rtmue"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("rtmue"))
.SetMagic(0xad7ecfa2)
.SetPort(19685)
.SetRPCPort(19686)
.SetMaxP2PVersion(70800)
.SetName("monetaryunit-reg")
.AddAlias("monetaryunit-regtest")
.SetUriScheme("monetaryunit")
.AddDNSSeeds(new DNSSeedData[0])
.AddSeeds(new NetworkAddress[0])
.SetGenesis("0100000000000000000000000000000000000000000000000000000000000000000000004e9144c4f6527245c4bdd6ee4e832e45d4ce035d5da260e261194a48f2adae7260e8b759ffff7f203b3000000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff6004ffff001d01044c57426974636f696e20426c6f636b20233534343338313a2030303030303030303030303030303030303030643564313634376364353137343032306430333439373761376131333362316165643438646636363731383138ffffffff0100000000000000000000000000");
return(builder);
}
protected override NetworkBuilder CreateRegtest()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 150,
MajorityEnforceBlockUpgrade = 51, //TODO
MajorityRejectBlockOutdated = 75, //TODO
MajorityWindow = 144, //TODO
PowLimit = new Target(new uint256("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(1.1 * 24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(1.5 * 60),
PowAllowMinDifficultyBlocks = true,
MinimumChainWork = uint256.Zero, //TODO
PowNoRetargeting = true,
RuleChangeActivationThreshold = 108,
MinerConfirmationWindow = 144,
CoinbaseMaturity = 100,
LitecoinWorkCalculation = true,
ConsensusFactory = MonacoinConsensusFactory.Instance
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 111 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 196 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 239 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("rmona"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("rmona"))
.SetMagic(0xdab5bffa)
.SetPort(20444)
.SetRPCPort(19402)
.SetName("mona-reg")
.AddAlias("mona-regtest")
.AddAlias("monacoin-reg")
.AddAlias("monacoin-regtest")
.SetGenesis("010000000000000000000000000000000000000000000000000000000000000000000000a64bac07fe31877f31d03252953b3c32398933af7a724119bc4d6fa4a805e435dae5494dffff7f20010000000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff5f04ffff001d01044c564465632e20333174682032303133204a6170616e2c205468652077696e6e696e67206e756d62657273206f6620746865203230313320596561722d456e64204a756d626f204c6f74746572793a32332d313330393136ffffffff0100f2052a010000004341040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9ac00000000");
return(builder);
}
protected override NetworkBuilder CreateTestnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 840000,
MajorityEnforceBlockUpgrade = 51,
MajorityRejectBlockOutdated = 75,
MajorityWindow = 1000,
PowLimit = new Target(new uint256("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(3.5 * 24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(2.5 * 60),
PowAllowMinDifficultyBlocks = true,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 375,
MinerConfirmationWindow = 2016,
CoinbaseMaturity = 100,
ConsensusFactory = ActiniumConsensusFactory.Instance
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 43 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 196 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 171 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("tacm"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("tacm"))
.SetMagic(0xf7c7d2f2)
.SetPort(4335)
.SetRPCPort(2301)
.SetName("acm-test")
.AddAlias("acm-testnet")
.AddAlias("actinium-test")
.AddAlias("actinium-testnet")
.AddSeeds(ToSeed(pnSeed6_test))
.SetGenesis("01000000000000000000000000000000000000000000000000000000000000000000000091912cefda3a88139528d6a4e6137c6812d9f46df80db48cf8ad222f0eb155ec1150e05af0ff0f1ec14d00000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff5004ffff001d0104484e592054696d65732032342f4170722f3230313820546f726f6e746f2056616e2041747461636b20537573706563742045787072657373656420416e67657220617420576f6d656effffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000");
return(builder);
}
protected override NetworkBuilder CreateRegtest()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 150,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
PowLimit = new Target(new uint256("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(14 * 24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(90),
PowAllowMinDifficultyBlocks = true,
MinimumChainWork = uint256.Zero,
PowNoRetargeting = true,
RuleChangeActivationThreshold = 108,
MinerConfirmationWindow = 144,
CoinbaseMaturity = 100,
ConsensusFactory = UfoConsensusFactory.Instance,
SupportSegwit = true
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 111 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 130 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 239 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("tuf"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("tuf"))
.SetMagic(0x1c55211b)
.SetPort(18444)
.SetRPCPort(18445)
.SetName("ufo-reg")
.AddAlias("Ufo-regtest")
.SetUriScheme("ufo")
.SetGenesis("0100000000000000000000000000000000000000000000000000000000000000000000006570e7f569717849280945b767d0a8ae3a1240e510c8a0abdcbfa5283adf0782dae5494dffff7f20030000000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff1604ffff001d01040e32206a616e756172792032303134ffffffff0100000000000000000200ac00000000");
return(builder);
}
protected override NetworkBuilder CreateRegtest()
{
var builder = new NetworkBuilder();
var res = builder.SetConsensus(new Consensus
{
SubsidyHalvingInterval = 150,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
PowLimit = new Target(0 >> 1),
MinimumChainWork = new uint256("0000000000000000000000000000000000000000000000000000000000000000"),
PowTargetTimespan = TimeSpan.FromSeconds(1),
PowTargetSpacing = TimeSpan.FromSeconds(1),
PowAllowMinDifficultyBlocks = false,
CoinbaseMaturity = 0,
PowNoRetargeting = true,
ConsensusFactory = LBRYCreditsConsensusFactory.Instance,
SupportSegwit = false
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 111 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 196 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 239 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("rtLBC"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("rtLBC"))
.SetMagic(0xfae4aad1)
.SetPort(29246)
.SetRPCPort(29245)
.SetMaxP2PVersion(70800)
.SetName("LBRYCredits-reg")
.AddAlias("LBRYCredits-regtest")
.AddDNSSeeds(new DNSSeedData[0])
.AddSeeds(new NetworkAddress[0])
.SetGenesis("010000000000000000000000000000000000000000000000000000000000000000000000cc59e59ff97ac092b55e423aa5495151ed6fb80570a5bb78cd5bd1c3821c21b8010000000000000000000000000000000000000000000000000000000000000033193156ffff7f20010000000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff1f04ffff001d010417696e736572742074696d657374616d7020737472696e67ffffffff01000004bfc91b8e001976a914345991dbf57bfb014b87006acdfafbfc5fe8292f88ac0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
return(builder);
}
protected override NetworkBuilder CreateRegtest()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 150,
MajorityEnforceBlockUpgrade = 108,
MajorityRejectBlockOutdated = 108,
MajorityWindow = 108,
PowLimit = new Target(new uint256("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(4000),
PowTargetSpacing = TimeSpan.FromSeconds(2 * 64),
PowAllowMinDifficultyBlocks = true,
CoinbaseMaturity = 500,
PowNoRetargeting = false,
ConsensusFactory = QtumConsensusFactory.Instance,
LitecoinWorkCalculation = false,
SupportSegwit = true
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 120 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 110 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 239 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("qcrt"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("qcrt"))
.SetMagic(0xe1c6ddfd)
.SetPort(23888)
.SetRPCPort(13889)
.SetMaxP2PVersion(70017)
.SetName("qtum-reg")
.AddAlias("qtum-regtest")
.AddSeeds(new NetworkAddress[0])
// Incorrect, using mainnet for now
.SetGenesis("0100000000000000000000000000000000000000000000000000000000000000000000006db905142382324db417761891f2d2f355ea92f27ab0fc35e59e90b50e0534edf5d2af59ffff7f2011000000e965ffd002cd6ad0e2dc402b8044de833e06b23127ea8c3d80aec9141077149556e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b4210000000000000000000000000000000000000000000000000000000000000000ffffffff000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff420004bf91221d0104395365702030322c203230313720426974636f696e20627265616b732024352c30303020696e206c6174657374207072696365206672656e7a79ffffffff0100f2052a010000004341040d61d8653448c98731ee5fffd303c15e71ec2057b77f11ab3601979728cdaff2d68afbba14e4fa0bc44f2072b0b23ef63717f8cdfbe58dcd33f32b6afe98741aac00000000");
return(builder);
}
protected override NetworkBuilder CreateRegtest()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 210000,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
PowLimit = new Target(new uint256("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(30),
PowTargetSpacing = TimeSpan.FromSeconds(30),
PowAllowMinDifficultyBlocks = false,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 300, // 75% of 400+
MinerConfirmationWindow = 400,
CoinbaseMaturity = 30,
LitecoinWorkCalculation = true,
ConsensusFactory = NavcoinConsensusFactory.Instance
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 111 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 196 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 239 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x40, 0x88, 0x2B, 0xE1 })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x40, 0x88, 0xDA, 0x4E })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("tnav"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("tnav"))
.SetMagic(0x89b7117d)
.SetPort(18886)
.SetRPCPort(44446)
.SetName("nav-reg")
.AddAlias("nav-regtest")
.AddAlias("navcoin-reg")
.AddAlias("navcoin-regtest")
.SetGenesis("0100000000000000000000000000000000000000000000000000000000000000000000001ac692738a35b20c57608a4b5946d9d242baafceaf64d73254fdabccc6ee07c590640e57ffff001f211b0000010100000090640e57010000000000000000000000000000000000000000000000000000000000000000ffffffff1200012a0e47616d652069732061666f6f7421ffffffff010000000000000000000000000000");
return(builder);
}
protected override NetworkBuilder CreateRegtest() => new NetworkBuilder()
.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 12500000,
MajorityEnforceBlockUpgrade = Bitcoin.Instance.Mainnet.Consensus.MajorityEnforceBlockUpgrade,
MajorityRejectBlockOutdated = Bitcoin.Instance.Mainnet.Consensus.MajorityRejectBlockOutdated,
MajorityWindow = Bitcoin.Instance.Mainnet.Consensus.MajorityWindow,
BIP34Hash = new uint256("72e36f3fcdf98d3625dfe03f28a914c513b913231e479d53fc22e5e46cf5b585"),
PowLimit = new Target(new uint256("003fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(61200),
PowTargetSpacing = TimeSpan.FromSeconds(510),
PowAllowMinDifficultyBlocks = false,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 9180,
MinerConfirmationWindow = 12240,
CoinbaseMaturity = Bitcoin.Instance.Mainnet.Consensus.CoinbaseMaturity,
LitecoinWorkCalculation = false,
SupportSegwit = true,
}
)
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 61 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 123 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 239 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("rugar"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("rugar"))
.SetPort(45340)
//.SetRPCPort(34229)
.SetName("sugarchain-regtest")
.AddAlias("sugarchain-regtestnet")
// .AddDNSSeeds(new[]
// {
// new DNSSeedData("", ""),
// })
.SetGenesis("d567a9c891c7a47e6dd03f8006cb65b0d6406b5dc7b2c86d7a904815c394e1f1")
.AddSeeds(new NetworkAddress[0]);
protected override NetworkBuilder CreateTestnet() => new NetworkBuilder()
.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 12500000,
MajorityEnforceBlockUpgrade = Bitcoin.Instance.Mainnet.Consensus.MajorityEnforceBlockUpgrade,
MajorityRejectBlockOutdated = Bitcoin.Instance.Mainnet.Consensus.MajorityRejectBlockOutdated,
MajorityWindow = Bitcoin.Instance.Mainnet.Consensus.MajorityWindow,
BIP34Hash = new uint256("72e36f3fcdf98d3625dfe03f28a914c513b913231e479d53fc22e5e46cf5b585"),
PowLimit = new Target(new uint256("003fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(61200),
PowTargetSpacing = TimeSpan.FromSeconds(510),
PowAllowMinDifficultyBlocks = false,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 9180,
MinerConfirmationWindow = 12240,
CoinbaseMaturity = Bitcoin.Instance.Mainnet.Consensus.CoinbaseMaturity,
LitecoinWorkCalculation = false,
SupportSegwit = true,
}
)
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 0x42 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 0x80 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 0xEF })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x88, 0xB2, 0x1E })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x88, 0xAD, 0xE4 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("tugar"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("tugar"))
.SetPort(44230)
//.SetRPCPort(34229)
.SetName("sugarchain-test")
.AddAlias("sugarchain-testnet")
.AddDNSSeeds(new[]
{
new DNSSeedData("1seed-testnet.cryptozeny.com", "1seed-testnet.cryptozeny.com"),
})
.SetGenesis("0032f49a73e00fc182e08d5ede75c1418c7833092d663e43a5463c1dbd096f28")
.AddSeeds(new NetworkAddress[0]);
protected override NetworkBuilder CreateRegtest()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 150,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
PowTargetTimespan = TimeSpan.FromSeconds(24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(2 * 60),
PowAllowMinDifficultyBlocks = true,
RuleChangeActivationThreshold = 108,
MinerConfirmationWindow = 144,
ConsensusFactory = FeirmConsensusFactory.Instance,
SupportSegwit = false
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 98 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 12 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 108 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("xfert"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("xfert"))
.SetMagic(0xBC32EE20)
.SetPort(81295)
.SetRPCPort(14000)
.SetMaxP2PVersion(70917)
.SetName("feirm-reg")
.AddAlias("feirm-regtest")
.AddDNSSeeds(new DNSSeedData[0])
.AddSeeds(new NetworkAddress[0])
.SetGenesis("e824b4355bb73c6072808d5bbb1624719c2d03d2c13429970a648efd2d4ceb08");
return(builder);
}
public Wallet(Key key, BinanceDexEnvironmentData env)
{
EcKey = key;
Env = env;
Bech32Encoder bech32Encoder = Encoders.Bech32(Env.Hrp);
AddressBytes = EcKey.PubKey.Hash.ToBytes();
string b32 = Encoders.Base32.EncodeData(AddressBytes);
byte[] address32 = new byte[b32.Length];
for (int i = 0; i < b32.Length; i++)
{
address32[i] = (byte)pbase32.IndexOf(b32[i]);
}
Address = bech32Encoder.EncodeData(address32);
byte[] pubKey = EcKey.PubKey.ToBytes();
byte[] pubKeyPrefix = MessageType.GetTransactionType(EMessageType.PubKey);
PubKeyForSign = new byte[pubKey.Length + pubKeyPrefix.Length + 1];
pubKeyPrefix.CopyTo(PubKeyForSign, 0);
PubKeyForSign[pubKeyPrefix.Length] = 33;
pubKey.CopyTo(PubKeyForSign, pubKeyPrefix.Length + 1);
client = new HttpApiClient(Env);
}
public SmartContractsPoARegTest()
{
this.Name = "SmartContractsPoARegTest";
this.NetworkType = NetworkType.Regtest;
this.CoinTicker = "SCPOA";
var consensusFactory = new SmartContractPoAConsensusFactory();
// Create the genesis block.
this.GenesisTime = 1513622125;
this.GenesisNonce = 1560058197;
this.GenesisBits = 402691653;
this.GenesisVersion = 1;
this.GenesisReward = Money.Zero;
NBitcoin.Block genesisBlock = CreatePoAGenesisBlock(consensusFactory, this.GenesisTime, this.GenesisNonce, this.GenesisBits, this.GenesisVersion, this.GenesisReward);
((SmartContractPoABlockHeader)genesisBlock.Header).HashStateRoot = new uint256("21B463E3B52F6201C0AD6C991BE0485B6EF8C092E64583FFA655CC1B171FE856"); // Set StateRoot to empty trie.
this.Genesis = genesisBlock;
// Keeping the 3rd there in case we use it in future. For our integration tests we use 2 nodes currently.
this.FederationKeys = new Key[]
{
new Mnemonic("lava frown leave wedding virtual ghost sibling able mammal liar wide wisdom").DeriveExtKey().PrivateKey,
new Mnemonic("idle power swim wash diesel blouse photo among eager reward govern menu").DeriveExtKey().PrivateKey,
new Mnemonic("high neither night category fly wasp inner kitchen phone current skate hair").DeriveExtKey().PrivateKey
};
var genesisFederationMembers = new List <IFederationMember>
{
new FederationMember(this.FederationKeys[0].PubKey), // 029528e83f065153d7fa655e73a07fc96fc759162f1e2c8936fa592f2942f39af0
new FederationMember(this.FederationKeys[1].PubKey), // 03b539807c64abafb2d14c52a0d1858cc29d7c7fad0598f92a1274789c18d74d2d
new FederationMember(this.FederationKeys[2].PubKey) // 02d6792cf941b68edd1e9056653573917cbaf974d46e9eeb9801d6fcedf846477a
};
var consensusOptions = new PoAConsensusOptions(
maxBlockBaseSize: 500_000, // Half the standard block size / weight. Easier to stress test.
maxStandardVersion: 2,
maxStandardTxWeight: 100_000,
maxBlockSigopsCost: 20_000,
maxStandardTxSigopsCost: 20_000 / 5,
genesisFederationMembers: genesisFederationMembers,
targetSpacingSeconds: 60,
votingEnabled: true,
autoKickIdleMembers: false
);
var buriedDeployments = new BuriedDeploymentsArray
{
[BuriedDeployments.BIP34] = 0,
[BuriedDeployments.BIP65] = 0,
[BuriedDeployments.BIP66] = 0
};
var bip9Deployments = new NoBIP9Deployments();
this.Consensus = new Consensus(
consensusFactory: consensusFactory,
consensusOptions: consensusOptions,
coinType: 105,
hashGenesisBlock: genesisBlock.GetHash(),
subsidyHalvingInterval: 210000,
majorityEnforceBlockUpgrade: 750,
majorityRejectBlockOutdated: 950,
majorityWindow: 1000,
buriedDeployments: buriedDeployments,
bip9Deployments: bip9Deployments,
bip34Hash: new uint256("0x000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8"),
ruleChangeActivationThreshold: 1916, // 95% of 2016
minerConfirmationWindow: 2016, // nPowTargetTimespan / nPowTargetSpacing
maxReorgLength: 500,
defaultAssumeValid: null,
maxMoney: long.MaxValue,
coinbaseMaturity: 1,
premineHeight: 5,
premineReward: Money.Coins(100_000_000),
proofOfWorkReward: Money.Coins(0),
powTargetTimespan: TimeSpan.FromSeconds(14 * 24 * 60 * 60), // two weeks
powTargetSpacing: TimeSpan.FromSeconds(60),
powAllowMinDifficultyBlocks: false,
posNoRetargeting: true,
powNoRetargeting: true,
powLimit: null,
minimumChainWork: null,
isProofOfStake: false,
lastPowBlock: 0,
proofOfStakeLimit: null,
proofOfStakeLimitV2: null,
proofOfStakeReward: Money.Zero
);
// Same as current smart contracts test networks to keep tests working
this.Base58Prefixes = new byte[12][];
this.Base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS] = new byte[] { (111) };
this.Base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS] = new byte[] { (196) };
this.Base58Prefixes[(int)Base58Type.SECRET_KEY] = new byte[] { (239) };
this.Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_NO_EC] = new byte[] { 0x01, 0x42 };
this.Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_EC] = new byte[] { 0x01, 0x43 };
this.Base58Prefixes[(int)Base58Type.EXT_PUBLIC_KEY] = new byte[] { (0x04), (0x35), (0x87), (0xCF) };
this.Base58Prefixes[(int)Base58Type.EXT_SECRET_KEY] = new byte[] { (0x04), (0x35), (0x83), (0x94) };
this.Base58Prefixes[(int)Base58Type.PASSPHRASE_CODE] = new byte[] { 0x2C, 0xE9, 0xB3, 0xE1, 0xFF, 0x39, 0xE2 };
this.Base58Prefixes[(int)Base58Type.CONFIRMATION_CODE] = new byte[] { 0x64, 0x3B, 0xF6, 0xA8, 0x9A };
this.Base58Prefixes[(int)Base58Type.STEALTH_ADDRESS] = new byte[] { 0x2b };
this.Base58Prefixes[(int)Base58Type.ASSET_ID] = new byte[] { 115 };
this.Base58Prefixes[(int)Base58Type.COLORED_ADDRESS] = new byte[] { 0x13 };
Bech32Encoder encoder = Encoders.Bech32("tb");
this.Bech32Encoders = new Bech32Encoder[2];
this.Bech32Encoders[(int)Bech32Type.WITNESS_PUBKEY_ADDRESS] = encoder;
this.Bech32Encoders[(int)Bech32Type.WITNESS_SCRIPT_ADDRESS] = encoder;
this.Checkpoints = new Dictionary <int, CheckpointInfo>();
this.DNSSeeds = new List <DNSSeedData>();
this.SeedNodes = new List <NetworkAddress>();
this.StandardScriptsRegistry = new SmartContractsStandardScriptsRegistry();
// TODO: Do we need Asserts for block hash
this.RegisterRules(this.Consensus);
this.RegisterMempoolRules(this.Consensus);
}
public NetworkBuilder SetBech32(Bech32Type type, string humanReadablePart)
{
_Bech32Prefixes.AddOrReplace(type, Encoders.Bech32(humanReadablePart));
return(this);
}
/// <summary>
/// Took the 'InitReg' from above and adjusted it slightly (set a static flag + removed the hash check)
/// </summary>
public SmartContractsRegTest()
{
this.Name = "SmartContractsRegTest";
this.RootFolderName = StratisMain.StratisRootFolderName;
this.DefaultConfigFilename = StratisMain.StratisDefaultConfigFilename;
this.Magic = 0xDAB5BFFA;
this.DefaultPort = 18444;
this.RPCPort = 18332;
this.MaxTipAge = BitcoinMain.BitcoinDefaultMaxTipAgeInSeconds;
this.MinTxFee = 1000;
this.FallbackFee = 20000;
this.MinRelayTxFee = 1000;
this.MaxTimeOffsetSeconds = 25 * 60;
var consensusFactory = new SmartContractPowConsensusFactory();
Block genesisBlock = BitcoinMain.CreateBitcoinGenesisBlock(consensusFactory, 1296688602, 2, 0x207fffff, 1, Money.Coins(50m));
((SmartContractBlockHeader)genesisBlock.Header).HashStateRoot = new uint256("21B463E3B52F6201C0AD6C991BE0485B6EF8C092E64583FFA655CC1B171FE856");
this.Genesis = genesisBlock;
// Taken from StratisX.
var consensusOptions = new PosConsensusOptions(
maxBlockBaseSize: 1_000_000,
maxStandardVersion: 2,
maxStandardTxWeight: 100_000,
maxBlockSigopsCost: 20_000
);
var buriedDeployments = new BuriedDeploymentsArray
{
[BuriedDeployments.BIP34] = 100000000,
[BuriedDeployments.BIP65] = 100000000,
[BuriedDeployments.BIP66] = 100000000
};
var bip9Deployments = new BIP9DeploymentsArray
{
[BIP9Deployments.TestDummy] = new BIP9DeploymentsParameters(28, 0, 999999999),
[BIP9Deployments.CSV] = new BIP9DeploymentsParameters(0, 0, 999999999),
[BIP9Deployments.Segwit] = new BIP9DeploymentsParameters(1, BIP9DeploymentsParameters.AlwaysActive, 999999999)
};
this.Consensus = new NBitcoin.Consensus(
consensusFactory: consensusFactory,
consensusOptions: consensusOptions,
coinType: default(int),
hashGenesisBlock: genesisBlock.Header.GetHash(),
subsidyHalvingInterval: 150,
majorityEnforceBlockUpgrade: 750,
majorityRejectBlockOutdated: 950,
majorityWindow: 1000,
buriedDeployments: buriedDeployments,
bip9Deployments: bip9Deployments,
bip34Hash: new uint256(),
ruleChangeActivationThreshold: 108, // 95% of 2016
minerConfirmationWindow: 144, // nPowTargetTimespan / nPowTargetSpacing
maxReorgLength: 500,
defaultAssumeValid: null, // turn off assumevalid for regtest.
maxMoney: long.MaxValue,
coinbaseMaturity: 5,
premineHeight: default(long),
premineReward: Money.Zero,
proofOfWorkReward: Money.Coins(50),
powTargetTimespan: TimeSpan.FromSeconds(14 * 24 * 60 * 60), // two weeks
powTargetSpacing: TimeSpan.FromSeconds(10 * 60),
powAllowMinDifficultyBlocks: true,
powNoRetargeting: true,
powLimit: new Target(new uint256("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
minimumChainWork: uint256.Zero,
isProofOfStake: default(bool),
lastPowBlock: default(int),
proofOfStakeLimit: null,
proofOfStakeLimitV2: null,
proofOfStakeReward: Money.Zero
);
Assert(this.Consensus.HashGenesisBlock == uint256.Parse("93867319cf92c86f957a9652c1fbe7cc8cbe70c53a915ac96ee7c59cb80f94b4"));
this.Base58Prefixes = new byte[12][];
this.Base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS] = new byte[] { (111) };
this.Base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS] = new byte[] { (196) };
this.Base58Prefixes[(int)Base58Type.SECRET_KEY] = new byte[] { (239) };
this.Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_NO_EC] = new byte[] { 0x01, 0x42 };
this.Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_EC] = new byte[] { 0x01, 0x43 };
this.Base58Prefixes[(int)Base58Type.EXT_PUBLIC_KEY] = new byte[] { (0x04), (0x35), (0x87), (0xCF) };
this.Base58Prefixes[(int)Base58Type.EXT_SECRET_KEY] = new byte[] { (0x04), (0x35), (0x83), (0x94) };
this.Base58Prefixes[(int)Base58Type.PASSPHRASE_CODE] = new byte[] { 0x2C, 0xE9, 0xB3, 0xE1, 0xFF, 0x39, 0xE2 };
this.Base58Prefixes[(int)Base58Type.CONFIRMATION_CODE] = new byte[] { 0x64, 0x3B, 0xF6, 0xA8, 0x9A };
this.Base58Prefixes[(int)Base58Type.STEALTH_ADDRESS] = new byte[] { 0x2b };
this.Base58Prefixes[(int)Base58Type.ASSET_ID] = new byte[] { 115 };
this.Base58Prefixes[(int)Base58Type.COLORED_ADDRESS] = new byte[] { 0x13 };
Bech32Encoder encoder = Encoders.Bech32("tb");
this.Bech32Encoders = new Bech32Encoder[2];
this.Bech32Encoders[(int)Bech32Type.WITNESS_PUBKEY_ADDRESS] = encoder;
this.Bech32Encoders[(int)Bech32Type.WITNESS_SCRIPT_ADDRESS] = encoder;
this.Checkpoints = new Dictionary <int, CheckpointInfo>();
this.DNSSeeds = new List <DNSSeedData>();
this.SeedNodes = new List <NetworkAddress>();
}
internal FederatedPegRegTest()
{
this.Name = FederatedPegNetwork.RegTestNetworkName;
this.CoinTicker = FederatedPegNetwork.TestCoinSymbol;
this.Magic = 0x522357C;
this.DefaultPort = 26179;
this.DefaultMaxOutboundConnections = 16;
this.DefaultMaxInboundConnections = 109;
this.RPCPort = 26175;
this.MaxTipAge = 2 * 60 * 60;
this.MinTxFee = 10000;
this.FallbackFee = 10000;
this.MinRelayTxFee = 10000;
this.RootFolderName = NetworkRootFolderName;
this.DefaultConfigFilename = NetworkDefaultConfigFilename;
this.MaxTimeOffsetSeconds = 25 * 60;
var consensusFactory = new SmartContractPoAConsensusFactory();
// Create the genesis block.
this.GenesisTime = 1513622125;
this.GenesisNonce = 1560058197;
this.GenesisBits = 402691653;
this.GenesisVersion = 1;
this.GenesisReward = Money.Zero;
Block genesisBlock = FederatedPegNetwork.CreateGenesis(consensusFactory, this.GenesisTime, this.GenesisNonce, this.GenesisBits, this.GenesisVersion, this.GenesisReward);
this.Genesis = genesisBlock;
this.FederationMnemonics = new[] {
"ensure feel swift crucial bridge charge cloud tell hobby twenty people mandate",
"quiz sunset vote alley draw turkey hill scrap lumber game differ fiction",
"exchange rent bronze pole post hurry oppose drama eternal voice client state"
}.Select(m => new Mnemonic(m, Wordlist.English)).ToList();
this.FederationKeys = this.FederationMnemonics.Select(m => m.DeriveExtKey().PrivateKey).ToList();
var federationPubKeys = this.FederationKeys.Select(k => k.PubKey).ToList();
var consensusOptions = new PoAConsensusOptions(
maxBlockBaseSize: 1_000_000,
maxStandardVersion: 2,
maxStandardTxWeight: 100_000,
maxBlockSigopsCost: 20_000,
maxStandardTxSigopsCost: 20_000 / 5,
federationPublicKeys: federationPubKeys,
targetSpacingSeconds: 4 // For integration tests - avoid FastMining
);
var buriedDeployments = new BuriedDeploymentsArray
{
[BuriedDeployments.BIP34] = 0,
[BuriedDeployments.BIP65] = 0,
[BuriedDeployments.BIP66] = 0
};
var bip9Deployments = new NoBIP9Deployments();
this.Consensus = new Consensus(
consensusFactory: consensusFactory,
consensusOptions: consensusOptions,
coinType: 400,
hashGenesisBlock: genesisBlock.GetHash(),
subsidyHalvingInterval: 210000,
majorityEnforceBlockUpgrade: 750,
majorityRejectBlockOutdated: 950,
majorityWindow: 1000,
buriedDeployments: buriedDeployments,
bip9Deployments: bip9Deployments,
bip34Hash: new uint256("0x000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8"),
ruleChangeActivationThreshold: 1916, // 95% of 2016
minerConfirmationWindow: 2016, // nPowTargetTimespan / nPowTargetSpacing
maxReorgLength: 0, // No max reorg limit on PoA networks.
defaultAssumeValid: null,
maxMoney: Money.Coins(20_000_000),
coinbaseMaturity: 1,
premineHeight: 2,
premineReward: Money.Coins(20_000_000),
proofOfWorkReward: Money.Coins(0),
powTargetTimespan: TimeSpan.FromDays(14), // two weeks
powTargetSpacing: TimeSpan.FromMinutes(1),
powAllowMinDifficultyBlocks: false,
powNoRetargeting: true,
powLimit: null,
minimumChainWork: null,
isProofOfStake: false,
lastPowBlock: 0,
proofOfStakeLimit: null,
proofOfStakeLimitV2: null,
proofOfStakeReward: Money.Zero
);
// Same as current smart contracts test networks to keep tests working
this.Base58Prefixes = new byte[12][];
this.Base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS] = new byte[] { 55 }; // P
this.Base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS] = new byte[] { 117 }; // p
this.Base58Prefixes[(int)Base58Type.SECRET_KEY] = new byte[] { (239) };
this.Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_NO_EC] = new byte[] { 0x01, 0x42 };
this.Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_EC] = new byte[] { 0x01, 0x43 };
this.Base58Prefixes[(int)Base58Type.EXT_PUBLIC_KEY] = new byte[] { (0x04), (0x35), (0x87), (0xCF) };
this.Base58Prefixes[(int)Base58Type.EXT_SECRET_KEY] = new byte[] { (0x04), (0x35), (0x83), (0x94) };
this.Base58Prefixes[(int)Base58Type.PASSPHRASE_CODE] = new byte[] { 0x2C, 0xE9, 0xB3, 0xE1, 0xFF, 0x39, 0xE2 };
this.Base58Prefixes[(int)Base58Type.CONFIRMATION_CODE] = new byte[] { 0x64, 0x3B, 0xF6, 0xA8, 0x9A };
this.Base58Prefixes[(int)Base58Type.STEALTH_ADDRESS] = new byte[] { 0x2b };
this.Base58Prefixes[(int)Base58Type.ASSET_ID] = new byte[] { 115 };
this.Base58Prefixes[(int)Base58Type.COLORED_ADDRESS] = new byte[] { 0x13 };
Bech32Encoder encoder = Encoders.Bech32("tb");
this.Bech32Encoders = new Bech32Encoder[2];
this.Bech32Encoders[(int)Bech32Type.WITNESS_PUBKEY_ADDRESS] = encoder;
this.Bech32Encoders[(int)Bech32Type.WITNESS_SCRIPT_ADDRESS] = encoder;
this.Checkpoints = new Dictionary <int, CheckpointInfo>();
this.DNSSeeds = new List <DNSSeedData>();
this.SeedNodes = new List <NetworkAddress>();
// TODO: Do we need Asserts for block hash
}