/// <summary>
/// Computes the required takeoff distance.
/// </summary>
/// <exception cref="Exception"></exception>
public static double TakeOffDistanceMeter(AirbusPerfTable t, TOParameters p)
{
var tables = GetTables(t, p);
if (tables.Count == 0)
{
throw new Exception("No data for selected flaps");
}
var pressAlt = ConversionTools.PressureAltitudeFt(p.RwyElevationFt, p.QNH);
var inverseTables = tables.Select(x => GetInverseTable(x, pressAlt, t, p));
var distancesFt = inverseTables.Select(x =>
x.ValueAt(p.WeightKg * 0.001 * Constants.KgLbRatio))
.ToArray();
var d = (distancesFt.Length == 1) ?
distancesFt[0] :
Interpolate1D.Interpolate(
tables.Select(x => x.IsaOffset).ToArray(),
distancesFt,
IsaOffset(p));
// The slope and wind correction is not exactly correct according to
// performance xml file comments. However, the table itsel is probably
// not that precise anyways.
return(Constants.FtMeterRatio * (d - SlopeAndWindCorrectionFt(d, t, p)));
}
/// <summary>
/// Selects a runway with most headwind component. Returns its ident.
/// </summary>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="InvalidOperationException">rwys is empty</exception>
public static string MaxHeadwind(this IEnumerable <IRwyData> rwys, double windHeading)
{
return(rwys
.Where(r => r.Heading.IsDouble())
.MaxBy(r => ConversionTools.HeadwindComponent(
double.Parse(r.Heading), windHeading, 1.0))
.RwyIdent);
}
private double?TryGetLengthFt()
{
if (double.TryParse(view.Length, out var length))
{
return(ConversionTools.GetLengthFt(length, view.LengthUnit));
}
return(null);
}
private double InterpolatePressure(double lat, double lon, double altFt,
Func <WxTable, TableItem> getTable)
{
double press = ConversionTools.PressureMb(altFt);
int index = GetIndicesForInterpolation(press);
return(Interpolate1D.Interpolate(
pressures[index],
pressures[index + 1],
getTable(windTables[index]).ValueAt(lat, lon),
getTable(windTables[index + 1]).ValueAt(lat, lon),
press));
}
private void TempUnitComboBoxSelectedIndexChanged(object sender, EventArgs e)
{
if (double.TryParse(oatTxtBox.Text, out var temp))
{
if (tempUnitComboBox.SelectedIndex == 0)
{
// deg F -> deg C
temp = ConversionTools.ToCelsius(temp);
}
else
{
// deg C -> deg F
temp = ConversionTools.ToFahrenheit(temp);
}
oatTxtBox.Text = Numbers.RoundToInt(temp).ToString();
}
}
public WindUV GetWindUV(double lat, double lon, double altitudeFt)
{
double press = ConversionTools.PressureMb(altitudeFt);
int index = GetIndicesForInterpolation(press);
double uWind = Interpolate1D.Interpolate(
pressures[index],
pressures[index + 1],
windTables[index].GetUWind(lat, lon),
windTables[index + 1].GetUWind(lat, lon),
press);
double vWind = Interpolate1D.Interpolate(
pressures[index],
pressures[index + 1],
windTables[index].GetVWind(lat, lon),
windTables[index + 1].GetVWind(lat, lon),
press);
return(new WindUV(uWind, vWind));
}
/// <summary>
/// Flaps and brake settings can be overriden.
/// </summary>
/// <exception cref="Exception">Unexpected error</exception>
public static double LandingDistanceMeter(CalculatorData d,
string flaps = null, string brake = null)
{
var p = d.Parameters;
var t = d.Table;
if (flaps == null)
{
flaps = t.AllFlaps()[p.FlapsIndex];
}
if (brake == null)
{
brake = t.AllBrakes()[p.BrakeIndex];
}
// Matching table
var m = t.Entries.Where(x => x.Flaps == flaps && x.Autobrake == brake)
.First();
var weight1000LB = p.WeightKG / 1000 * Constants.KgLbRatio;
var(table, elevation, head, tail, reverser) = p.SurfaceCondition == 0
? (m.Dry, m.ElevationDry, m.HeadwindDry, m.TailwindDry, m.BothReversersDry)
: (m.Wet, m.ElevationWet, m.HeadwindWet, m.TailwindWet, m.BothReversersWet);
var len = table.ValueAt(weight1000LB);
var alt = ConversionTools.PressureAltitudeFt(p.ElevationFT, p.QNH);
len *= 1 + alt / 1000 * elevation / 100;
len *= 1 + (p.HeadwindKts >= 0 ?
(-head * p.HeadwindKts / 10) :
(tail * -p.HeadwindKts / 10)) / 100;
len *= 1 - (p.Reverser == 1 ? reverser : 0) / 100;
len *= 1 + (p.AppSpeedIncrease / 5) * (m.Speed5Knots / 100);
return(len * Constants.FtMeterRatio * t.Multiplier);
}
public RutanioMain()
{
// START MODIFICATIONS OF GENERATED CODE
var consensusOptions = new RutanioPosConsensusOptions
{
MaxBlockBaseSize = 1_000_000,
MaxStandardVersion = 2,
MaxStandardTxWeight = 100_000,
MaxBlockSigopsCost = 20_000,
MaxStandardTxSigopsCost = 20_000 / 5,
WitnessScaleFactor = 4
};
// END MODIFICATIONS
CoinSetup setup = RutanioSetup.Instance.Setup;
NetworkSetup network = RutanioSetup.Instance.Main;
NetworkType = NetworkType.Mainnet;
DefaultConfigFilename = setup.ConfigFileName; // The default name used for the Rutanio configuration file.
Name = network.Name;
CoinTicker = network.CoinTicker;
Magic = ConversionTools.ConvertToUInt32(setup.Magic);
RootFolderName = network.RootFolderName;
DefaultPort = network.DefaultPort;
DefaultRPCPort = network.DefaultRPCPort;
DefaultAPIPort = network.DefaultAPIPort;
DefaultMaxOutboundConnections = 16;
DefaultMaxInboundConnections = 109;
MaxTipAge = 2 * 60 * 60;
MinTxFee = 10000;
MaxTxFee = Money.Coins(1).Satoshi;
FallbackFee = 10000;
MinRelayTxFee = 10000;
MaxTimeOffsetSeconds = 25 * 60;
DefaultBanTimeSeconds = 16000; // 500 (MaxReorg) * 64 (TargetSpacing) / 2 = 4 hours, 26 minutes and 40 seconds
var consensusFactory = new PosConsensusFactory();
GenesisTime = network.GenesisTime;
GenesisNonce = network.GenesisNonce;
GenesisBits = network.GenesisBits;
GenesisVersion = network.GenesisVersion;
GenesisReward = network.GenesisReward;
Block genesisBlock = CreateGenesisBlock(consensusFactory,
GenesisTime,
GenesisNonce,
GenesisBits,
GenesisVersion,
GenesisReward,
setup.GenesisText);
Genesis = genesisBlock;
var buriedDeployments = new BuriedDeploymentsArray
{
[BuriedDeployments.BIP34] = 0,
[BuriedDeployments.BIP65] = 0,
[BuriedDeployments.BIP66] = 0
};
var bip9Deployments = new RutanioBIP9Deployments
{
[RutanioBIP9Deployments.ColdStaking] = new BIP9DeploymentsParameters("ColdStaking", 27, new DateTime(2020, 6, 1, 0, 0, 0, DateTimeKind.Utc), new DateTime(2021, 6, 1, 0, 0, 0, DateTimeKind.Utc), BIP9DeploymentsParameters.DefaultMainnetThreshold),
[RutanioBIP9Deployments.CSV] = new BIP9DeploymentsParameters("CSV", 0, new DateTime(2020, 6, 1, 0, 0, 0, DateTimeKind.Utc), new DateTime(2021, 6, 1, 0, 0, 0, DateTimeKind.Utc), BIP9DeploymentsParameters.DefaultMainnetThreshold),
[RutanioBIP9Deployments.Segwit] = new BIP9DeploymentsParameters("Segwit", 1, new DateTime(2020, 6, 1, 0, 0, 0, DateTimeKind.Utc), new DateTime(2021, 6, 1, 0, 0, 0, DateTimeKind.Utc), BIP9DeploymentsParameters.DefaultMainnetThreshold)
};
consensusFactory.Protocol = new ConsensusProtocol()
{
ProtocolVersion = ProtocolVersion.FEEFILTER_VERSION,
MinProtocolVersion = ProtocolVersion.POS_PROTOCOL_VERSION,
};
Consensus = new Blockcore.Consensus.Consensus(
consensusFactory: consensusFactory,
consensusOptions: consensusOptions,
coinType: setup.CoinType,
hashGenesisBlock: genesisBlock.GetHash(),
subsidyHalvingInterval: 210000,
majorityEnforceBlockUpgrade: 750,
majorityRejectBlockOutdated: 950,
majorityWindow: 1000,
buriedDeployments: buriedDeployments,
bip9Deployments: bip9Deployments,
bip34Hash: null,
minerConfirmationWindow: 2016, // nPowTargetTimespan / nPowTargetSpacing
maxReorgLength: 500,
defaultAssumeValid: null,
maxMoney: long.MaxValue,
coinbaseMaturity: 50,
premineHeight: 2,
premineReward: Money.Coins(setup.PremineReward),
proofOfWorkReward: Money.Coins(setup.PoWBlockReward),
targetTimespan: TimeSpan.FromSeconds(14 * 24 * 60 * 60), // two weeks
targetSpacing: setup.TargetSpacing,
powAllowMinDifficultyBlocks: false,
posNoRetargeting: false,
powNoRetargeting: false,
powLimit: new Target(new uint256("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
minimumChainWork: null,
isProofOfStake: true,
lastPowBlock: setup.LastPowBlock,
proofOfStakeLimit: new BigInteger(uint256.Parse("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").ToBytes(false)),
proofOfStakeLimitV2: new BigInteger(uint256.Parse("000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffff").ToBytes(false)),
proofOfStakeReward: Money.Coins(setup.PoSBlockReward),
proofOfStakeTimestampMask: setup.ProofOfStakeTimestampMask
);
// HashKey Definition
byte[] newHashkey = Encoders.ASCII.DecodeData("Rutanio seed");
ExtKey.OverrideHashKey(newHashkey);
Consensus.PosEmptyCoinbase = RutanioSetup.Instance.IsPoSv3();
Consensus.PosUseTimeFieldInKernalHash = RutanioSetup.Instance.IsPoSv3();
// TODO: Set your Base58Prefixes
Base58Prefixes = new byte[12][];
Base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS] = new byte[] { (byte)network.PubKeyAddress };
Base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS] = new byte[] { (byte)network.ScriptAddress };
Base58Prefixes[(int)Base58Type.SECRET_KEY] = new byte[] { (byte)network.SecretAddress };
Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_NO_EC] = new byte[] { 0x01, 0x42 };
Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_EC] = new byte[] { 0x01, 0x43 };
Base58Prefixes[(int)Base58Type.EXT_PUBLIC_KEY] = new byte[] { (0x04), (0x88), (0xB2), (0x1E) };
Base58Prefixes[(int)Base58Type.EXT_SECRET_KEY] = new byte[] { (0x04), (0x88), (0xAD), (0xE4) };
Base58Prefixes[(int)Base58Type.PASSPHRASE_CODE] = new byte[] { 0x2C, 0xE9, 0xB3, 0xE1, 0xFF, 0x39, 0xE2 };
Base58Prefixes[(int)Base58Type.CONFIRMATION_CODE] = new byte[] { 0x64, 0x3B, 0xF6, 0xA8, 0x9A };
Base58Prefixes[(int)Base58Type.ASSET_ID] = new byte[] { 23 };
Bech32Encoders = new Bech32Encoder[2];
var encoder = new Bech32Encoder(network.CoinTicker.ToLowerInvariant());
Bech32Encoders[(int)Bech32Type.WITNESS_PUBKEY_ADDRESS] = encoder;
Bech32Encoders[(int)Bech32Type.WITNESS_SCRIPT_ADDRESS] = encoder;
Checkpoints = network.Checkpoints;
DNSSeeds = network.DNS.Select(dns => new DNSSeedData(dns, dns)).ToList();
SeedNodes = network.Nodes.Select(node => new NBitcoin.Protocol.NetworkAddress(IPAddress.Parse(Dns.GetHostAddresses(node).GetValue(0).ToString()), network.DefaultPort)).ToList();
StandardScriptsRegistry = new RutanioStandardScriptsRegistry();
// 64 below should be changed to TargetSpacingSeconds when we move that field.
Assert(DefaultBanTimeSeconds <= Consensus.MaxReorgLength * 64 / 2);
Assert(Consensus.HashGenesisBlock == uint256.Parse(network.HashGenesisBlock));
Assert(Genesis.Header.HashMerkleRoot == uint256.Parse(network.HashMerkleRoot));
RegisterRules(Consensus);
RegisterMempoolRules(Consensus);
}
public OpenExoRegTest()
{
// START MODIFICATIONS OF GENERATED CODE
var consensusOptions = new OpenExoPosConsensusOptions
{
MaxBlockBaseSize = 1_000_000,
MaxStandardVersion = 2,
MaxStandardTxWeight = 100_000,
MaxBlockSigopsCost = 20_000,
MaxStandardTxSigopsCost = 20_000 / 5,
WitnessScaleFactor = 4
};
// END MODIFICATIONS
CoinSetup setup = OpenExoSetup.Instance.Setup;
NetworkSetup network = OpenExoSetup.Instance.RegTest;
NetworkType = NetworkType.Regtest;
Name = network.Name;
CoinTicker = network.CoinTicker;
Magic = ConversionTools.ConvertToUInt32(setup.Magic, true);
RootFolderName = network.RootFolderName;
DefaultPort = network.DefaultPort;
DefaultRPCPort = network.DefaultRPCPort;
DefaultAPIPort = network.DefaultAPIPort;
var consensusFactory = new PosConsensusFactory();
// Create the genesis block.
GenesisTime = network.GenesisTime;
GenesisNonce = network.GenesisNonce;
GenesisBits = network.GenesisBits;
GenesisVersion = network.GenesisVersion;
GenesisReward = network.GenesisReward;
Block genesisBlock = CreateGenesisBlock(consensusFactory,
GenesisTime,
GenesisNonce,
GenesisBits,
GenesisVersion,
GenesisReward,
setup.GenesisText);
Genesis = genesisBlock;
var buriedDeployments = new BuriedDeploymentsArray
{
[BuriedDeployments.BIP34] = 0,
[BuriedDeployments.BIP65] = 0,
[BuriedDeployments.BIP66] = 0
};
var bip9Deployments = new OpenExoBIP9Deployments()
{
// Always active on OpenExoRegTest.
[OpenExoBIP9Deployments.TestDummy] = new BIP9DeploymentsParameters("TestDummy", 28, BIP9DeploymentsParameters.AlwaysActive, 999999999, BIP9DeploymentsParameters.AlwaysActive),
[OpenExoBIP9Deployments.CSV] = new BIP9DeploymentsParameters("CSV", 0, BIP9DeploymentsParameters.AlwaysActive, 999999999, BIP9DeploymentsParameters.AlwaysActive),
[OpenExoBIP9Deployments.Segwit] = new BIP9DeploymentsParameters("Segwit", 1, BIP9DeploymentsParameters.AlwaysActive, 999999999, BIP9DeploymentsParameters.AlwaysActive),
[OpenExoBIP9Deployments.ColdStaking] = new BIP9DeploymentsParameters("ColdStaking", 2, BIP9DeploymentsParameters.AlwaysActive, 999999999, BIP9DeploymentsParameters.AlwaysActive),
};
Consensus = new Blockcore.Consensus.Consensus(
consensusFactory: consensusFactory,
consensusOptions: consensusOptions,
coinType: setup.CoinType,
hashGenesisBlock: genesisBlock.GetHash(),
subsidyHalvingInterval: 210000,
majorityEnforceBlockUpgrade: 750,
majorityRejectBlockOutdated: 950,
majorityWindow: 1000,
buriedDeployments: buriedDeployments,
bip9Deployments: bip9Deployments,
bip34Hash: null,
minerConfirmationWindow: 2016, // nPowTargetTimespan / nPowTargetSpacing
maxReorgLength: 500,
defaultAssumeValid: null,
maxMoney: long.MaxValue,
coinbaseMaturity: 10,
premineHeight: 2,
premineReward: Money.Coins(setup.PremineReward),
proofOfWorkReward: Money.Coins(setup.PoWBlockReward),
targetTimespan: TimeSpan.FromSeconds(14 * 24 * 60 * 60), // two weeks
targetSpacing: setup.TargetSpacing,
powAllowMinDifficultyBlocks: true,
posNoRetargeting: true,
powNoRetargeting: true,
powLimit: new Target(new uint256("0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
minimumChainWork: null,
isProofOfStake: true,
lastPowBlock: setup.LastPowBlock,
proofOfStakeLimit: new BigInteger(uint256.Parse("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").ToBytes(false)),
proofOfStakeLimitV2: new BigInteger(uint256.Parse("000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffff").ToBytes(false)),
proofOfStakeReward: Money.Coins(setup.PoSBlockReward),
proofOfStakeTimestampMask: setup.ProofOfStakeTimestampMask
);
Base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS] = new byte[] { (byte)network.PubKeyAddress };
Base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS] = new byte[] { (byte)network.ScriptAddress };
Base58Prefixes[(int)Base58Type.SECRET_KEY] = new byte[] { (68 + 128) };
Base58Prefixes[(int)Base58Type.EXT_PUBLIC_KEY] = new byte[] { (0x04), (0x35), (0x87), (0xCF) };
Base58Prefixes[(int)Base58Type.EXT_SECRET_KEY] = new byte[] { (0x04), (0x35), (0x83), (0x94) };
Bech32Encoders = new Bech32Encoder[2];
var encoder = new Bech32Encoder(network.CoinTicker.ToLowerInvariant());
Bech32Encoders[(int)Bech32Type.WITNESS_PUBKEY_ADDRESS] = encoder;
Bech32Encoders[(int)Bech32Type.WITNESS_SCRIPT_ADDRESS] = encoder;
Checkpoints = network.Checkpoints;
DNSSeeds = network.DNS.Select(dns => new DNSSeedData(dns, dns)).ToList();
SeedNodes = network.Nodes.Select(node => new NBitcoin.Protocol.NetworkAddress(IPAddress.Parse(Dns.GetHostAddresses(node).GetValue(0).ToString()), network.DefaultPort)).ToList();
StandardScriptsRegistry = new OpenExoStandardScriptsRegistry();
// 64 below should be changed to TargetSpacingSeconds when we move that field.
Assert(DefaultBanTimeSeconds <= Consensus.MaxReorgLength * 64 / 2);
Assert(Consensus.HashGenesisBlock == uint256.Parse(network.HashGenesisBlock));
Assert(Genesis.Header.HashMerkleRoot == uint256.Parse(network.HashMerkleRoot));
RegisterRules(Consensus);
RegisterMempoolRules(Consensus);
}
}
public x42RegTest()
{
// START MODIFICATIONS OF GENERATED CODE
var consensusOptions = new x42PosConsensusOptions
{
MaxBlockBaseSize = 1_000_000,
MaxStandardVersion = 2,
MaxStandardTxWeight = 100_000,
MaxBlockSigopsCost = 20_000,
MaxStandardTxSigopsCost = 20_000 / 5,
WitnessScaleFactor = 4
};
// END MODIFICATIONS
CoinSetup setup = x42Setup.Instance.Setup;
NetworkSetup network = x42Setup.Instance.RegTest;
NetworkType = NetworkType.Regtest;
Name = network.Name;
CoinTicker = network.CoinTicker;
Magic = ConversionTools.ConvertToUInt32(setup.Magic, true);
RootFolderName = network.RootFolderName;
DefaultPort = network.DefaultPort;
DefaultRPCPort = network.DefaultRPCPort;
DefaultAPIPort = network.DefaultAPIPort;
var consensusFactory = new PosConsensusFactory();
// Create the genesis block.
GenesisTime = network.GenesisTime;
GenesisNonce = network.GenesisNonce;
GenesisBits = network.GenesisBits;
GenesisVersion = network.GenesisVersion;
GenesisReward = network.GenesisReward;
Block genesisBlock = CreateGenesisBlock(consensusFactory,
GenesisTime,
GenesisNonce,
GenesisBits,
GenesisVersion,
GenesisReward,
setup.GenesisText);
Genesis = genesisBlock;
var buriedDeployments = new BuriedDeploymentsArray
{
[BuriedDeployments.BIP34] = 0,
[BuriedDeployments.BIP65] = 0,
[BuriedDeployments.BIP66] = 0
};
consensusFactory.Protocol = new ConsensusProtocol()
{
ProtocolVersion = ProtocolVersion.FEEFILTER_VERSION,
MinProtocolVersion = ProtocolVersion.POS_PROTOCOL_VERSION,
};
this.Consensus = new x42Consensus(
consensusFactory: consensusFactory,
consensusOptions: consensusOptions,
coinType: setup.CoinType,
hashGenesisBlock: genesisBlock.GetHash(),
subsidyHalvingInterval: 24333,
majorityEnforceBlockUpgrade: 750,
majorityRejectBlockOutdated: 950,
majorityWindow: 1000,
buriedDeployments: buriedDeployments,
bip9Deployments: new NoBIP9Deployments(),
bip34Hash: null,
minerConfirmationWindow: 2016, // nPowTargetTimespan / nPowTargetSpacing
maxReorgLength: 500,
defaultAssumeValid: null,
maxMoney: long.MaxValue,
coinbaseMaturity: 10,
premineHeight: 2,
premineReward: Money.Coins(setup.PremineReward),
proofOfWorkReward: Money.Coins(setup.PoWBlockReward),
targetTimespan: TimeSpan.FromSeconds(14 * 24 * 60 * 60), // two weeks
targetSpacing: setup.TargetSpacing,
powAllowMinDifficultyBlocks: true,
posNoRetargeting: true,
powNoRetargeting: true,
powLimit: new Target(new uint256("0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
minimumChainWork: null,
isProofOfStake: true,
lastPowBlock: setup.LastPowBlock,
proofOfStakeLimitV2: new BigInteger(uint256.Parse("000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffff").ToBytes(false)),
proofOfStakeReward: Money.Coins(setup.PoSBlockReward),
subsidyLimit: setup.SubsidyLimit,
proofOfStakeRewardAfterSubsidyLimit: setup.ProofOfStakeRewardAfterSubsidyLimit,
lastProofOfStakeRewardHeight: setup.LastProofOfStakeRewardHeight,
minOpReturnFee: Money.Coins(0.02m).Satoshi,
proofOfStakeTimestampMask: setup.ProofOfStakeTimestampMask,
posEmptyCoinbase: x42Setup.Instance.IsPoSv3()
)
{
PosUseTimeFieldInKernalHash = x42Setup.Instance.IsPoSv3()
};
Base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS] = new byte[] { (byte)network.PubKeyAddress };
Base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS] = new byte[] { (byte)network.ScriptAddress };
Base58Prefixes[(int)Base58Type.SECRET_KEY] = new byte[] { (239) };
Base58Prefixes[(int)Base58Type.EXT_PUBLIC_KEY] = new byte[] { (0x04), (0x35), (0x87), (0xCF) };
Base58Prefixes[(int)Base58Type.EXT_SECRET_KEY] = new byte[] { (0x04), (0x35), (0x83), (0x94) };
Base58Prefixes[(int)Base58Type.ASSET_ID] = new byte[] { 115 };
Bech32Encoders = new Bech32Encoder[2];
var encoder = new Bech32Encoder(network.CoinTicker.ToLowerInvariant());
Bech32Encoders[(int)Bech32Type.WITNESS_PUBKEY_ADDRESS] = encoder;
Bech32Encoders[(int)Bech32Type.WITNESS_SCRIPT_ADDRESS] = encoder;
Checkpoints = network.Checkpoints;
DNSSeeds = network.DNS.Select(dns => new DNSSeedData(dns, dns)).ToList();
SeedNodes = network.Nodes.Select(node => new NBitcoin.Protocol.NetworkAddress(IPAddress.Parse(node), network.DefaultPort)).ToList();
StandardScriptsRegistry = new x42StandardScriptsRegistry();
// 64 below should be changed to TargetSpacingSeconds when we move that field.
Assert(DefaultBanTimeSeconds <= Consensus.MaxReorgLength * 64 / 2);
Assert(Consensus.HashGenesisBlock == uint256.Parse(network.HashGenesisBlock));
Assert(Genesis.Header.HashMerkleRoot == uint256.Parse(network.HashMerkleRoot));
RegisterRules(Consensus);
RegisterMempoolRules(Consensus);
}
}
public quoxentMain()
{
CoinSetup setup = quoxentSetup.Instance.Setup;
NetworkSetup network = quoxentSetup.Instance.Main;
NetworkType = NetworkType.Mainnet;
DefaultConfigFilename = setup.ConfigFileName; // The default name used for the quoxent configuration file.
Name = network.Name;
CoinTicker = network.CoinTicker;
Magic = ConversionTools.ConvertToUInt32(setup.Magic);
RootFolderName = network.RootFolderName;
DefaultPort = network.DefaultPort;
DefaultRPCPort = network.DefaultRPCPort;
DefaultAPIPort = network.DefaultAPIPort;
DefaultMaxOutboundConnections = 16;
DefaultMaxInboundConnections = 109;
MaxTipAge = 2 * 60 * 60;
MinTxFee = 9333;
FallbackFee = 9333;
MinRelayTxFee = 9333;
MaxTimeOffsetSeconds = 25 * 60;
DefaultBanTimeSeconds = 16000; // 500 (MaxReorg) * 64 (TargetSpacing) / 2 = 4 hours, 26 minutes and 40 seconds
var consensusFactory = new PosConsensusFactory();
// Create the genesis block.
GenesisTime = network.GenesisTime;
GenesisNonce = network.GenesisNonce;
GenesisBits = network.GenesisBits;
GenesisVersion = network.GenesisVersion;
GenesisReward = network.GenesisReward;
Block genesisBlock = CreateGenesisBlock(consensusFactory,
GenesisTime,
GenesisNonce,
GenesisBits,
GenesisVersion,
GenesisReward,
setup.GenesisText);
Genesis = genesisBlock;
var consensusOptions = new PosConsensusOptions(
maxBlockBaseSize: 1_000_000,
maxStandardVersion: 2,
maxStandardTxWeight: 100_000,
maxBlockSigopsCost: 20_000,
maxStandardTxSigopsCost: 20_000 / 5,
witnessScaleFactor: 4
);
var buriedDeployments = new BuriedDeploymentsArray
{
[BuriedDeployments.BIP34] = 0,
[BuriedDeployments.BIP65] = 0,
[BuriedDeployments.BIP66] = 0
};
Consensus = new NBitcoin.Consensus(
consensusFactory: consensusFactory,
consensusOptions: consensusOptions,
coinType: setup.CoinType,
hashGenesisBlock: genesisBlock.GetHash(),
subsidyHalvingInterval: 29333,
majorityEnforceBlockUpgrade: 750,
majorityRejectBlockOutdated: 950,
majorityWindow: 1000,
buriedDeployments: buriedDeployments,
bip9Deployments: new NoBIP9Deployments(),
bip34Hash: null,
minerConfirmationWindow: 2016, // nPowTargetTimespan / nPowTargetSpacing
maxReorgLength: 500,
defaultAssumeValid: null,
maxMoney: long.MaxValue,
coinbaseMaturity: 50,
premineHeight: 2,
premineReward: Money.Coins(setup.PremineReward),
proofOfWorkReward: Money.Coins(setup.PoWBlockReward),
targetTimespan: TimeSpan.FromSeconds(14 * 24 * 60 * 60), // two weeks
targetSpacing: setup.TargetSpacing,
powAllowMinDifficultyBlocks: false,
posNoRetargeting: false,
powNoRetargeting: false,
powLimit: new Target(new uint256("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
minimumChainWork: null,
isProofOfStake: true,
lastPowBlock: setup.LastPowBlock,
proofOfStakeLimit: new BigInteger(uint256.Parse("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").ToBytes(false)),
proofOfStakeLimitV2: new BigInteger(uint256.Parse("000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffff").ToBytes(false)),
proofOfStakeReward: Money.Coins(setup.PoSBlockReward),
proofOfStakeTimestampMask: setup.ProofOfStakeTimestampMask
);
Consensus.PosEmptyCoinbase = quoxentSetup.Instance.IsPoSv3();
Consensus.PosUseTimeFieldInKernalHash = quoxentSetup.Instance.IsPoSv3();
// TODO: Set your Base58Prefixes
Base58Prefixes = new byte[12][];
Base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS] = new byte[] { (byte)network.PubKeyAddress };
Base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS] = new byte[] { (byte)network.ScriptAddress };
Base58Prefixes[(int)Base58Type.SECRET_KEY] = new byte[] { (byte)network.SecretAddress };
Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_NO_EC] = new byte[] { 0x01, 0x42 };
Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_EC] = new byte[] { 0x01, 0x43 };
Base58Prefixes[(int)Base58Type.EXT_PUBLIC_KEY] = new byte[] { (0x04), (0x88), (0xB2), (0x1E) };
Base58Prefixes[(int)Base58Type.EXT_SECRET_KEY] = new byte[] { (0x04), (0x88), (0xAD), (0xE4) };
Base58Prefixes[(int)Base58Type.PASSPHRASE_CODE] = new byte[] { 0x2C, 0xE9, 0xB3, 0xE1, 0xFF, 0x39, 0xE2 };
Base58Prefixes[(int)Base58Type.CONFIRMATION_CODE] = new byte[] { 0x64, 0x3B, 0xF6, 0xA8, 0x9A };
Base58Prefixes[(int)Base58Type.STEALTH_ADDRESS] = new byte[] { 0x2a };
Base58Prefixes[(int)Base58Type.ASSET_ID] = new byte[] { 23 };
Base58Prefixes[(int)Base58Type.COLORED_ADDRESS] = new byte[] { 0x13 };
Bech32Encoders = new Bech32Encoder[2];
var encoder = new Bech32Encoder(network.CoinTicker.ToLowerInvariant());
Bech32Encoders[(int)Bech32Type.WITNESS_PUBKEY_ADDRESS] = encoder;
Bech32Encoders[(int)Bech32Type.WITNESS_SCRIPT_ADDRESS] = encoder;
Checkpoints = network.Checkpoints;
DNSSeeds = network.DNS.Select(dns => new DNSSeedData(dns, dns)).ToList();
SeedNodes = network.Nodes.Select(node => new NBitcoin.Protocol.NetworkAddress(IPAddress.Parse(node), network.DefaultPort)).ToList();
StandardScriptsRegistry = new quoxentStandardScriptsRegistry();
// 64 below should be changed to TargetSpacingSeconds when we move that field.
Assert(DefaultBanTimeSeconds <= Consensus.MaxReorgLength * 64 / 2);
Assert(Consensus.HashGenesisBlock == uint256.Parse(network.HashGenesisBlock));
Assert(Genesis.Header.HashMerkleRoot == uint256.Parse(network.HashMerkleRoot));
RegisterRules(Consensus);
RegisterMempoolRules(Consensus);
}
/// <exception cref="InvalidUserInputException"></exception>
public LandingParameters Validate()
{
var e = elements;
double weightKg = 0.0;
double rwyLengthMeter = 0.0;
double elevationFt = 0.0;
double headwindKts = 0.0;
double slopePercent = 0.0;
double tempCelsius = 0.0;
double qnh = 0.0;
double appSpeedIncrease = 0.0;
int reverser = 0;
int surfaceCondition = 0;
int flapsIndex = 0;
int brakeIndex = 0;
try
{
weightKg = Convert.ToDouble(e.Weight.Text);
if (e.WtUnit.SelectedIndex == 1) //LB
{
weightKg *= Constants.LbKgRatio;
}
if (weightKg < 0)
{
throw new InvalidUserInputException("Landing weight is not valid.");
}
}
catch
{
throw new InvalidUserInputException("Landing weight is not valid.");
}
try
{
rwyLengthMeter = Convert.ToDouble(e.Length.Text);
if (e.LengthUnit.SelectedIndex == 1) // FT
{
rwyLengthMeter *= Constants.FtMeterRatio;
}
if (rwyLengthMeter < 0)
{
throw new InvalidUserInputException("Runway length is not valid.");
}
}
catch
{
throw new InvalidUserInputException("Runway length is not valid.");
}
try
{
elevationFt = Convert.ToDouble(e.Elevation.Text);
if (elevationFt < -2000.0 || elevationFt > 20000.0)
{
throw new InvalidUserInputException("Runway elevation is not valid.");
}
}
catch
{
throw new InvalidUserInputException("Runway elevation is not valid.");
}
try
{
headwindKts = ConversionTools.HeadwindComponent(
Convert.ToDouble(e.RwyHeading.Text),
Convert.ToDouble(e.WindDirection.Text),
Convert.ToDouble(e.WindSpeed.Text));
}
catch
{
throw new InvalidUserInputException("Wind entry is not valid.");
}
try
{
slopePercent = Convert.ToDouble(e.Slope.Text);
}
catch
{
throw new InvalidUserInputException("Runway slope is not valid.");
}
try
{
tempCelsius = Convert.ToDouble(e.Oat.Text);
if (e.TempUnit.SelectedIndex == 1) // deg F
{
tempCelsius = ConversionTools.ToCelsius(tempCelsius);
}
}
catch
{
throw new InvalidUserInputException("OAT is not valid.");
}
try
{
qnh = Convert.ToDouble(e.Pressure.Text);
if (e.PressureUnit.SelectedIndex == 1)
{
qnh *= 1013.0 / 29.92;
}
if (qnh <900.0 | qnh> 1100.0)
{
throw new InvalidUserInputException("Altimeter setting is not valid.");
}
}
catch
{
throw new InvalidUserInputException("Altimeter setting is not valid.");
}
try
{
appSpeedIncrease = double.Parse(e.AppSpeedIncrease.Text);
}
catch
{
throw new InvalidUserInputException("APP speed increase is not valid.");
}
try
{
reverser = e.Reverser.SelectedIndex;
}
catch
{
throw new InvalidUserInputException("Reverser selection is not valid.");
}
try
{
surfaceCondition = e.SurfCond.SelectedIndex;
}
catch
{
throw new InvalidUserInputException("Surface condition is not valid.");
}
flapsIndex = e.Flaps.SelectedIndex;
brakeIndex = e.Brake.SelectedIndex;
return(new LandingParameters(
weightKg,
rwyLengthMeter,
elevationFt,
headwindKts,
slopePercent,
tempCelsius,
qnh,
appSpeedIncrease,
reverser,
surfaceCondition,
flapsIndex,
brakeIndex));
}
private static double IsaOffset(TOParameters p) => p.OatCelsius - ConversionTools.IsaTemp(p.RwyElevationFt);
public CyBitsTest()
{
CoinSetup setup = CyBitsSetup.Instance.Setup;
NetworkSetup network = CyBitsSetup.Instance.Test;
NetworkType = NetworkType.Testnet;
Name = network.Name;
CoinTicker = network.CoinTicker;
Magic = ConversionTools.ConvertToUInt32(setup.Magic, true);
RootFolderName = network.RootFolderName;
DefaultPort = network.DefaultPort;
DefaultRPCPort = network.DefaultRPCPort;
DefaultAPIPort = network.DefaultAPIPort;
var consensusFactory = new PosConsensusFactory();
// Create the genesis block.
GenesisTime = network.GenesisTime;
GenesisNonce = network.GenesisNonce;
GenesisBits = network.GenesisBits;
GenesisVersion = network.GenesisVersion;
GenesisReward = network.GenesisReward;
Block genesisBlock = CreateGenesisBlock(consensusFactory,
GenesisTime,
GenesisNonce,
GenesisBits,
GenesisVersion,
GenesisReward,
setup.GenesisText);
Genesis = genesisBlock;
var consensusOptions = new PosConsensusOptions
{
MaxBlockBaseSize = 1_000_000,
MaxStandardVersion = 2,
MaxStandardTxWeight = 100_000,
MaxBlockSigopsCost = 20_000,
MaxStandardTxSigopsCost = 20_000 / 5,
WitnessScaleFactor = 4
};
var buriedDeployments = new BuriedDeploymentsArray
{
[BuriedDeployments.BIP34] = 0,
[BuriedDeployments.BIP65] = 0,
[BuriedDeployments.BIP66] = 0
};
Consensus = new Blockcore.Consensus.Consensus(
consensusFactory: consensusFactory,
consensusOptions: consensusOptions,
coinType: setup.CoinType,
hashGenesisBlock: genesisBlock.GetHash(),
subsidyHalvingInterval: 210000,
majorityEnforceBlockUpgrade: 750,
majorityRejectBlockOutdated: 950,
majorityWindow: 1000,
buriedDeployments: buriedDeployments,
bip9Deployments: new NoBIP9Deployments(),
bip34Hash: null,
minerConfirmationWindow: 2016, // nPowTargetTimespan / nPowTargetSpacing
maxReorgLength: 500,
defaultAssumeValid: null,
maxMoney: long.MaxValue,
coinbaseMaturity: 10,
premineHeight: 2,
premineReward: Money.Coins(setup.PremineReward),
proofOfWorkReward: Money.Coins(setup.PoWBlockReward),
targetTimespan: TimeSpan.FromSeconds(14 * 24 * 60 * 60), // two weeks
targetSpacing: setup.TargetSpacing,
powAllowMinDifficultyBlocks: false,
posNoRetargeting: false,
powNoRetargeting: false,
powLimit: new Target(new uint256("000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
minimumChainWork: null,
isProofOfStake: true,
lastPowBlock: setup.LastPowBlock,
proofOfStakeLimit: new BigInteger(uint256.Parse("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").ToBytes(false)),
proofOfStakeLimitV2: new BigInteger(uint256.Parse("000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffff").ToBytes(false)),
proofOfStakeReward: Money.Coins(setup.PoSBlockReward),
proofOfStakeTimestampMask: setup.ProofOfStakeTimestampMask
);
Base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS] = new byte[] { (byte)network.PubKeyAddress };
Base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS] = new byte[] { (byte)network.ScriptAddress };
Base58Prefixes[(int)Base58Type.SECRET_KEY] = new byte[] { (239) };
Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_NO_EC] = new byte[] { 0x01, 0x42 };
Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_EC] = new byte[] { 0x01, 0x43 };
Base58Prefixes[(int)Base58Type.EXT_PUBLIC_KEY] = new byte[] { (0x04), (0x88), (0xB2), (0x1E) };
Base58Prefixes[(int)Base58Type.EXT_SECRET_KEY] = new byte[] { (0x04), (0x88), (0xAD), (0xE4) };
Base58Prefixes[(int)Base58Type.PASSPHRASE_CODE] = new byte[] { 0x2C, 0xE9, 0xB3, 0xE1, 0xFF, 0x39, 0xE2 };
Base58Prefixes[(int)Base58Type.CONFIRMATION_CODE] = new byte[] { 0x64, 0x3B, 0xF6, 0xA8, 0x9A };
Base58Prefixes[(int)Base58Type.ASSET_ID] = new byte[] { 115 };
Bech32Encoders = new Bech32Encoder[2];
var encoder = new Bech32Encoder(network.CoinTicker.ToLowerInvariant());
Bech32Encoders[(int)Bech32Type.WITNESS_PUBKEY_ADDRESS] = encoder;
Bech32Encoders[(int)Bech32Type.WITNESS_SCRIPT_ADDRESS] = encoder;
Checkpoints = network.Checkpoints;
DNSSeeds = network.DNS.Select(dns => new DNSSeedData(dns, dns)).ToList();
SeedNodes = network.Nodes.Select(node => new NBitcoin.Protocol.NetworkAddress(IPAddress.Parse(node), network.DefaultPort)).ToList();
StandardScriptsRegistry = new CyBitsStandardScriptsRegistry();
// 64 below should be changed to TargetSpacingSeconds when we move that field.
Assert(DefaultBanTimeSeconds <= Consensus.MaxReorgLength * 64 / 2);
Assert(Consensus.HashGenesisBlock == uint256.Parse(network.HashGenesisBlock));
Assert(Genesis.Header.HashMerkleRoot == uint256.Parse(network.HashMerkleRoot));
RegisterRules(Consensus);
RegisterMempoolRules(Consensus);
}
}
private double RwyPressureAltFt()
{
return(ConversionTools.PressureAltitudeFt(para.RwyElevationFt, para.QNH));
}
public x42Main()
{
// START MODIFICATIONS OF GENERATED CODE
var consensusOptions = new x42PosConsensusOptions
{
MaxBlockBaseSize = 1_000_000,
MaxStandardVersion = 2,
MaxStandardTxWeight = 100_000,
MaxBlockSigopsCost = 20_000,
MaxStandardTxSigopsCost = 20_000 / 5,
WitnessScaleFactor = 4
};
consensusOptions.MinBlockFeeRate = Money.Zero;
// END MODIFICATIONS
CoinSetup setup = x42Setup.Instance.Setup;
NetworkSetup network = x42Setup.Instance.Main;
this.NetworkType = NetworkType.Mainnet;
this.DefaultConfigFilename = setup.ConfigFileName; // The default name used for the x42's configuration file.
this.Name = network.Name;
this.CoinTicker = network.CoinTicker;
this.Magic = ConversionTools.ConvertToUInt32(setup.Magic);
this.RootFolderName = network.RootFolderName;
this.DefaultPort = network.DefaultPort;
this.DefaultRPCPort = network.DefaultRPCPort;
this.DefaultAPIPort = network.DefaultAPIPort;
this.DefaultMaxOutboundConnections = 16;
this.DefaultMaxInboundConnections = 109;
this.MaxTipAge = 2 * 60 * 60;
this.MinTxFee = Money.Zero;
this.MaxTxFee = Money.Coins(1).Satoshi;
this.FallbackFee = Money.Zero;
this.MinRelayTxFee = Money.Zero;
this.MaxTimeOffsetSeconds = 25 * 60;
this.DefaultBanTimeSeconds = 16000; // 500 (MaxReorg) * 64 (TargetSpacing) / 2 = 4 hours, 26 minutes and 40 seconds
var consensusFactory = new PosConsensusFactory();
this.GenesisTime = network.GenesisTime;
this.GenesisNonce = network.GenesisNonce;
this.GenesisBits = network.GenesisBits;
this.GenesisVersion = network.GenesisVersion;
this.GenesisReward = network.GenesisReward;
Block genesisBlock = CreateGenesisBlock(consensusFactory,
this.GenesisTime,
this.GenesisNonce,
this.GenesisBits,
this.GenesisVersion,
this.GenesisReward,
setup.GenesisText);
this.Genesis = genesisBlock;
var buriedDeployments = new BuriedDeploymentsArray
{
[BuriedDeployments.BIP34] = 0,
[BuriedDeployments.BIP65] = 0,
[BuriedDeployments.BIP66] = 0
};
var bip9Deployments = new x42BIP9Deployments
{
[x42BIP9Deployments.ColdStaking] = new BIP9DeploymentsParameters("ColdStaking", 27, BIP9DeploymentsParameters.AlwaysActive, 999999999, BIP9DeploymentsParameters.DefaultMainnetThreshold),
[x42BIP9Deployments.CSV] = new BIP9DeploymentsParameters("CSV", 0, BIP9DeploymentsParameters.AlwaysActive, 999999999, BIP9DeploymentsParameters.DefaultMainnetThreshold),
[x42BIP9Deployments.Segwit] = new BIP9DeploymentsParameters("Segwit", 1, BIP9DeploymentsParameters.AlwaysActive, 999999999, BIP9DeploymentsParameters.DefaultMainnetThreshold)
};
consensusFactory.Protocol = new ConsensusProtocol()
{
ProtocolVersion = ProtocolVersion.FEEFILTER_VERSION,
MinProtocolVersion = ProtocolVersion.POS_PROTOCOL_VERSION,
};
this.Consensus = new x42Consensus(
consensusFactory: consensusFactory,
consensusOptions: consensusOptions,
coinType: setup.CoinType,
hashGenesisBlock: genesisBlock.GetHash(),
subsidyHalvingInterval: 24333,
majorityEnforceBlockUpgrade: 750,
majorityRejectBlockOutdated: 950,
majorityWindow: 1000,
buriedDeployments: buriedDeployments,
bip9Deployments: bip9Deployments,
bip34Hash: null,
minerConfirmationWindow: 2016, // nPowTargetTimespan / nPowTargetSpacing
maxReorgLength: 500,
defaultAssumeValid: null,
maxMoney: Money.Coins(42 * 1000000),
coinbaseMaturity: 50,
premineHeight: 2,
premineReward: Money.Coins(setup.PremineReward),
proofOfWorkReward: Money.Coins(setup.PoWBlockReward),
targetTimespan: TimeSpan.FromSeconds(14 * 24 * 60 * 60), // two weeks
targetSpacing: setup.TargetSpacing,
powAllowMinDifficultyBlocks: false,
posNoRetargeting: false,
powNoRetargeting: false,
powLimit: new Target(new uint256("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
minimumChainWork: null,
isProofOfStake: true,
lastPowBlock: setup.LastPowBlock,
proofOfStakeLimitV2: new BigInteger(uint256.Parse("000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffff").ToBytes(false)),
proofOfStakeReward: Money.Coins(setup.PoSBlockReward),
subsidyLimit: setup.SubsidyLimit,
proofOfStakeRewardAfterSubsidyLimit: setup.ProofOfStakeRewardAfterSubsidyLimit,
lastProofOfStakeRewardHeight: setup.LastProofOfStakeRewardHeight,
minOpReturnFee: Money.Coins(0.02m).Satoshi,
proofOfStakeTimestampMask: setup.ProofOfStakeTimestampMask,
posEmptyCoinbase: x42Setup.Instance.IsPoSv3()
)
{
PosUseTimeFieldInKernalHash = x42Setup.Instance.IsPoSv3()
};
// TODO: Set your Base58Prefixes
this.Base58Prefixes = new byte[12][];
this.Base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS] = new byte[] { (byte)network.PubKeyAddress };
this.Base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS] = new byte[] { (byte)network.ScriptAddress };
this.Base58Prefixes[(int)Base58Type.SECRET_KEY] = new byte[] { (byte)network.SecretAddress };
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), (0x88), (0xB2), (0x1E) };
this.Base58Prefixes[(int)Base58Type.EXT_SECRET_KEY] = new byte[] { (0x04), (0x88), (0xAD), (0xE4) };
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.ASSET_ID] = new byte[] { 23 };
this.Bech32Encoders = new Bech32Encoder[2];
var encoder = new Bech32Encoder(network.CoinTicker.ToLowerInvariant());
this.Bech32Encoders[(int)Bech32Type.WITNESS_PUBKEY_ADDRESS] = encoder;
this.Bech32Encoders[(int)Bech32Type.WITNESS_SCRIPT_ADDRESS] = encoder;
this.Checkpoints = network.Checkpoints;
this.DNSSeeds = network.DNS.Select(dns => new DNSSeedData(dns, dns)).ToList();
this.SeedNodes = network.Nodes.Select(node => new NBitcoin.Protocol.NetworkAddress(IPAddress.Parse(node), network.DefaultPort)).ToList();
this.XServerSeedNodes = new List <NetworkXServer>
{
new NetworkXServer("149.248.39.61", 4242),
new NetworkXServer("aliens.asuscomm.com", 4242),
new NetworkXServer("161.97.174.242", 4242),
new NetworkXServer("100.20.125.209", 4242),
new NetworkXServer("54.79.155.69", 4242),
new NetworkXServer("3.36.142.13", 4242),
new NetworkXServer("3.65.159.17", 4242),
new NetworkXServer("3.210.168.170", 4242),
new NetworkXServer("52.209.245.102", 4242),
new NetworkXServer("35.81.38.211", 4242),
new NetworkXServer("209.145.54.46", 4242),
};
this.StandardScriptsRegistry = new x42StandardScriptsRegistry();
// 64 below should be changed to TargetSpacingSeconds when we move that field.
Assert(this.DefaultBanTimeSeconds <= this.Consensus.MaxReorgLength * 64 / 2);
Assert(this.Consensus.HashGenesisBlock == uint256.Parse(network.HashGenesisBlock));
Assert(this.Genesis.Header.HashMerkleRoot == uint256.Parse(network.HashMerkleRoot));
RegisterRules(this.Consensus);
RegisterMempoolRules(this.Consensus);
}
private int TempConvertUnit(double tempCelsuis, TemperatureUnit tempUnit)
{
return(Numbers.RoundToInt(tempUnit == TemperatureUnit.Fahrenheit ?
ConversionTools.ToFahrenheit(tempCelsuis) : tempCelsuis));
}
