protected override NetworkBuilder CreateTestnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 100000,
MajorityEnforceBlockUpgrade = 501,
MajorityRejectBlockOutdated = 750,
MajorityWindow = 1000,
PowLimit = new Target(new uint256("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
// pre-post-digishield https://github.com/dogecoin/dogecoin/blob/10a5e93a055ab5f239c5447a5fe05283af09e293/src/chainparams.cpp#L45
PowTargetTimespan = TimeSpan.FromSeconds(60),
PowTargetSpacing = TimeSpan.FromSeconds(60),
PowAllowMinDifficultyBlocks = true,
CoinbaseMaturity = 240,
// Not set in reference client, assuming false
PowNoRetargeting = false,
//RuleChangeActivationThreshold = 6048,
//MinerConfirmationWindow = 8064,
LitecoinWorkCalculation = true,
ConsensusFactory = DogeConsensusFactory.Instance,
SupportSegwit = false
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 113 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 196 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 241 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x35, 0x87, 0xCF })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x35, 0x83, 0x94 })
.SetNetworkStringParser(new DogecoinTestnetAddressStringParser())
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("tdoge"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("tdoge"))
.SetMagic(0xdcb7c1fc)
.SetPort(44556)
.SetRPCPort(22555)
.SetName("doge-test")
.AddAlias("doge-testnet")
.AddAlias("dogecoin-test")
.AddAlias("dogecoin-testnet")
.SetUriScheme("dogecoin")
.AddDNSSeeds(new[]
{
new DNSSeedData("jrn.me.uk", "testseed.jrn.me.uk")
})
.AddSeeds(new NetworkAddress[0])
.SetGenesis("010000000000000000000000000000000000000000000000000000000000000000000000696ad20e2dd4365c7459b4a4a5af743d5e92c6da3229e6532cd605f6533f2a5bb9a7f052f0ff0f1ef7390f000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff1004ffff001d0104084e696e746f6e646fffffffff010058850c020000004341040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9ac00000000");
return(builder);
}
protected override NetworkBuilder CreateMainnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 262800,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
BIP34Hash = new uint256("0x00000cd6bde619b2c3b23ad2e384328a450a37fa28731debf748c3b17f91f97d"),
PowLimit = new Target(new uint256("0x00000fffff000000000000000000000000000000000000000000000000000000")),
MinimumChainWork = new uint256("0x0000000000000000000000000000000000000000000000000047a222baa2d1fe"),
PowTargetTimespan = TimeSpan.FromSeconds(24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(2 * 60),
PowAllowMinDifficultyBlocks = false,
CoinbaseMaturity = 100,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 1916,
MinerConfirmationWindow = 2016,
ConsensusFactory = GincoinConsensusFactory.Instance,
SupportSegwit = false
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 38 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 10 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 198 })
.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("gin"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("gin"))
.SetMagic(0xBD6B0CBF)
.SetPort(10111)
.SetRPCPort(10211)
.SetMaxP2PVersion(70208)
.SetName("gincoin-main")
.AddAlias("gincoin-mainnet")
.AddDNSSeeds(new[]
{
new DNSSeedData("gincoin.io", "seed1.gincoin.io"),
new DNSSeedData("seed2.gincoin.io", "seed2.gincoin.io"),
new DNSSeedData("seed3.gincoin.io", "seed3.gincoin.io"),
new DNSSeedData("seed4.gincoin.io", "seed4.gincoin.io"),
new DNSSeedData("seed5.gincoin.io", "seed5.gincoin.io")
})
.AddSeeds(new NetworkAddress[0])
.SetGenesis("0100000000000000000000000000000000000000000000000000000000000000000000005e0a079fb1b3af615b69a59944f734c6d2e491d98024fe8c3067e175cb8318158c368f5af0ff0f1e543300000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4904ffff001d01044154686520477561726469616e2032322d4665622d32303138204e5241206865616420627265616b732073696c656e636520746f2061747461636b2067756e2e2e2effffffff0100943577000000004341044f1443283e594f9a087e02aeceef6c2cac0d651f65c82cea13b929240a73f380e708f5922225ae4551749a7db28c742758f44877fd4ba527789481f3733d61b1ac00000000");
return(builder);
}
protected override NetworkBuilder CreateMainnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus
{
SubsidyHalvingInterval = 210000,
MajorityEnforceBlockUpgrade = 8100,
MajorityRejectBlockOutdated = 10260,
MajorityWindow = 10800,
BIP34Hash = new uint256("000000cb303fa18385fca0610ce525db98f32a5f55f5cd9bf5ff83d88b537915"),
PowLimit = new Target(0 >> 1),
MinimumChainWork = new uint256("000000000000000000000000000000000000000000000000c2ba8ca4fb1f06cb"),
PowTargetTimespan = TimeSpan.FromSeconds(24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(1 * 60),
PowAllowMinDifficultyBlocks = true,
CoinbaseMaturity = 30,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 1916,
MinerConfirmationWindow = 2016,
ConsensusFactory = DogeCashConsensusFactory.Instance,
SupportSegwit = false,
CoinType = 385
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 31 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 19 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 122 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x02, 0x2D, 0x25, 0x33 })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x02, 0x21, 0x31, 0x2B })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("DogeCash"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("DogeCash"))
.SetMagic(0x191643a0)
.SetPort(56740)
.SetRPCPort(51573)
.SetMaxP2PVersion(70920)
.SetName("DogeCash-main")
.AddAlias("DogeCash-mainnet")
.AddDNSSeeds(new[]
{
new DNSSeedData("dogec1", "seeds.dogec.io"),
new DNSSeedData("dogec2", "x9.seeds.dogec.io"),
new DNSSeedData("dogec3", "testseeds.dogec.io")
})
.AddSeeds(new NetworkAddress[0])
.SetGenesis("01000000000000000000000000000000000000000000000000000000000000000000000014e427b75837280517873799a954e87b8b0484f3f1df927888a0ff4fd3a0c9f7bb2eac56f0ff0f1edfa624000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff8604ffff001d01044c7d323031372d30392d32312032323a30313a3034203a20426974636f696e20426c6f636b204861736820666f722048656967687420343836333832203a2030303030303030303030303030303030303039326431356535623365366538323639333938613834613630616535613264626434653766343331313939643033ffffffff0100ba1dd205000000434104c10e83b2703ccf322f7dbd62dd5855ac7c10bd055814ce121ba32607d573b8810c02c0582aed05b4deb9c4b77b26d92428c61256cd42774babea0a073b2ed0c9ac00000000");
return(builder);
}
protected override NetworkBuilder CreateMainnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 1569325056,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
BIP34Hash = new uint256("0x000001f35e70f7c5705f64c6c5cc3dea9449e74d5b5c7cf74dad1bcca14a8012"),
PowLimit = new Target(new uint256("0x00000fffff000000000000000000000000000000000000000000000000000000")),
MinimumChainWork = new uint256("0x000000000000000000000000000000000000000000000000e72e9b868ce8efb7"),
PowTargetTimespan = TimeSpan.FromSeconds(24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(2 * 60),
PowAllowMinDifficultyBlocks = false,
CoinbaseMaturity = 15,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 1916,
MinerConfirmationWindow = 2016,
HashGenesisBlock = new uint256("0x000009701eb781a8113b1af1d814e2f060f6408a2c990db291bc5108a1345c1e"),
ConsensusFactory = new PolisConsensusFactory(),
SupportSegwit = false
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 55 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 56 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 60 })
.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("polis"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("polis"))
.SetMagic(0xBD6B0CBF)
.SetPort(24126)
.SetRPCPort(24127)
.SetMaxP2PVersion(70208)
.SetName("polis-main")
.AddAlias("polis-mainnet")
.AddDNSSeeds(new[]
{
new DNSSeedData("node1.polispay.org", "node1.polispay.org"),
new DNSSeedData("polis.seeds.mn.zone", "polis.seeds.mn.zone"),
new DNSSeedData("polis.mnseeds.com", "polis.mnseeds.com"),
new DNSSeedData("node2.polispay.org", "node2.polispay.org")
})
.AddSeeds(new NetworkAddress[0])
.SetGenesis("010000000000000000000000000000000000000000000000000000000000000000000000fc4b8cb903aed54e11e1ae8a5b7ad097ade34988a84500ad2d80e4d1f5bcc95d2bb73b5af0ff0f1edbff04000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2404ffff001d01041c506f6c69732c2066726f6d2070656f706c6520746f2070656f706c65ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000");
return(builder);
}
protected override NetworkBuilder CreateMainnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 100000,
MajorityEnforceBlockUpgrade = 1500,
MajorityRejectBlockOutdated = 1900,
MajorityWindow = 2000,
PowLimit = new Target(new uint256("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(4 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(60),
PowAllowMinDifficultyBlocks = false,
CoinbaseMaturity = 30,
// Not set in reference client, assuming false
PowNoRetargeting = false,
//RuleChangeActivationThreshold = 6048,
//MinerConfirmationWindow = 8064,
ConsensusFactory = DogeConsensusFactory.Instance,
LitecoinWorkCalculation = true,
SupportSegwit = false
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 30 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 22 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 158 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x02, 0xFA, 0xCA, 0xFD })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x02, 0xFA, 0xC3, 0x98 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("doge"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("doge"))
.SetMagic(0xc0c0c0c0)
.SetPort(22556)
.SetRPCPort(22555)
.SetName("doge-main")
.AddAlias("doge-mainnet")
.AddAlias("dogecoin-mainnet")
.AddAlias("dogecoin-main")
.AddDNSSeeds(new[]
{
new DNSSeedData("dogecoin.com", "seed.dogecoin.com"),
new DNSSeedData("multidoge.org", "seed.multidoge.org"),
new DNSSeedData("multidoge.org", "seed.multidoge.org"),
new DNSSeedData("doger.dogecoin.com", "seed.doger.dogecoin.com")
})
.AddSeeds(new NetworkAddress[0])
.SetGenesis("010000000000000000000000000000000000000000000000000000000000000000000000696ad20e2dd4365c7459b4a4a5af743d5e92c6da3229e6532cd605f6533f2a5b24a6a152f0ff0f1e678601000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff1004ffff001d0104084e696e746f6e646fffffffff010058850c020000004341040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9ac00000000");
return(builder);
}
protected override NetworkBuilder CreateMainnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 210240,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
BIP34Hash = new uint256("0x000007d91d1254d60e2dd1ae580383070a4ddffa4c64c2eeb4a2f9ecc0414343"),
PowLimit = new Target(new uint256("0x000007d91d1254d60e2dd1ae580383070a4ddffa4c64c2eeb4a2f9ecc0414343")),
MinimumChainWork = new uint256("0x000000000000000000000000000000000000000000000100a308553b4863b755"),
PowTargetTimespan = TimeSpan.FromSeconds(24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(2.5 * 60),
PowAllowMinDifficultyBlocks = false,
CoinbaseMaturity = 30,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 1916,
MinerConfirmationWindow = 2016,
HashGenesisBlock = new uint256("0x00000ffd590b1485b3caadc19b22e6379c733355108f107a430458cdf3407ab6"),
ConsensusFactory = new DashConsensusFactory(),
SupportSegwit = false
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 76 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 16 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 204 })
.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("dash"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("dash"))
.SetMagic(0xBD6B0CBF)
.SetPort(9999)
.SetRPCPort(9998)
.SetMaxP2PVersion(70208)
.SetName("dash-main")
.AddAlias("dash-mainnet")
.AddDNSSeeds(new[]
{
new DNSSeedData("dash.org", "dnsseed.dash.org"),
new DNSSeedData("dashdot.io", "dnsseed.dashdot.io"),
new DNSSeedData("masternode.io", "dnsseed.masternode.io"),
new DNSSeedData("dashpay.io", "dnsseed.dashpay.io")
})
.AddSeeds(new NetworkAddress[0])
.SetGenesis("010000000000000000000000000000000000000000000000000000000000000000000000c762a6567f3cc092f0684bb62b7e00a84890b990f07cc71a6bb58d64b98e02e0022ddb52f0ff0f1ec23fb9010101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff6204ffff001d01044c5957697265642030392f4a616e2f3230313420546865204772616e64204578706572696d656e7420476f6573204c6976653a204f76657273746f636b2e636f6d204973204e6f7720416363657074696e6720426974636f696e73ffffffff0100f2052a010000004341040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9ac00000000");
return(builder);
}
private static Network InitLLCoin()
{
Block.BlockSignature = true;
Transaction.TimeStamp = true;
var consensus = Network.StratisMain.Consensus.Clone();
consensus.PowLimit = new Target(uint256.Parse("0x000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));
// The message start string is designed to be unlikely to occur in normal data.
// The characters are rarely used upper ASCII, not valid as UTF-8, and produce
// a large 4-byte int at any alignment.
var pchMessageStart = new byte[4];
pchMessageStart[0] = 0x71;
pchMessageStart[1] = 0x31;
pchMessageStart[2] = 0x21;
pchMessageStart[3] = 0x11;
var magic = BitConverter.ToUInt32(pchMessageStart, 0); //0x5223570;
//var genesis = Network.StratisMain.GetGenesis().Clone();
var genesis = CreateStratisGenesisBlock(1496069495, 1840204, consensus.PowLimit, 1, Money.Zero);
consensus.HashGenesisBlock = genesis.GetHash();
Guard.Assert(consensus.HashGenesisBlock == uint256.Parse("0x0002c75e4179fd8dc22391536af7e647bdd88b83d9ed57fcf09e5ae3d06cae78"));
var builder = new NetworkBuilder()
.SetName("LLCoin")
.SetConsensus(consensus)
.SetMagic(magic)
.SetGenesis(genesis)
.SetPort(36178)
.SetRPCPort(36174)
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { (63) })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { (125) })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { (63 + 125) })
.SetBase58Bytes(Base58Type.ENCRYPTED_SECRET_KEY_NO_EC, new byte[] { 0x01, 0x42 })
.SetBase58Bytes(Base58Type.ENCRYPTED_SECRET_KEY_EC, new byte[] { 0x01, 0x43 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { (0x04), (0x88), (0xC2), (0x1E) })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { (0x04), (0x88), (0xB2), (0xDD) })
.AddDNSSeeds(new[]
{
new DNSSeedData("stratisplatform.com", "testnode1.stratisplatform.com"),
});
return(builder.BuildAndRegister());
}
protected override NetworkBuilder CreateMainnet()
{
NetworkBuilder builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 420000,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
BIP34Hash = new uint256("000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8"),
PowLimit = new Target(new uint256("00ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(10 * 60),
PowAllowMinDifficultyBlocks = false,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 1916,
MinerConfirmationWindow = 2016,
CoinbaseMaturity = 100,
ConsensusFactory = ZCoinConsensusFactory.Instance
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 82 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 07 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 210 })
.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("xzc"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("xzc"))
.SetMagic(0xF1FED9E3) //defined in inverted direction, 0xF9BEB4D9
.SetPort(8168)
.SetRPCPort(8888)
.SetMaxP2PVersion(80000)
.SetName("xzc-main")
.AddAlias("xzc-mainnet")
.AddAlias("zcoin-mainnet")
.AddAlias("zcoin-main")
.AddDNSSeeds(new[]
{
new DNSSeedData("amsterdam.zcoin.io", "amsterdam.zcoin.io"),
new DNSSeedData("australia.zcoin.io", "australia.zcoin.io"),
new DNSSeedData("chicago.zcoin.io", "chicago.zcoin.io"),
new DNSSeedData("london.zcoin.io", "london.zcoin.io"),
new DNSSeedData("frankfurt.zcoin.io", "frankfurt.zcoin.io")
})
.AddSeeds(ToSeed(pnSeed6_main))
.SetGenesis("0200000000000000000000000000000000000000000000000000000000000000000000008327a4aae5254fd54eafc4b74b3b1e6b718539acabfdaec97013065da72a5d36dec55354f0ff0f1e382c02000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff5a04f0ff0f1e01044c4c54696d657320323031342f31302f3331204d61696e65204a756467652053617973204e75727365204d75737420466f6c6c6f772045626f6c612051756172616e74696e6520666f72204e6f7704823f0000ffffffff0100000000000000000000000000");
return(builder);
}
protected override NetworkBuilder CreateMainnet()
{
NetworkBuilder builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 657000,
MajorityEnforceBlockUpgrade = 15000,
MajorityRejectBlockOutdated = 19000,
MajorityWindow = 20000,
BIP34Hash = new uint256("4e9b54001f9976049830128ec0331515eaabe35a70970d79971da1539a400ba1"),
PowLimit = new Target(new uint256("000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(14 * 24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(1 * 24),
PowAllowMinDifficultyBlocks = false,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 8100,
MinerConfirmationWindow = 10800,
CoinbaseMaturity = 30,
HashGenesisBlock = new uint256("4e9b54001f9976049830128ec0331515eaabe35a70970d79971da1539a400ba1"),
LitecoinWorkCalculation = true,
ConsensusFactory = ViacoinConsensusFactory.Instance
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 71 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 33 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 176 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x04, 0x88, 0xB2, 0x1E })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x04, 0x88, 0xAD, 0xE4 })
//.SetNetworkStringParser(new ViacoinMainnetAddressStringParser())
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("via"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("via"))
.SetMagic(0xcbc6680f)
.SetPort(5223)
.SetRPCPort(5222)
.SetName("via-main")
.AddAlias("via-mainnet")
.AddAlias("viacoin-mainnet")
.AddAlias("viacoin-main")
.AddDNSSeeds(new[]
{
new DNSSeedData("viacoin.net", "seed.viacoin.net"),
new DNSSeedData("barbatos.fr", "viaseeder.barbatos.fr"),
new DNSSeedData("viacoin.net", "mainnet.viacoin.net"),
})
.AddSeeds(ToSeed(pnSeed6_main))
.SetGenesis("010000000000000000000000000000000000000000000000000000000000000000000000d9ced4ed1130f7b7faad9be25323ffafa33232a17c3edf6cfd97bee6bafbdd97b9aa8e4ef0ff0f1ecd513f7c0101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4804ffff001d0104404e592054696d65732030352f4f63742f32303131205374657665204a6f62732c204170706c65e280997320566973696f6e6172792c2044696573206174203536ffffffff0100f2052a010000004341040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9ac00000000");
return(builder);
}
protected override NetworkBuilder CreateMainnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus
{
SubsidyHalvingInterval = 210000,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
BIP34Hash = new uint256("00000f4fb42644a07735beea3647155995ab01cf49d05fdc082c08eb673433f9"),
PowLimit = new Target(0 >> 1),
MinimumChainWork = new uint256("000000000000000000000000000000000000000000000000010b219afffe4a8b"),
PowTargetTimespan = TimeSpan.FromSeconds(24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(1 * 60),
PowAllowMinDifficultyBlocks = false,
CoinbaseMaturity = 30,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 1916,
MinerConfirmationWindow = 2016,
ConsensusFactory = ColossusConsensusFactory.Instance,
SupportSegwit = false,
CoinType = 222
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 30 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 13 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 212 })
.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("Colossus"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("Colossus"))
.SetMagic(0xEAFEC591)
.SetPort(51572)
.SetRPCPort(51473)
.SetMaxP2PVersion(70910)
.SetName("colossus-main")
.AddAlias("colossus-mainnet")
.AddDNSSeeds(new[]
{
new DNSSeedData("colx1", "seed.colossuscoinxt.org"),
new DNSSeedData("colx2", "seed.colossusxt.org"),
new DNSSeedData("colx3", "seed.colxt.net")
})
.AddSeeds(new NetworkAddress[0])
.SetGenesis("01000000000000000000000000000000000000000000000000000000000000000000000014e427b75837280517873799a954e87b8b0484f3f1df927888a0ff4fd3a0c9f7bb2eac56f0ff0f1edfa624000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff8604ffff001d01044c7d323031372d30392d32312032323a30313a3034203a20426974636f696e20426c6f636b204861736820666f722048656967687420343836333832203a2030303030303030303030303030303030303039326431356535623365366538323639333938613834613630616535613264626434653766343331313939643033ffffffff0100ba1dd205000000434104c10e83b2703ccf322f7dbd62dd5855ac7c10bd055814ce121ba32607d573b8810c02c0582aed05b4deb9c4b77b26d92428c61256cd42774babea0a073b2ed0c9ac00000000");
return(builder);
}
protected override NetworkBuilder CreateMainnet()
{
NetworkBuilder builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 210000,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
BIP34Hash = new uint256("604148281e5c4b7f2487e5d03cd60d8e6f69411d613f6448034508cea52e9574"),
PowLimit = new Target(new uint256("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(3.5 * 24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(2.5 * 60),
PowAllowMinDifficultyBlocks = false,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 250,
MinerConfirmationWindow = 1000,
CoinbaseMaturity = 100,
ConsensusFactory = BitcoreConsensusFactory.Instance
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 03 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 125 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 128 })
.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("btx"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("btx"))
.SetMagic(0xD9B4BEF9) //defined in inverted direction, 0xF9BEB4D9
.SetPort(8555)
.SetRPCPort(8556)
.SetMaxP2PVersion(80000)
.SetName("btx-main")
.AddAlias("btx-mainnet")
.AddAlias("bitcore-mainnet")
.AddAlias("bitcore-main")
.AddDNSSeeds(new[]
{
new DNSSeedData("bitcore.biz", "seed.bitcore.biz"),
new DNSSeedData("37.120.190.76", "37.120.190.76"),
new DNSSeedData("37.120.186.85", "37.120.186.85"),
new DNSSeedData("185.194.140.60", "185.194.140.60"),
new DNSSeedData("188.71.223.206", "188.71.223.206")
})
.AddSeeds(ToSeed(pnSeed6_main))
.SetGenesis("01000000000000000000000000000000000000000000000000000000000000000000000000522753002939c78659b4fdc6ed56c6b6aacdc7586facf2f6ada2012ed31703842cc153ffff1f1e110304000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff5704ffff001d01044c4e426c6f636b20233331303337393a30303030303030303030303030303030323431323532613762623237626539376265666539323138633132393064666633366331666631323965633732313161ffffffff01000000000000000043410459934a6a228ce9716fa0b13aa1cdc01593fca5f8599473c803a5109ff834dfdaf4c9ee35f2218c9ee3e7cf7db734e1179524b9d6ae8ebbeba883d4cb89b6c7bfac00000000");
return(builder);
}
protected override NetworkBuilder CreateTestnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 210000,
MajorityEnforceBlockUpgrade = 51,
MajorityRejectBlockOutdated = 75,
MajorityWindow = 2016,
BIP34Hash = new uint256("0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8"),
PowLimit = new Target(new uint256("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(14 * 24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(10 * 60),
PowAllowMinDifficultyBlocks = true,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 1512,
MinerConfirmationWindow = 2016,
CoinbaseMaturity = 100,
MinimumChainWork = new uint256("00000000000000000000000000000000000000000000002888c34d61b53a244a"),
ConsensusFactory = BitcoinGoldConsensusFactory.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("tbtg"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("tbtg"))
.SetMagic(0x456e48e2)
.SetPort(18338)
.SetRPCPort(18337)
.SetMaxP2PVersion(70016)
.SetName("btg-test")
.AddAlias("btg-testnet")
.AddAlias("bitcoingold-test")
.AddAlias("bitcoingold-testnet")
.AddDNSSeeds(new[]
{
new DNSSeedData("bitcoingold-official.org", "eu-test-dnsseed.bitcoingold-official.org"),
new DNSSeedData("bitcoingold.org", "test-dnsseed.bitcoingold.org"),
new DNSSeedData("btcgpu.org", "test-dnsseed.btcgpu.org"),
})
.AddSeeds(new NetworkAddress[0])
.SetGenesis("0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a00000000000000000000000000000000000000000000000000000000000000007c355e5affff001d4251bd5600000000000000000000000000000000000000000000000000000000000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000");
return(builder);
}
protected override NetworkBuilder CreateMainnet()
{
NetworkBuilder builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 210000,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
BIP34Hash = new uint256("0x000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8"),
PowLimit = new Target(new uint256("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(14 * 24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(10 * 60),
PowAllowMinDifficultyBlocks = false,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 1916,
MinerConfirmationWindow = 2016,
CoinbaseMaturity = 100,
MinimumChainWork = new uint256("0000000000000000000000000000000000000000007e5dbf54c7f6b58a6853cd"),
ConsensusFactory = BitcoinGoldConsensusFactory.Instance,
SupportSegwit = true
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 38 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 23 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 128 })
.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("btg"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("btg"))
.SetMagic(0x446d47e1)
.SetPort(8338)
.SetRPCPort(8337)
.SetMaxP2PVersion(70016)
.SetName("btg-main")
.AddAlias("btg-mainnet")
.AddAlias("bitcoingold-mainnet")
.AddAlias("bitcoingold-main")
.AddDNSSeeds(new[]
{
new DNSSeedData("bitcoingold-official.org", "eu-dnsseed.bitcoingold-official.org"),
new DNSSeedData("bitcoingold.org", "dnsseed.bitcoingold.org"),
new DNSSeedData("btcgpu.org", "dnsseed.btcgpu.org"),
})
.AddSeeds(new NetworkAddress[0])
.SetGenesis("0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000000000000000000000000000000000000000000000000000000000000029ab5f49ffff001d1dac2b7c00000000000000000000000000000000000000000000000000000000000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000");
return(builder);
}
protected override NetworkBuilder CreateTestnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 210000,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
BIP34Hash = new uint256("0x000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8"),
PowLimit = new Target(
new uint256("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(14 * 24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(10 * 60),
PowAllowMinDifficultyBlocks = false,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 6048,
MinerConfirmationWindow = 8064,
CoinbaseMaturity = 100,
ConsensusFactory = WiccConsensusFactory.Instance
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 135 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 88 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 210 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x7d, 0x57, 0x3a, 0x2c })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x7d, 0x5c, 0x5a, 0x26 })
//.SetBase58Bytes(Base58Type.ACC_ADDRESS, new byte[] { 0 })
//.SetNetworkStringParser(new LitecoinMainnetAddressStringParser())
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("wicc"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("wicc"))
.SetMagic(0xD75C7DFD)
.SetPort(18921)
.SetRPCPort(18901)
.SetName("wicc-test")
.AddAlias("wicc-testnet")
.AddAlias("wiccoin-testnet")
.AddAlias("wiccoin-test")
.AddDNSSeeds(new[]
{
new DNSSeedData("n1.waykichain.net", "seed1.waykichain.net"),
new DNSSeedData("n2.waykichain.net", "seed2.waykichain.net"),
});
return(builder);
}
#pragma warning restore CS0618 // Type or member is obsolete
protected override NetworkBuilder CreateMainnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 400000,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
BIP34Hash = new uint256("966e30dd04d09232f6f690a04664cd3258abe43eeda2f2291d93706aa494aa54"),
PowLimit = new Target(new uint256("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(90),
PowAllowMinDifficultyBlocks = false,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 10080,
MinerConfirmationWindow = 13440,
CoinbaseMaturity = 100,
LitecoinWorkCalculation = true,
ConsensusFactory = UfoConsensusFactory.Instance,
SupportSegwit = true
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 27 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 68 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 155 })
.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("uf"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("uf"))
.SetMagic(0xddb7d9fc)
.SetPort(9887)
.SetRPCPort(9888)
.SetName("ufo-main")
.AddAlias("Ufo-mainnet")
.SetUriScheme("ufo")
.AddDNSSeeds(new[]
{
new DNSSeedData("Ufocoin.net", "seed1.ufocoin.net"),
new DNSSeedData("ufocoin.net", "seed2.ufocoin.net"),
new DNSSeedData("ufocoin.net", "seed3.ufocoin.net"),
new DNSSeedData("ufocoin.net", "seed4.ufocoin.net"),
})
.AddSeeds(ToSeed(pnSeed6_main))
.SetGenesis("010000000000000000000000000000000000000000000000000000000000000000000000d9ced4ed1130f7b7faad9be25323ffafa33232a17c3edf6cfd97bee6bafbdd97b9aa8e4ef0ff0f1ecd513f7c0101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4804ffff001d0104404e592054696d65732030352f4f63742f32303131205374657665204a6f62732c204170706c65e280997320566973696f6e6172792c2044696573206174203536ffffffff0100f2052a010000004341040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9ac00000000");
return(builder);
}
protected override NetworkBuilder CreateTestnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 210000,
MajorityEnforceBlockUpgrade = 51,
MajorityRejectBlockOutdated = 75,
MajorityWindow = 100,
BIP34Hash = new uint256(),
PowLimit = new Target(new uint256("0x3fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
MinimumChainWork = new uint256("0000000000000000000000000000000000000000000000008da8d3d2e63fb960"),
PowTargetTimespan = TimeSpan.FromSeconds(60),
PowTargetSpacing = TimeSpan.FromSeconds(60),
PowAllowMinDifficultyBlocks = true,
CoinbaseMaturity = 15,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 45,
MinerConfirmationWindow = 60,
ConsensusFactory = BlocknetConsensusFactory.Instance,
SupportSegwit = true
})
.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("tblock"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("tblock"))
.SetMagic(0xBA657645)
.SetPort(41474)
.SetRPCPort(41419)
.SetMaxP2PVersion(70713)
.SetName("blocknet-test")
.AddAlias("blocknet-testnet")
.AddDNSSeeds(new[]
{
new DNSSeedData("3.16.3.126", "3.16.3.126"),
new DNSSeedData("18.224.130.185", "18.224.130.185"),
new DNSSeedData("18.213.44.27", "18.213.44.27"),
new DNSSeedData("34.196.102.239", "34.196.102.239")
})
.AddSeeds(new NetworkAddress[0])
.SetGenesis("010000000000000000000000000000000000000000000000000000000000000000000000f26bb5a8606ca026d9c17f12b6e215812bbe33ab19073ac2f45af56d3fe9f0b16be2445cffff3f2002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff3d04ffff001d010435646563656e7472616c697a656420636f6e73656e7375732062617365642064656d6f63726163792069732074686520667574757265ffffffff0100ba1dd20500000043410452c91a00518fb8c6d38100341f88499554284d1ba75097cc25ae5a0d811835c63d2cb46c8855304bca81c452b63ce71fcb6897d06f8000450841f72602457f74ac00000000");
return(builder);
}
protected override NetworkBuilder CreateMainnet()
{
NetworkBuilder builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 1050000,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
BIP34Hash = new uint256("0x0000000000006a908847f2d6b7ac98e8ac9ce54c544aca63c66473e637f4741e"),
PowLimit = new Target(new uint256("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
MinimumChainWork = new uint256("0x00000000000000000000000000000000000000000013c31ec956b02ded0e535c"),
PowTargetTimespan = TimeSpan.FromSeconds(60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(2 * 60),
PowAllowMinDifficultyBlocks = false,
CoinbaseMaturity = 100,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 90,
MinerConfirmationWindow = 30,
ConsensusFactory = TerracoinConsensusFactory.Instance,
SupportSegwit = false
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 0 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 5 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 128 })
.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("trc"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("trc"))
.SetMagic(0x56BEBA42)
.SetPort(13333)
.SetRPCPort(13332)
.SetMaxP2PVersion(70208)
.SetName("trc-main")
.AddAlias("trc-mainnet")
.AddAlias("terracoin-main")
.AddAlias("terracoin-mainnet")
.AddDNSSeeds(new[]
{
new DNSSeedData("terracoin.io", "seed.terracoin.io"),
new DNSSeedData("southofheaven.ca", "dnsseed.southofheaven.ca")
})
.AddSeeds(new NetworkAddress[0])
.SetGenesis("01000000000000000000000000000000000000000000000000000000000000000000000096f12836f9a4d8029fea2c89ad06be01a9aaa6f3c3160c5867b00338f9098b0fbb538a50ffff001d2a841ba80101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4204ffff001d01043a4a756e65203474682031393738202d204d61726368203674682032303039203b205265737420496e2050656163652c205374657068616e69652effffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000");
return(builder);
}
protected override NetworkBuilder CreateMainnet()
{
NetworkBuilder builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 840000,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
BIP34Hash = new uint256("0x0007104ccda289427919efc39dc9e4d499804b7bebc22df55f8b834301260602"), // (Genesis)
PowLimit = new Target(new uint256("07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(14 * 24 * 60 * 60), //TODO ? - maxTipAge = 24 * 60 * 60
PowTargetSpacing = TimeSpan.FromSeconds(2.5 * 60),
PowAllowMinDifficultyBlocks = false,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 1916,
MinerConfirmationWindow = 2016,
CoinbaseMaturity = 100,
MinimumChainWork = new uint256("0000000000000000000000000000000000000000000000000002f67046eb6a34"),
ConsensusFactory = BitcoinPrivateConsensusFactory.Instance,
SupportSegwit = false // (For now)
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 0x13, 0x25 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 0x13, 0xAF })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 0x80 })
.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("btcp"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("btcp"))
.SetMagic(0xa8eaa2cd)
.SetPort(7933)
.SetRPCPort(7932)
.SetMaxP2PVersion(180004)
.SetName("btcp-main")
.AddAlias("btcp-mainnet")
.AddAlias("BitcoinPrivate-mainnet")
.AddAlias("BitcoinPrivate-main")
.AddDNSSeeds(new[]
{
new DNSSeedData("dnsseed.btcprivate.org", "dnsseed.btcprivate.org"),
new DNSSeedData("dnsseed.btcprivate.co", "dnsseed.btcprivate.co")
})
.AddSeeds(new NetworkAddress[0])
.SetGenesis("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");
return(builder);
}
protected override NetworkBuilder CreateMainnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 365 * 720,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
BIP34Hash = new uint256("0x000006ba48cbdecd71bc411a3e0b609f1acab9806fc652040f247c8b86831d06"),
PowLimit = new Target(new uint256("0x00000fffff000000000000000000000000000000000000000000000000000000")),
MinimumChainWork = new uint256("0x0000000000000000000000000000000000000000000000000000000000000000"),
PowTargetTimespan = TimeSpan.FromSeconds(60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(2 * 60),
PowAllowMinDifficultyBlocks = false,
CoinbaseMaturity = 101,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 1916,
MinerConfirmationWindow = 2016,
ConsensusFactory = MogwaiConsensusFactory.Instance,
SupportSegwit = false
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 50 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 16 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 204 })
.SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, new byte[] { 0x03, 0xA3, 0xFD, 0xC2 })
.SetBase58Bytes(Base58Type.EXT_SECRET_KEY, new byte[] { 0x03, 0xA3, 0xF9, 0x89 })
.SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32("mog"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("mog"))
.SetMagic(0xCACA7091)
.SetPort(17777)
.SetRPCPort(17710)
.SetMaxP2PVersion(70209)
.SetName("mogwai-main")
.AddAlias("mogwai-mainnet")
.AddDNSSeeds(new[]
{
new DNSSeedData("mogwaicoin.org", "dns-seed1.mogwaicoin.org"),
new DNSSeedData("mogwaicoin.org", "dns-seed2.mogwaicoin.org"),
new DNSSeedData("mogwaicoin.org", "dns-seed3.mogwaicoin.org"),
new DNSSeedData("mogwaicoin.org", "dns-seed4.mogwaicoin.org")
})
.AddSeeds(new NetworkAddress[0])
.SetGenesis("010000000000000000000000000000000000000000000000000000000000000000000000ced6de01d8d26ce7613669df2fc002d6f2138159744cf84d3c68d6245bb8989db0f62f5bf0ff0f1ea5060a000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4804ffff001d0104404279652d6279652c20576f6f6620576f6f662e20576520617265206d6f67776169732e20457870656374207573206f6e204a756e652032362028323031382921ffffffff0100c08f312e0000004341047d476d8fec5e400a30657039003432293111167dc8357d1c66bcc64b7903f8eb9e4332cc073bda542e98a763d59e56e1c65563d0401a88a532d2eebed29da1b3ac00000000");
return(builder);
}
protected override NetworkBuilder CreateMainnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 210240,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
BIP34Hash = new uint256("0x000007d91d1254d60e2dd1ae580383070a4ddffa4c64c2eeb4a2f9ecc0414343"),
PowLimit = new Target(new uint256("0x000007d91d1254d60e2dd1ae580383070a4ddffa4c64c2eeb4a2f9ecc0414343")),
MinimumChainWork = new uint256("0x000000000000000000000000000000000000000000000100a308553b4863b755"),
PowTargetTimespan = TimeSpan.FromSeconds(20 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(2 * 60),
PowAllowMinDifficultyBlocks = false,
CoinbaseMaturity = 10,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 1916,
MinerConfirmationWindow = 2016,
ConsensusFactory = ReexConsensusFactory.Instance,
SupportSegwit = true
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 61 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 122 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 189 })
.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("reex"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("reex"))
.SetMagic(0xBD6B0CBF)
.SetPort(43210)
.SetRPCPort(9998)
.SetMaxP2PVersion(70208)
.SetName("reex-main")
.AddAlias("reex-mainnet")
.AddDNSSeeds(new[]
{
new DNSSeedData("173.249.1.107", "173.249.1.107"),
new DNSSeedData("35.237.166.130", "35.237.166.130"),
new DNSSeedData("35.196.193.43", "35.196.193.43"),
new DNSSeedData("35.231.79.133", "35.231.79.133")
})
.AddSeeds(new NetworkAddress[0])
.SetGenesis("0000047d24635e347be3aaaeb66c26be94901a2f962feccd4f95090191f208c1");
return(builder);
}
private NetworkInterpreter CreateNetworkInterpreter(ITokenStream tokens)
{
Network network = NetworkBuilder <AlloySimplifiedAtnBuilder> .GetOrBuildNetwork();
NetworkInterpreter interpreter = new NetworkInterpreter(network, tokens);
RuleBinding memberSelectRule = network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.BinOpExpr18);
interpreter.BoundaryRules.Add(memberSelectRule);
//interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.LetDecl));
//interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.QuantDecls));
//interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.Decl));
////interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.NameList));
////interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.NameListName));
//interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.Ref));
//interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.Open));
//interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.FactDecl));
//interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.AssertDecl));
////interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.FunDecl));
////interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.FunctionName));
//interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.CmdDecl));
//interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.Typescope));
//interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.EnumDecl));
//interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.ElseClause));
//interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.Module));
interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.LetDecl));
interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.QuantDecls));
interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.Decl));
/* adding this rule definitely didn't help! */
//interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.Expr));
interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.Module));
interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.FactDeclHeader));
interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.AssertDeclHeader));
interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.FunFunctionName));
interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.PredFunctionName));
interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.FunctionReturn));
interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.SigDeclHeader));
interpreter.BoundaryRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.SigExt));
//interpreter.ExcludedStartRules.Add(network.GetRule(AlloySimplifiedAtnBuilder.RuleNames.CallArguments));
return(interpreter);
}
protected override NetworkBuilder CreateTestnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 525600,
MajorityEnforceBlockUpgrade = 51,
MajorityRejectBlockOutdated = 75,
MajorityWindow = 100,
BIP34Hash = new uint256("0x00000e91f3a63b1b81797a52348931a7078c0eba642bb79e64090cdf38764e83"),
PowLimit = new Target(new uint256("0x00000fffff000000000000000000000000000000000000000000000000000000")),
MinimumChainWork = new uint256("0x0000000000000000000000000000000000000000000000000000000000000000"),
PowTargetTimespan = TimeSpan.FromSeconds(24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(1 * 60),
PowAllowMinDifficultyBlocks = true,
CoinbaseMaturity = 100,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 1512,
MinerConfirmationWindow = 2016,
ConsensusFactory = ArgoneumConsensusFactory.Instance,
SupportSegwit = false
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 0x80 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 0x42 })
.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("targoneum"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("targoneum"))
.SetMagic(0x014d4741)
.SetPort(19898)
.SetRPCPort(19899)
.SetMaxP2PVersion(70215)
.SetName("argoneum-test")
.AddAlias("argoneum-testnet")
.AddDNSSeeds(new[]
{
new DNSSeedData("argoneum.net", "testnet-seed1.argoneum.net"),
new DNSSeedData("argoneum.net", "testnet-seed2.argoneum.net"),
})
.SetUriScheme("argoneum")
.AddSeeds(new NetworkAddress[0])
// FIXME
.SetGenesis("0100000000000000000000000000000000000000000000000000000000000000000000008413e4d942bcac7d58d727e5e9f45900e048966acec55bfa815bceb64c5ca4ed90dfd95bf0ff0f1ea36617000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4804ffff001d010440323031382f31312f30313a204172676f6e65756d2c20746865206d61737465726e6f646520736f6c7574696f6e7320706c6174666f726d2077617320626f726effffffff010000000000000000434104480f351d994e150563c3c686e25247513ccfcd98d8826fb450f164f9400659e50b066b6fc2d110b7ed61a27a2b932e3f4e5564da19716dd3e5d5fc0e4bfed625ac00000000");
return(builder);
}
protected override NetworkBuilder CreateTestnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 1052100,
MajorityEnforceBlockUpgrade = 51,
MajorityRejectBlockOutdated = 75,
MajorityWindow = 1000,
PowLimit = new Target(new uint256("00ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(1.1 * 24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(60),
PowAllowMinDifficultyBlocks = true,
PowNoRetargeting = false,
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("tgrs"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("tgrs"))
.SetMagic(0x0709110b)
.SetPort(17777)
.SetRPCPort(17766)
.SetName("groestl-test")
.AddAlias("groestl-testnet")
.AddAlias("groestlcoin-test")
.AddAlias("groestlcoin-testnet")
.AddDNSSeeds(new[]
{
new DNSSeedData("testnet1.groestlcoin.org", "testnet1.groestlcoin.org"),
new DNSSeedData("testnet2.groestlcoin.org", "testnet2.groestlcoin.org"),
new DNSSeedData("testp2pool.groestlcoin.org", "testp2pool.groestlcoin.org"),
new DNSSeedData("testp2pool2.groestlcoin.org", "testp2pool2.groestlcoin.org"),
})
.AddSeeds(ToSeed(pnSeed6_test))
.SetGenesis("030000000000000000000000000000000000000000000000000000000000000000000000bb2866aaca46c4428ad08b57bc9d1493abaf64724b6c3052a7c8f958df68e93c02a8d455ffff001e950a64000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff3a04ffff001d0104325072657373757265206d75737420626520707574206f6e20566c6164696d697220507574696e206f766572204372696d6561ffffffff010000000000000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000");
return(builder);
}
protected override NetworkBuilder CreateMainnet()
{
NetworkBuilder builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 657000,
MajorityEnforceBlockUpgrade = 15000,
MajorityRejectBlockOutdated = 19000,
MajorityWindow = 20000,
BIP34Hash = new uint256("4e9b54001f9976049830128ec0331515eaabe35a70970d79971da1539a400ba1"),
PowLimit = new Target(new uint256("000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(14 * 24 * 60 * 60),
PowTargetSpacing = TimeSpan.FromSeconds(1 * 24),
PowAllowMinDifficultyBlocks = false,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 8100,
MinerConfirmationWindow = 10800,
CoinbaseMaturity = 30,
LitecoinWorkCalculation = true,
ConsensusFactory = ViacoinConsensusFactory.Instance
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 71 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 33 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 199 })
.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("via"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("via"))
.SetMagic(0xcbc6680f)
.SetPort(5223)
.SetRPCPort(5222)
.SetName("via-main")
.AddAlias("via-mainnet")
.AddAlias("viacoin-mainnet")
.AddAlias("viacoin-main")
.AddDNSSeeds(new[]
{
new DNSSeedData("viacoin.net", "seed.viacoin.net"),
new DNSSeedData("barbatos.fr", "viaseeder.barbatos.fr"),
new DNSSeedData("viacoin.net", "mainnet.viacoin.net"),
})
.AddSeeds(ToSeed(pnSeed6_main))
.SetGenesis("01000000000000000000000000000000000000000000000000000000000000000000000000522753002939c78659b4fdc6ed56c6b6aacdc7586facf2f6ada2012ed31703e61cc153ffff011ea1473d000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff5704ffff001d01044c4e426c6f636b20233331303337393a30303030303030303030303030303030323431323532613762623237626539376265666539323138633132393064666633366331666631323965633732313161ffffffff01000000000000000043410459934a6a228ce9716fa0b13aa1cdc01593fca5f8599473c803a5109ff834dfdaf4c9ee35f2218c9ee3e7cf7db734e1179524b9d6ae8ebbeba883d4cb89b6c7bfac00000000");
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.5 * 60),
PowAllowMinDifficultyBlocks = true,
CoinbaseMaturity = 100,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 1512,
MinerConfirmationWindow = 2016,
ConsensusFactory = DashConsensusFactory.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("tdash"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("tdash"))
.SetMagic(0xFFCAE2CE)
.SetPort(19999)
.SetRPCPort(19998)
.SetMaxP2PVersion(70213)
.SetName("dash-test")
.AddAlias("dash-testnet")
.SetUriScheme("dash")
.AddDNSSeeds(new[]
{
new DNSSeedData("dashdot.io", "testnet-seed.dashdot.io"),
new DNSSeedData("masternode.io", "test.dnsseed.masternode.io")
})
.AddSeeds(new NetworkAddress[0])
.SetGenesis("010000000000000000000000000000000000000000000000000000000000000000000000c762a6567f3cc092f0684bb62b7e00a84890b990f07cc71a6bb58d64b98e02e0dee1e352f0ff0f1ec3c927e60101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff6204ffff001d01044c5957697265642030392f4a616e2f3230313420546865204772616e64204578706572696d656e7420476f6573204c6976653a204f76657273746f636b2e636f6d204973204e6f7720416363657074696e6720426974636f696e73ffffffff0100f2052a010000004341040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9ac00000000");
return(builder);
}
protected override NetworkBuilder CreateTestnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 2100000,
MajorityEnforceBlockUpgrade = 51,
MajorityRejectBlockOutdated = 75,
MajorityWindow = 600,
PowLimit = new Target(new uint256("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(60),
PowTargetSpacing = TimeSpan.FromSeconds(60),
PowAllowMinDifficultyBlocks = true,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 375,
MinerConfirmationWindow = 500,
CoinbaseMaturity = 120,
LitecoinWorkCalculation = true,
ConsensusFactory = FeathercoinConsensusFactory.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("tfc"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("tfc"))
.SetMagic(0x716a6591)
.SetPort(19336)
.SetRPCPort(19337)
.SetName("ftc-test")
.AddAlias("ftc-testnet")
.AddAlias("feathercoin-test")
.AddAlias("feathercoin-testnet")
.SetUriScheme("feathercoin")
.AddDNSSeeds(new[]
{
new DNSSeedData("testnet-explorer2.feathercoin.com", "feathercoin.com"),
new DNSSeedData("testnet-dnsseed.feathercoin.com", "feathercoin.com"),
})
.AddSeeds(ToSeed(pnSeed6_test))
.SetGenesis("010000000000000000000000000000000000000000000000000000000000000000000000d9ced4ed1130f7b7faad9be25323ffafa33232a17c3edf6cfd97bee6bafbdd97f60ba158f0ff0f1ee17904000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4804ffff001d0104404e592054696d65732030352f4f63742f32303131205374657665204a6f62732c204170706c65e280997320566973696f6e6172792c2044696573206174203536ffffffff0100f2052a010000004341040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9ac00000000");
return(builder);
}
protected override NetworkBuilder CreateTestnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 210000,
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 = 1,
MinerConfirmationWindow = 2,
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(0xF1C8D2FD) //defined in inverted direction, 0xFDD2C8F1
.SetPort(8666)
.SetRPCPort(50332)
.SetMaxP2PVersion(80000)
.SetName("btx-test")
.AddAlias("btx-testnet")
.AddAlias("bitcore-test")
.AddAlias("bitcore-testnet")
.AddDNSSeeds(new[]
{
new DNSSeedData("51.15.84.165", "51.15.84.165"),
new DNSSeedData("188.68.52.172", "188.68.52.172"),
new DNSSeedData("37.120.186.85", "37.120.186.85"),
new DNSSeedData("188.71.223.206", "188.71.223.206")
})
.AddSeeds(ToSeed(pnSeed6_test))
.SetGenesis("010000000000000000000000000000000000000000000000000000000000000000000000ff00e3481f61b255420602f7af626924221a41224b0d645bd2f082f82c8bc50a5746ff58f0ff0f1e98611a000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4004ffff001d010438506f77657264652062792042697473656e642d4575726f7065636f696e2d4469616d6f6e642d4d41432d42332032332f4170722f32303137ffffffff01807c814a00000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000");
return(builder);
}
//static uint256 GetPoWHash(BlockHeader header)
//{
// var headerBytes = header.ToBytes();
// var h = NBitcoin.Crypto.SCrypt.ComputeDerivedKey(headerBytes, headerBytes, 1024, 1, 1, null, 32);
// return new uint256(h);
//}
protected override NetworkBuilder CreateMainnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 4730400,
MajorityEnforceBlockUpgrade = 750,
MajorityRejectBlockOutdated = 950,
MajorityWindow = 1000,
BIP34Hash = new uint256("0x000007d91d1254d60e2dd1ae580383070a4ddffa4c64c2eeb4a2f9ecc0414343"),
PowLimit = new Target(new uint256("0x0000100000000000000000000000000000000000000000000000000000000000")),
MinimumChainWork = new uint256("0x0000100000000000000000000000000000000000000001117564a5d286356cb6"),
PowTargetTimespan = TimeSpan.FromSeconds(108 * 40),
PowTargetSpacing = TimeSpan.FromSeconds(40),
PowAllowMinDifficultyBlocks = false,
CoinbaseMaturity = 5,
PowNoRetargeting = false,
//RuleChangeActivationThreshold = 1916,
//MinerConfirmationWindow = 2016,
ConsensusFactory = DGCConsensusFactory.Instance,
SupportSegwit = false
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 30 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 5 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 128 })
.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("dgc"))
.SetBech32(Bech32Type.WITNESS_SCRIPT_ADDRESS, Encoders.Bech32("dgc"))
.SetMagic(0xDBB6C0FB)
.SetPort(7999)
.SetRPCPort(7998)
.SetMaxP2PVersion(70208)
.SetName("digitalcoin-main")
.AddAlias("digitalcoin-mainnet")
.AddDNSSeeds(new[]
{
new DNSSeedData("brekki_1", "82.165.30.169"),
new DNSSeedData("brekki_2", "212.227.204.145"),
})
.AddSeeds(new NetworkAddress[0])
.SetGenesis("01000000000000000000000000000000000000000000000000000000000000000000000001152abc11024b7593cf60c90ec6a4c50770732720c3524136f2f9ff95c5b2ecf8ff8751f0ff0f1eb0410a000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff3104ffff001d0104294469676974616c636f696e2c20412043757272656e637920666f722061204469676974616c20416765ffffffff0100f2052a01000000434104a5814813115273a109cff99907ba4a05d951873dae7acb6c973d0c9e7c88911a3dbc9aa600deac241b91707e7b4ffb30ad91c8e56e695a1ddf318592988afe0aac00000000");
return(builder);
}
public UserDefinedNetworkFixture()
{
Network = new NetworkBuilder <UserDefinedNetwork>()
.ConfigureHostConfiguration(builder => builder.AddInMemoryCollection())
.ConfigureAppConfiguration((context, builder) => builder.AddInMemoryCollection())
.ConfigureLogging(builder =>
{
builder.AddConsole();
builder.SetMinimumLevel(LogLevel.Debug);
})
.ConfigureNetwork((context, network) =>
{
})
.Build();
DockerClient = ((UserDefinedNetwork)Network).DockerClient;
}
protected override NetworkBuilder CreateTestnet()
{
var builder = new NetworkBuilder();
builder.SetConsensus(new Consensus()
{
SubsidyHalvingInterval = 657000,
MajorityEnforceBlockUpgrade = 510,
MajorityRejectBlockOutdated = 750,
MajorityWindow = 1000,
PowLimit = new Target(new uint256("00001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
PowTargetTimespan = TimeSpan.FromSeconds(3.5 * 24 * 60 * 60), // 3.5 days
PowTargetSpacing = TimeSpan.FromSeconds(1 * 24),
PowAllowMinDifficultyBlocks = true,
PowNoRetargeting = false,
RuleChangeActivationThreshold = 1512,
MinerConfirmationWindow = 2016,
CoinbaseMaturity = 30,
LitecoinWorkCalculation = true,
ConsensusFactory = ViacoinConsensusFactory.Instance,
SupportSegwit = true
})
.SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, new byte[] { 127 })
.SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, new byte[] { 196 })
.SetBase58Bytes(Base58Type.SECRET_KEY, new byte[] { 255 })
.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(0x92efc5a9)
.SetPort(25223)
.SetRPCPort(25222)
.SetName("via-test")
.AddAlias("via-testnet")
.AddAlias("viacoin-test")
.AddAlias("viacoin-testnet")
.SetUriScheme("viacoin")
.AddDNSSeeds(new[]
{
new DNSSeedData("viacoin.net", "testnet.viacoin.net"),
new DNSSeedData("viacoin.net", "seed-testnet.viacoin.net")
})
.AddSeeds(ToSeed(pnSeed6_test))
.SetGenesis("01000000000000000000000000000000000000000000000000000000000000000000000000522753002939c78659b4fdc6ed56c6b6aacdc7586facf2f6ada2012ed31703842cc153ffff1f1e110304000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff5704ffff001d01044c4e426c6f636b20233331303337393a30303030303030303030303030303030323431323532613762623237626539376265666539323138633132393064666633366331666631323965633732313161ffffffff01000000000000000043410459934a6a228ce9716fa0b13aa1cdc01593fca5f8599473c803a5109ff834dfdaf4c9ee35f2218c9ee3e7cf7db734e1179524b9d6ae8ebbeba883d4cb89b6c7bfac00000000");
return(builder);
}
