/*
Write a method that adds two positive integer numbers represented as
arrays of digits (each array element arr[i] contains a digit; the last
digit is kept in arr[0]). Each of the numbers that will be added
could have up to 10 000 digits.
*/
static BigInteger AddNumbers(BigInteger num1, BigInteger num2)
{
if (num1.ToString().Length < num2.ToString().Length)
{
BigInteger tempNum = num1;
num1 = num2;
num2 = tempNum;
}
char[] longerArr = num1.ToString().ToCharArray(); // Inserting the number in char array
Array.Reverse(longerArr);
char[] shorterArr = num2.ToString().ToCharArray(); // Inserting the number in char array
Array.Reverse(shorterArr);
byte[] summedNum = new byte[longerArr.Length + 1];
for (int i = 0; i < shorterArr.Length; i++)
{
byte rest = 0;
byte digitInMind = 0; // We can have only 0 or 1 in mind because we sum the digits from 0 to 9
// If the sum of the current digits is bigger than 10, we will
// have 1 in mind. In the other case we will just sum them.
if ((Convert.ToInt32(longerArr[i]) + // Subtract 96 because it sum the ASCII codes and we have two
Convert.ToInt32(shorterArr[i]) - 96) > 9) // numbers. They ASCII code of the numbers starts from 48. So 2x48
{
digitInMind = 1;
rest = (byte)((Convert.ToInt32(longerArr[i]) + Convert.ToInt32(shorterArr[i]) - 96) % 10);
}
else
{
rest = (byte)(Convert.ToInt32(longerArr[i]) + Convert.ToInt32(shorterArr[i] - 96));
}
summedNum[i] += rest; // Add the result to cell in the summed array
summedNum[i + 1] += digitInMind; // Add the "1" in mind to next cell in the summed array
}
// Adding the rest digits of the longer num
// when shorter num has no more digits.
for (int i = shorterArr.Length; i < longerArr.Length; i++)
{
summedNum[i] = (byte)(longerArr[i] - 48);
}
Array.Reverse(summedNum); // Reversing the number to get in the correct order
string result = "";
// Putting every digit in 1 string
for (int i = 0; i < summedNum.Length; i++)
{
result += summedNum[i];
}
return BigInteger.Parse(result); // Convert and return the string as number. Also removes the 0 in front.
}
private static int[] ConvertToArray(BigInteger num)
{
int[] digits = new int[num.ToString().Length];
string number = num.ToString();
BigInteger currentNumber = num;
for (int i = number.Length - 1; i >= 0; i--)
{
digits[i] = (int)(currentNumber % 10);
currentNumber /= 10;
}
return digits;
}
static int[] IntegerRepresentedAsArray(BigInteger number)
{
int[] numArray = new int[number.ToString().Length];
int index = 0;
foreach (char num in number.ToString())
{
numArray[index] = (int)(number % 10);
number /= 10;
++index;
}
return numArray;
}
public object Convert(object value, Type targetType,
object parameter, CultureInfo culture)
{
BigInteger buffer = value as BigInteger;
return(buffer?.ToString());
}
public void Big()
{
BigInteger BigInteger = new BigInteger(int.MaxValue);
BigInteger += BigInteger += BigInteger += BigInteger;
long longX = int.MaxValue;
longX += longX += longX += longX;
Assert.Equal(BigInteger.ToString(), longX.ToString());
}
public void DisplayTapValueAt(Vector3 position, BigInteger value)
{
GameObject canvas = GameObject.Find("Canvas");
GameObject text = (GameObject) Instantiate(risingText);
text.transform.position = position;
text.transform.SetParent(canvas.transform);
text.GetComponent<RisingText>().Setup("+" + value.ToString(), 3f, 100f);
}
static void Main(String[] args)
{
BigInteger number = new BigInteger(1);
int n = int.Parse(Console.ReadLine());
for (int i = 0; i < n; i++)
{
number = BigInteger.Multiply(number, new BigInteger(i + 1));
}
Console.WriteLine(number.ToString());
}
public static void Main()
{
BigInteger n = new BigInteger(1);
/* Left bit shifting is the same as raising to power of 2 */
n <<= 1000;
String s = n.ToString();
int sum = 0;
for(int i = 0, j = s.Length; i < j; sum += Int32.Parse(s.Substring(i, 1)), i++)
;
Console.WriteLine(sum);
}
static void Main(string[] args)
{
long value = Basics.getLong ("Ingresa un número: ");
BigInteger number = new BigInteger (value);
number = Factorial (number);
Console.WriteLine (number.ToString ("N0"));
Console.Read ();
}
//converts a number to an array where the last digit is at index 0
static BigInteger[] NumberToArray(BigInteger number)
{
string numberString = number.ToString();
BigInteger[] numberArr = new BigInteger[numberString.Length];
for (int i = 0; i < numberArr.Length; i++)
{
numberArr[i] = number % 10;
number /= 10;
}
return numberArr;
}
static int[] FillArray(BigInteger number)
{
string numberToString = number.ToString();
int numberLength = numberToString.Length;
int[] array = new int[numberLength];
for (int i = numberLength - 1; i >= 0; i--)
{
array[i] = (int)number % 10;
number /= 10;
}
return array;
}
private static int[] InputToArray(BigInteger input)
{
int[] arr = new int[input.ToString().Length];
BigInteger number = input;
int len = number.ToString().Length;
for (int i = 0; i < len; i++)
{
arr[i] = (int)number % 10;
number /= 10;
}
Array.Reverse(arr);
return arr;
}
public string GetN(int n)
{
BigInteger n0 = new BigInteger(this.a);
BigInteger n1 = new BigInteger(this.b);
BigInteger n2 = new BigInteger(0);
int i = 2;
while (i < n)
{
n2 = BigInteger.Add(BigInteger.Multiply(n1, n1), n0);
n0 = n1;
n1 = n2;
i++;
}
return n1.ToString();
}
static string GetHashOfPermutation(BigInteger i)
{
List<int> numberDigits = new List<int>();
string s = i.ToString();
for (int a = 0; a < s.Length; a++)
numberDigits.Add(System.Convert.ToInt16(s.Substring(a, 1)));
numberDigits.Sort();
s = "";
foreach (int j in numberDigits)
s += j.ToString();
// Hash is the number sorted from lowest to highest value
return s;
}
private static bool VerifyCtorInt32(Int32 value)
{
bool ret = true;
BigInteger bigInteger;
bigInteger = new BigInteger(value);
if (!bigInteger.Equals(value))
{
Console.WriteLine("Expected BigInteger {0} to be equal to Int32 {1}", bigInteger, value);
ret = false;
}
if (String.CompareOrdinal(value.ToString(), bigInteger.ToString()) != 0)
{
Console.WriteLine("Int32.ToString() and BigInteger.ToString() on {0} and {1} should be equal", value, bigInteger);
ret = false;
}
if (value != (Int32)bigInteger)
{
Console.WriteLine("Expected BigInteger {0} to be equal to Int32 {1}", bigInteger, value);
ret = false;
}
if (value != Int32.MaxValue)
{
if ((Int32)(value + 1) != (Int32)(bigInteger + 1))
{
Console.WriteLine("Adding 1 to both {0} and {1} should remain equal", value, bigInteger);
ret = false;
}
}
if (value != Int32.MinValue)
{
if ((Int32)(value - 1) != (Int32)(bigInteger - 1))
{
Console.WriteLine("Subtracting 1 from both {0} and {1} should remain equal", value, bigInteger);
ret = false;
}
}
Assert.True(VerifyBigintegerUsingIdentities(bigInteger, 0 == value), " Verification Failed");
return ret;
}
private void btnOpen_Click(object sender, EventArgs e)
{
string tempKi = "";
Ki = Sign.BI_Generate_Ki();
tempKi = Ki.ToString();
try
{
Ki = new BigInteger(tempKi, 10);
find = true;
txtPrivateKey.Text = Ki.ToString();
}
catch
{
MessageBox.Show("Неверный ключ");
}
}
private static ulong ZeroesCounter(BigInteger factorial)
{
string factorialToString = factorial.ToString ();
ulong counter = 0;
int[] array = new int[factorialToString.Length];
for (int i = 0; i < factorialToString.Length; i++) {
array[i]=factorialToString[factorialToString.Length-1 -i] - '0';
}
for (int i = 0; i < array.Length-1; i++) {
if(array[i]==0) {
counter++;
if (array[i+1]!=0) {
break;
}
}
}
return counter;
}
public Task <DryRunResults> DryRunTransactionsAsync(List <Dictionary <AccountParameter, object> > accounts, BigInteger?block, List <UnsignedTx> unsignedTransactions, CancellationToken token = default(CancellationToken))
{
DryRunInput body = new DryRunInput();
if (accounts == null || accounts.Count == 0)
{
throw new ArgumentException($"Invalid Parameter accounts: {Validation.NO_ENTRIES}");
}
if (unsignedTransactions == null || unsignedTransactions.Count == 0)
{
throw new ArgumentException($"Invalid Parameter unsignedTransactions: {Validation.NO_ENTRIES}");
}
if (accounts.Count != unsignedTransactions.Count)
{
throw new ArgumentException($"Invalid Parameter unsignedTransactions: {Validation.LIST_NOT_SAME_SIZE}");
}
List <DryRunAccount> dryRunAccounts = new List <DryRunAccount>();
foreach (Dictionary <AccountParameter, object> txParams in accounts)
{
DryRunAccount currAccount = new DryRunAccount();
if (txParams.Count == 0)
{
throw new ArgumentException($"Invalid Parameter accounts.Dictionary: {Validation.NO_ENTRIES}");
}
if (!txParams.ContainsKey(AccountParameter.PUBLIC_KEY))
{
throw new ArgumentException($"Invalid Parameter accounts.Dictionary missing value: {string.Format(Validation.MAP_MISSING_VALUE, AccountParameter.PUBLIC_KEY)}");
}
currAccount.PublicKey = txParams[AccountParameter.PUBLIC_KEY].ToString();
currAccount.Amount = txParams.ContainsKey(AccountParameter.AMOUNT) ? BigInteger.Parse(txParams[AccountParameter.AMOUNT].ToString()) : BigInteger.Zero;
dryRunAccounts.Add(currAccount);
}
body.Accounts = dryRunAccounts;
body.Top = block?.ToString();
unsignedTransactions.ForEach(item => body.TXs.Add(new DryRunInputItem {
CallReq = null, TX = item.TX
}));
_logger.LogDebug("Calling dry run on block {0} with body {1}", block, body);
return(_apiClient.DryRunTxsAsync(body, token));
}
private static void VerifyCtorInt32(Int32 value)
{
BigInteger bigInteger = new BigInteger(value);
Assert.Equal(value, bigInteger);
Assert.Equal(0, String.CompareOrdinal(value.ToString(), bigInteger.ToString()));
Assert.Equal(value, (Int32)bigInteger);
if (value != Int32.MaxValue)
{
Assert.Equal((Int32)(value + 1), (Int32)(bigInteger + 1));
}
if (value != Int32.MinValue)
{
Assert.Equal((Int32)(value - 1), (Int32)(bigInteger - 1));
}
VerifyBigIntegerUsingIdentities(bigInteger, 0 == value);
}
// waaaaaaay too much parameters, should be less than 3
public void DisplayTapValueAt(Vector2 position, BigInteger value, bool special)
{
GameObject canvas = GameObject.Find("Canvas");
GameObject text = (GameObject) Instantiate(risingText);
text.transform.position = position;
text.transform.SetParent(canvas.transform);
RisingText rising = text.GetComponent<RisingText>();
rising.Text = "+" + value.ToString();
rising.Duration = 3f;
rising.UpSpeed = 100f;
if (special) {
rising.Color = Color.yellow;
rising.FontSize = 20;
} else
{
rising.Color = Color.white;
rising.FontSize = 16;
}
rising.Init();
}
static void Main()
{
BigInteger number = BigInteger.Parse(Console.ReadLine());
BigInteger result = 1;
int counter = 0;
while (number > 1)
{
counter = 1;
number = number / 10;
string currentnumber = number.ToString();
BigInteger currentEvenSum = 0;
for (int i = 0; i < currentnumber.Length; i++)
{
if (i % 2 == 0)
{
currentEvenSum += currentnumber[i] - '0';
}
}
if (currentEvenSum != 0)
{
result *= currentEvenSum;
}
}
while (result > 10)
{
counter++;
if (counter > 10)
{
break;
}
number = result;
result = 1;
while (number > 1)
{
number = number / 10;
string currentnumber = number.ToString();
BigInteger currentEvenSum = 0;
for (int i = 0; i < currentnumber.Length; i++)
{
if (i % 2 == 0)
{
currentEvenSum += currentnumber[i] - '0';
}
}
if (currentEvenSum != 0)
{
result *= currentEvenSum;
}
}
}
if (counter < 10)
{
Console.WriteLine(counter);
Console.WriteLine(result);
}
else
{
Console.WriteLine(result);
}
}
public static void Main(string[] args)
{
// Known problem -> these two pseudoprimes passes my implementation of
// primality test but failed in JDK's isProbablePrime test.
byte[] pseudoPrime1 = { (byte)0x00,
(byte)0x85, (byte)0x84, (byte)0x64, (byte)0xFD, (byte)0x70, (byte)0x6A,
(byte)0x9F, (byte)0xF0, (byte)0x94, (byte)0x0C, (byte)0x3E, (byte)0x2C,
(byte)0x74, (byte)0x34, (byte)0x05, (byte)0xC9, (byte)0x55, (byte)0xB3,
(byte)0x85, (byte)0x32, (byte)0x98, (byte)0x71, (byte)0xF9, (byte)0x41,
(byte)0x21, (byte)0x5F, (byte)0x02, (byte)0x9E, (byte)0xEA, (byte)0x56,
(byte)0x8D, (byte)0x8C, (byte)0x44, (byte)0xCC, (byte)0xEE, (byte)0xEE,
(byte)0x3D, (byte)0x2C, (byte)0x9D, (byte)0x2C, (byte)0x12, (byte)0x41,
(byte)0x1E, (byte)0xF1, (byte)0xC5, (byte)0x32, (byte)0xC3, (byte)0xAA,
(byte)0x31, (byte)0x4A, (byte)0x52, (byte)0xD8, (byte)0xE8, (byte)0xAF,
(byte)0x42, (byte)0xF4, (byte)0x72, (byte)0xA1, (byte)0x2A, (byte)0x0D,
(byte)0x97, (byte)0xB1, (byte)0x31, (byte)0xB3,
};
byte[] pseudoPrime2 = { (byte)0x00,
(byte)0x99, (byte)0x98, (byte)0xCA, (byte)0xB8, (byte)0x5E, (byte)0xD7,
(byte)0xE5, (byte)0xDC, (byte)0x28, (byte)0x5C, (byte)0x6F, (byte)0x0E,
(byte)0x15, (byte)0x09, (byte)0x59, (byte)0x6E, (byte)0x84, (byte)0xF3,
(byte)0x81, (byte)0xCD, (byte)0xDE, (byte)0x42, (byte)0xDC, (byte)0x93,
(byte)0xC2, (byte)0x7A, (byte)0x62, (byte)0xAC, (byte)0x6C, (byte)0xAF,
(byte)0xDE, (byte)0x74, (byte)0xE3, (byte)0xCB, (byte)0x60, (byte)0x20,
(byte)0x38, (byte)0x9C, (byte)0x21, (byte)0xC3, (byte)0xDC, (byte)0xC8,
(byte)0xA2, (byte)0x4D, (byte)0xC6, (byte)0x2A, (byte)0x35, (byte)0x7F,
(byte)0xF3, (byte)0xA9, (byte)0xE8, (byte)0x1D, (byte)0x7B, (byte)0x2C,
(byte)0x78, (byte)0xFA, (byte)0xB8, (byte)0x02, (byte)0x55, (byte)0x80,
(byte)0x9B, (byte)0xC2, (byte)0xA5, (byte)0xCB,
};
Console.WriteLine("List of primes < 2000\n---------------------");
int limit = 100, count = 0;
for(int i = 0; i < 2000; i++)
{
if(i >= limit)
{
Console.WriteLine();
limit += 100;
}
BigInteger p = new BigInteger(-i);
if(p.isProbablePrime())
{
Console.Write(i + ", ");
count++;
}
}
Console.WriteLine("\nCount = " + count);
BigInteger bi1 = new BigInteger(pseudoPrime1);
Console.WriteLine("\n\nPrimality testing for\n" + bi1.ToString() + "\n");
Console.WriteLine("SolovayStrassenTest(5) = " + bi1.SolovayStrassenTest(5));
Console.WriteLine("RabinMillerTest(5) = " + bi1.RabinMillerTest(5));
Console.WriteLine("FermatLittleTest(5) = " + bi1.FermatLittleTest(5));
Console.WriteLine("isProbablePrime() = " + bi1.isProbablePrime());
Console.Write("\nGenerating 512-bits random pseudoprime. . .");
Random rand = new Random();
BigInteger prime = BigInteger.genPseudoPrime(512, 5, rand);
Console.WriteLine("\n" + prime);
//int dwStart = System.Environment.TickCount;
//BigInteger.MulDivTest(100000);
//BigInteger.RSATest(10);
//BigInteger.RSATest2(10);
//Console.WriteLine(System.Environment.TickCount - dwStart);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual string Literal(BigInteger value)
=> $"BigInteger.Parse(\"{value.ToString(NumberFormatInfo.InvariantInfo)}\", NumberFormatInfo.InvariantInfo)";
private static string RenderFormat(PrintfFormat format, Variable arg)
{
int n;
if (format.directive == PrintfDirective.String)
{
return(arg.Fetch().mo.mro_raw_Str.Get(arg));
}
if (format.directive == PrintfDirective.CodePoint)
{
n = (int)arg.Fetch().mo.mro_raw_Numeric.Get(arg);
return("" + (char)n);
}
bool add_minus_sign = false;
if (format.directive == PrintfDirective.Int)
{
P6any o1 = arg.Fetch();
int r1;
P6any n1 = GetNumber(arg, o1, out r1);
Variable arg2;
if (r1 != NR_BIGINT && r1 != NR_FIXINT)
{
arg2 = Builtins.InvokeMethod("Int", arg);
o1 = arg2.Fetch();
n1 = GetNumber(arg2, o1, out r1);
}
BigInteger value = PromoteToBigInt(r1, n1);
if (value < 0)
{
add_minus_sign = true;
value = -value;
}
String number;
if (format.radix == 16)
{
number = RemoveInitialZero(value.ToString(format.radix, null)).ToLower();
}
else
{
number = value.ToString(format.radix, null);
}
if (format.upper)
{
number = number.ToUpper();
}
if (add_minus_sign)
{
if (format.rightJustifyZeroes)
{
return("-" + number.PadLeft(format.minimumWidth - 1, '0'));
}
else
{
return("-" + number);
}
}
return(number);
}
else
{
double f = arg.Fetch().mo.mro_raw_Numeric.Get(arg);
if (f < 0.0)
{
add_minus_sign = true;
f = -f;
}
int precision = format.precision > 0 ? format.precision : 6;
String number = "??";
switch (format.directive)
{
case PrintfDirective.FloatFixedDecimal:
number = f.ToString("F" + precision);
break;
case PrintfDirective.FloatScientific:
number = f.ToString("e" + precision);
break;
case PrintfDirective.FloatEF:
number = f.ToString("g" + precision);
break;
}
if (format.upper)
{
number = number.ToUpper();
}
if (add_minus_sign)
{
if (format.rightJustifyZeroes)
{
return("-" + number.PadLeft(format.minimumWidth - 1, '0'));
}
else
{
return("-" + number);
}
}
return(number);
}
}
protected override async Task OnUpdate()
{
_dbContext.DetachEverything();
// get events
var log = await _ethereumReader.GatherPoolFreezerEvents(_lastBlock - 1, _lastBlock + _blocksPerRound, _confirmationsRequired);
_lastBlock = log.ToBlock;
Logger.Debug(
(log.Events.Length > 0
? $"{log.Events.Length} request(s) found"
: "Nothing found"
) + $" in blocks [{log.FromBlock} - {log.ToBlock}]"
);
if (IsCancelled())
{
return;
}
foreach (var v in log.Events)
{
if (IsCancelled())
{
return;
}
Logger.Debug($"Trying to enqueue pool-freezer event with tx {v.TransactionId}");
try {
var model = new DAL.Models.PoolFreezeRequest()
{
Status = EmissionRequestStatus.Initial,
EthAddress = v.Address,
EthTransaction = v.TransactionId,
Amount = v.Amount.FromSumus(),
SumAddress = v.SumusAddress,
SumTransaction = null,
TimeCreated = DateTime.UtcNow,
TimeCompleted = null,
};
_dbContext.PoolFreezeRequest.Add(model);
await _dbContext.SaveChangesAsync();
Logger.Information(
$"Pool-freezer event enqueued for tx {v.TransactionId}"
);
} catch (Exception e) {
if (!ExceptionExtension.IsMySqlDuplicateException(e))
{
Logger.Error(e, $"Pool-freezer event failed with tx {v.TransactionId}");
}
}
++_statProcessed;
}
// save last index to settings
if (_lastSavedBlock != _lastBlock)
{
if (await _dbContext.SaveDbSetting(DbSetting.PoolFreezerHarvLastBlock, _lastBlock.ToString()))
{
_lastSavedBlock = _lastBlock;
Logger.Debug($"Last block #{_lastBlock} saved to DB");
}
}
}
private BigInteger ReverseNumber(BigInteger number)
{
string reversedNumberString = new string(number.ToString().Reverse().ToArray());
return(BigInteger.Parse(reversedNumberString));
}
public static BigDecimal InducedFrom(RubyContext /*!*/ context, RubyClass /*!*/ self, [NotNull] BigInteger /*!*/ value)
{
return(BigDecimal.Create(GetConfig(context), value.ToString(CultureInfo.InvariantCulture)));
}
public static string __repr__([NotNull] BigInteger /*!*/ self)
{
return(self.ToString());
}
public override string ToString()
{
return(value.ToString());
}
public static string /*!*/ __format__(CodeContext /*!*/ context, BigInteger /*!*/ self, [NotNull] string /*!*/ formatSpec)
{
StringFormatSpec spec = StringFormatSpec.FromString(formatSpec);
if (spec.Precision != null)
{
throw PythonOps.ValueError("Precision not allowed in integer format specifier");
}
BigInteger val = self;
if (self < 0)
{
val = -self;
}
string digits;
switch (spec.Type)
{
case 'n':
CultureInfo culture = context.LanguageContext.NumericCulture;
if (culture == CultureInfo.InvariantCulture)
{
// invariant culture maps to CPython's C culture, which doesn't
// include any formatting info.
goto case 'd';
}
digits = FormattingHelper.ToCultureString(val, context.LanguageContext.NumericCulture.NumberFormat, spec);
break;
case null:
case 'd':
if (spec.ThousandsComma)
{
var width = spec.Width ?? 0;
// If we're inserting commas, and we're padding with leading zeros.
// AlignNumericText won't know where to place the commas,
// so force .Net to help us out here.
if (spec.Fill.HasValue && spec.Fill.Value == '0' && width > 1)
{
digits = val.ToString(FormattingHelper.ToCultureString(self, FormattingHelper.InvariantCommaNumberInfo, spec));
}
else
{
digits = val.ToString("#,0", CultureInfo.InvariantCulture);
}
}
else
{
digits = val.ToString("D", CultureInfo.InvariantCulture);
}
break;
case '%':
if (spec.ThousandsComma)
{
digits = val.ToString("#,0.000000%", CultureInfo.InvariantCulture);
}
else
{
digits = val.ToString("0.000000%", CultureInfo.InvariantCulture);
}
break;
case 'e':
if (spec.ThousandsComma)
{
digits = val.ToString("#,0.000000e+00", CultureInfo.InvariantCulture);
}
else
{
digits = val.ToString("0.000000e+00", CultureInfo.InvariantCulture);
}
break;
case 'E':
if (spec.ThousandsComma)
{
digits = val.ToString("#,0.000000E+00", CultureInfo.InvariantCulture);
}
else
{
digits = val.ToString("0.000000E+00", CultureInfo.InvariantCulture);
}
break;
case 'f':
case 'F':
if (spec.ThousandsComma)
{
digits = val.ToString("#,########0.000000", CultureInfo.InvariantCulture);
}
else
{
digits = val.ToString("#########0.000000", CultureInfo.InvariantCulture);
}
break;
case 'g':
if (val >= 1000000)
{
digits = val.ToString("0.#####e+00", CultureInfo.InvariantCulture);
}
else if (spec.ThousandsComma)
{
goto case 'd';
}
else
{
digits = val.ToString(CultureInfo.InvariantCulture);
}
break;
case 'G':
if (val >= 1000000)
{
digits = val.ToString("0.#####E+00", CultureInfo.InvariantCulture);
}
else if (spec.ThousandsComma)
{
goto case 'd';
}
else
{
digits = val.ToString(CultureInfo.InvariantCulture);
}
break;
case 'X':
digits = AbsToHex(val, false);
break;
case 'x':
digits = AbsToHex(val, true);
break;
case 'o': // octal
digits = ToOctal(val, true);
break;
case 'b': // binary
digits = ToBinary(val, false, true);
break;
case 'c': // single char
int iVal;
if (spec.Sign != null)
{
throw PythonOps.ValueError("Sign not allowed with integer format specifier 'c'");
}
else if (!self.AsInt32(out iVal))
{
throw PythonOps.OverflowError("long int too large to convert to int");
}
else if (iVal < 0 || iVal > 0x10ffff)
{
throw PythonOps.OverflowError("%c arg not in range(0x110000)");
}
digits = (iVal > char.MaxValue) ? char.ConvertFromUtf32(iVal) : ScriptingRuntimeHelpers.CharToString((char)iVal);
break;
default:
throw PythonOps.ValueError("Unknown format code '{0}' for object of type 'int'", spec.TypeRepr);
}
Debug.Assert(digits[0] != '-');
return(spec.AlignNumericText(digits, self.IsZero(), self.IsPositive()));
}
private static string /*!*/ ToExponent(BigInteger /*!*/ self, bool lower, int minPrecision, int maxPrecision)
{
Debug.Assert(minPrecision <= maxPrecision);
// get all the digits
string digits = self.ToString();
StringBuilder tmp = new StringBuilder();
tmp.Append(digits[0]);
for (int i = 1; i < maxPrecision && i < digits.Length; i++)
{
// append if we have a significant digit or if we are forcing a minimum precision
if (digits[i] != '0' || i <= minPrecision)
{
if (tmp.Length == 1)
{
// first time we've appended, add the decimal point now
tmp.Append('.');
}
while (i > tmp.Length - 1)
{
// add any digits that we skipped before
tmp.Append('0');
}
// round up last digit if necessary
if (i == maxPrecision - 1 && i != digits.Length - 1 && digits[i + 1] >= '5')
{
tmp.Append((char)(digits[i] + 1));
}
else
{
tmp.Append(digits[i]);
}
}
}
if (digits.Length <= minPrecision)
{
if (tmp.Length == 1)
{
// first time we've appended, add the decimal point now
tmp.Append('.');
}
while (minPrecision >= tmp.Length - 1)
{
tmp.Append('0');
}
}
tmp.Append(lower ? "e+" : "E+");
int digitCnt = digits.Length - 1;
if (digitCnt < 10)
{
tmp.Append('0');
tmp.Append((char)('0' + digitCnt));
}
else
{
tmp.Append(digitCnt.ToString());
}
digits = tmp.ToString();
return(digits);
}
public void OnPost()
{
String ID = HttpContext.Session.GetString("ID");
String Exception = "";
Boolean CheckConnection = MyOwnMySQLConnectionClass.LoadConnection(ref Exception);
MySqlCommand MySQLQuery = new MySqlCommand();
MySqlDataReader PublicKeyDBReader;
int Checker = 0;
DateTime MyUTCDateTime = DateTime.UtcNow.AddHours(8);
String PrivateKeyString = Request.Form["SK_Diffie_Hellman"].ToString();
String Current_User = HttpContext.Session.GetString("User_Name");
String PublicKeyStringDB = "";
BigInteger PrivateKey = BigInteger.Parse(PrivateKeyString);
BigInteger PublicKey = 0;
Byte[] PrivateKeyBytes = new Byte[] { };
Byte[] PublicKeyBytes = new Byte[] { };
PrivateKeyBytes = PrivateKey.ToByteArray();
PublicKeyBytes = ScalarMult.Base(PrivateKeyBytes);
PublicKey = new BigInteger(PublicKeyBytes);
MySQLQuery.CommandText = "SELECT COUNT(*) FROM `DF_Public_Key` WHERE `Requestor_1`=@Current_User AND `ID`=@ID";
MySQLQuery.Parameters.Add("@Current_User", MySqlDbType.Text).Value = Current_User;
MySQLQuery.Parameters.Add("@ID", MySqlDbType.Text).Value = ID;
MySQLQuery.Connection = MyOwnMySQLConnectionClass.MyMySQLConnection;
MySQLQuery.Prepare();
Checker = int.Parse(MySQLQuery.ExecuteScalar().ToString());
if (Checker == 1)
{
MySQLQuery = new MySqlCommand();
MySQLQuery.CommandText = "SELECT `Requestor_1_PK` FROM `DF_Public_Key` WHERE `ID`=@ID";
MySQLQuery.Parameters.Add("@ID", MySqlDbType.Text).Value = ID;
MySQLQuery.Connection = MyOwnMySQLConnectionClass.MyMySQLConnection;
MySQLQuery.Prepare();
PublicKeyDBReader = MySQLQuery.ExecuteReader();
while (PublicKeyDBReader.Read())
{
PublicKeyStringDB = PublicKeyDBReader.GetValue(0).ToString();
}
MyOwnMySQLConnectionClass.MyMySQLConnection.Close();
CheckConnection = MyOwnMySQLConnectionClass.LoadConnection(ref Exception);
MySQLQuery = new MySqlCommand();
MySQLQuery.CommandText = "UPDATE `DF_Public_Key` SET `Last_Checked_Date_R1`=@Last_Checked_Date_R1,`Requestor_1_PK`=@Requestor_1_PK WHERE `ID`=@ID";
MySQLQuery.Parameters.Add("@Last_Checked_Date_R1", MySqlDbType.DateTime).Value = MyUTCDateTime;
MySQLQuery.Parameters.Add("@Requestor_1_PK", MySqlDbType.Text).Value = PublicKey.ToString();
MySQLQuery.Parameters.Add("@ID", MySqlDbType.Text).Value = ID;
MySQLQuery.Connection = MyOwnMySQLConnectionClass.MyMySQLConnection;
MySQLQuery.Prepare();
MySQLQuery.ExecuteNonQuery();
}
else
{
MySQLQuery = new MySqlCommand();
MySQLQuery.CommandText = "SELECT `Requestor_2_PK` FROM `DF_Public_Key` WHERE `ID`=@ID";
MySQLQuery.Parameters.Add("@ID", MySqlDbType.Text).Value = ID;
MySQLQuery.Connection = MyOwnMySQLConnectionClass.MyMySQLConnection;
MySQLQuery.Prepare();
PublicKeyDBReader = MySQLQuery.ExecuteReader();
while (PublicKeyDBReader.Read())
{
PublicKeyStringDB = PublicKeyDBReader.GetValue(0).ToString();
}
MyOwnMySQLConnectionClass.MyMySQLConnection.Close();
CheckConnection = MyOwnMySQLConnectionClass.LoadConnection(ref Exception);
MySQLQuery = new MySqlCommand();
MySQLQuery.CommandText = "UPDATE `DF_Public_Key` SET `Last_Checked_Date_R2`=@Last_Checked_Date_R2,`Requestor_2_PK`=@Requestor_2_PK WHERE `ID`=@ID";
MySQLQuery.Parameters.Add("@Last_Checked_Date_R2", MySqlDbType.DateTime).Value = MyUTCDateTime;
MySQLQuery.Parameters.Add("@Requestor_2_PK", MySqlDbType.Text).Value = PublicKey.ToString();
MySQLQuery.Parameters.Add("@ID", MySqlDbType.Text).Value = ID;
MySQLQuery.Connection = MyOwnMySQLConnectionClass.MyMySQLConnection;
MySQLQuery.Prepare();
MySQLQuery.ExecuteNonQuery();
}
if (PublicKeyStringDB.CompareTo(PublicKey.ToString()) == 0)
{
ViewData["Result"] = "Your public key value hasn't been tampered with..";
}
else
{
ViewData["Result"] = "You better watch out someone has modified ur public key value..";
}
HttpContext.Session.Remove("ID");
}
private static string ToStringInternal(BigInteger value)
{
return(value.ToString(null, CultureInfo.InvariantCulture));
}
private static string writeHex(BigInteger value)
{
return(value.ToString("x").TrimStart('0'));
}
private int GetEthUnitValueLength(BigInteger unitValue)
{
return(unitValue.ToString().Length - 1);
}
public string ToString(int radix)
{
return(_value.ToString(radix));
}
// Only the ctor should be calling with isAuthority = true
// if isAuthority, value for isMachineCert doesn't matter
private X509CertificateContainer CreateCertificate(bool isAuthority, bool isMachineCert, X509Certificate signingCertificate, CertificateCreationSettings certificateCreationSettings)
{
if (certificateCreationSettings == null)
{
if (isAuthority)
{
certificateCreationSettings = new CertificateCreationSettings();
}
else
{
throw new Exception("Parameter certificateCreationSettings cannot be null when isAuthority is false");
}
}
// Set to default cert creation settings if not set
if (certificateCreationSettings.ValidityNotBefore == default(DateTime))
{
certificateCreationSettings.ValidityNotBefore = _defaultValidityNotBefore;
}
if (certificateCreationSettings.ValidityNotAfter == default(DateTime))
{
certificateCreationSettings.ValidityNotAfter = _defaultValidityNotAfter;
}
if (!isAuthority ^ (signingCertificate != null))
{
throw new ArgumentException("Either isAuthority == true or signingCertificate is not null");
}
string subject = certificateCreationSettings.Subject;
// If certificateCreationSettings.SubjectAlternativeNames == null, then we should add exactly one SubjectAlternativeName == Subject
// so that the default certificate generated is compatible with mainline scenarios
// However, if certificateCreationSettings.SubjectAlternativeNames == string[0], then allow this as this is a legit scenario we want to test out
if (certificateCreationSettings.SubjectAlternativeNames == null)
{
certificateCreationSettings.SubjectAlternativeNames = new string[1] {
subject
};
}
string[] subjectAlternativeNames = certificateCreationSettings.SubjectAlternativeNames;
if (!isAuthority && string.IsNullOrWhiteSpace(subject))
{
throw new ArgumentException("Certificate Subject must not be an empty string or only whitespace", "creationSettings.Subject");
}
EnsureInitialized();
_certGenerator.Reset();
_certGenerator.SetSignatureAlgorithm(_signatureAlthorithm);
X509Name authorityX509Name = CreateX509Name(_authorityCanonicalName);
var serialNum = new BigInteger(64 /*sizeInBits*/, _random).Abs();
var keyPair = isAuthority ? _authorityKeyPair : _keyPairGenerator.GenerateKeyPair();
if (isAuthority)
{
_certGenerator.SetIssuerDN(authorityX509Name);
_certGenerator.SetSubjectDN(authorityX509Name);
var authorityKeyIdentifier = new AuthorityKeyIdentifier(
SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(_authorityKeyPair.Public),
new GeneralNames(new GeneralName(authorityX509Name)),
serialNum);
_certGenerator.AddExtension(X509Extensions.AuthorityKeyIdentifier, false, authorityKeyIdentifier);
_certGenerator.AddExtension(X509Extensions.KeyUsage, false, new KeyUsage(X509KeyUsage.DigitalSignature | X509KeyUsage.KeyAgreement | X509KeyUsage.KeyCertSign | X509KeyUsage.KeyEncipherment | X509KeyUsage.CrlSign));
}
else
{
X509Name subjectName = CreateX509Name(subject);
_certGenerator.SetIssuerDN(PrincipalUtilities.GetSubjectX509Principal(signingCertificate));
_certGenerator.SetSubjectDN(subjectName);
_certGenerator.AddExtension(X509Extensions.AuthorityKeyIdentifier, false, new AuthorityKeyIdentifierStructure(_authorityKeyPair.Public));
_certGenerator.AddExtension(X509Extensions.KeyUsage, false, new KeyUsage(X509KeyUsage.DigitalSignature | X509KeyUsage.KeyAgreement | X509KeyUsage.KeyEncipherment));
}
_certGenerator.AddExtension(X509Extensions.SubjectKeyIdentifier, false, new SubjectKeyIdentifierStructure(keyPair.Public));
_certGenerator.SetSerialNumber(serialNum);
_certGenerator.SetNotBefore(certificateCreationSettings.ValidityNotBefore);
_certGenerator.SetNotAfter(certificateCreationSettings.ValidityNotAfter);
_certGenerator.SetPublicKey(keyPair.Public);
_certGenerator.AddExtension(X509Extensions.BasicConstraints, true, new BasicConstraints(isAuthority));
_certGenerator.AddExtension(X509Extensions.ExtendedKeyUsage, false, new ExtendedKeyUsage(KeyPurposeID.IdKPServerAuth, KeyPurposeID.IdKPClientAuth));
if (!isAuthority)
{
if (isMachineCert)
{
List <Asn1Encodable> subjectAlternativeNamesAsAsn1EncodableList = new List <Asn1Encodable>();
// All endpoints should also be in the Subject Alt Names
for (int i = 0; i < subjectAlternativeNames.Length; i++)
{
if (!string.IsNullOrWhiteSpace(subjectAlternativeNames[i]))
{
// Machine certs can have additional DNS names
subjectAlternativeNamesAsAsn1EncodableList.Add(new GeneralName(GeneralName.DnsName, subjectAlternativeNames[i]));
}
}
_certGenerator.AddExtension(X509Extensions.SubjectAlternativeName, true, new DerSequence(subjectAlternativeNamesAsAsn1EncodableList.ToArray()));
}
else
{
if (subjectAlternativeNames.Length > 1)
{
var subjectAlternativeNamesAsAsn1EncodableList = new Asn1EncodableVector();
// Only add a SAN for the user if there are any
for (int i = 1; i < subjectAlternativeNames.Length; i++)
{
if (!string.IsNullOrWhiteSpace(subjectAlternativeNames[i]))
{
Asn1EncodableVector otherNames = new Asn1EncodableVector();
otherNames.Add(new DerObjectIdentifier(_upnObjectId));
otherNames.Add(new DerTaggedObject(true, 0, new DerUtf8String(subjectAlternativeNames[i])));
Asn1Object genName = new DerTaggedObject(false, 0, new DerSequence(otherNames));
subjectAlternativeNamesAsAsn1EncodableList.Add(genName);
}
}
_certGenerator.AddExtension(X509Extensions.SubjectAlternativeName, true, new DerSequence(subjectAlternativeNamesAsAsn1EncodableList));
}
}
}
// Our CRL Distribution Point has the serial number in the query string to fool Windows into doing a fresh query
// rather than using a cached copy of the CRL in the case where the CRL has been previously accessed before
var crlDistributionPoints = new DistributionPoint[2] {
new DistributionPoint(new DistributionPointName(
new GeneralNames(new GeneralName(
GeneralName.UniformResourceIdentifier, string.Format("{0}?serialNum={1}", _crlUri, serialNum.ToString(radix: 16))))),
null,
null),
new DistributionPoint(new DistributionPointName(
new GeneralNames(new GeneralName(
GeneralName.UniformResourceIdentifier, string.Format("{0}?serialNum={1}", _crlUri, serialNum.ToString(radix: 16))))),
null,
new GeneralNames(new GeneralName(authorityX509Name)))
};
var revocationListExtension = new CrlDistPoint(crlDistributionPoints);
_certGenerator.AddExtension(X509Extensions.CrlDistributionPoints, false, revocationListExtension);
X509Certificate cert = _certGenerator.Generate(_authorityKeyPair.Private, _random);
switch (certificateCreationSettings.ValidityType)
{
case CertificateValidityType.Revoked:
RevokeCertificateBySerialNumber(serialNum.ToString(radix: 16));
break;
case CertificateValidityType.Expired:
break;
default:
EnsureCertificateIsValid(cert);
break;
}
// For now, given that we don't know what format to return it in, preserve the formats so we have
// the flexibility to do what we need to
X509CertificateContainer container = new X509CertificateContainer();
X509CertificateEntry[] chain = new X509CertificateEntry[1];
chain[0] = new X509CertificateEntry(cert);
Pkcs12Store store = new Pkcs12StoreBuilder().Build();
store.SetKeyEntry(
certificateCreationSettings.FriendlyName != null ? certificateCreationSettings.FriendlyName : string.Empty,
new AsymmetricKeyEntry(keyPair.Private),
chain);
using (MemoryStream stream = new MemoryStream())
{
store.Save(stream, _password.ToCharArray(), _random);
container.Pfx = stream.ToArray();
}
X509Certificate2 outputCert;
if (isAuthority)
{
// don't hand out the private key for the cert when it's the authority
outputCert = new X509Certificate2(cert.GetEncoded());
}
else
{
// Otherwise, allow encode with the private key. note that X509Certificate2.RawData will not provide the private key
// you will have to re-export this cert if needed
outputCert = new X509Certificate2(container.Pfx, _password, X509KeyStorageFlags.MachineKeySet | X509KeyStorageFlags.Exportable | X509KeyStorageFlags.PersistKeySet);
}
container.Subject = subject;
container.InternalCertificate = cert;
container.Certificate = outputCert;
container.Thumbprint = outputCert.Thumbprint;
Trace.WriteLine("[CertificateGenerator] generated a certificate:");
Trace.WriteLine(string.Format(" {0} = {1}", "isAuthority", isAuthority));
if (!isAuthority)
{
Trace.WriteLine(string.Format(" {0} = {1}", "Signed by", signingCertificate.SubjectDN));
Trace.WriteLine(string.Format(" {0} = {1}", "Subject (CN) ", subject));
Trace.WriteLine(string.Format(" {0} = {1}", "Subject Alt names ", string.Join(", ", subjectAlternativeNames)));
Trace.WriteLine(string.Format(" {0} = {1}", "Friendly Name ", certificateCreationSettings.FriendlyName));
}
Trace.WriteLine(string.Format(" {0} = {1}", "HasPrivateKey:", outputCert.HasPrivateKey));
Trace.WriteLine(string.Format(" {0} = {1}", "Thumbprint", outputCert.Thumbprint));
Trace.WriteLine(string.Format(" {0} = {1}", "CertificateValidityType", certificateCreationSettings.ValidityType));
return(container);
}
private static bool VerifyCtorDecimal(Decimal value)
{
bool ret = true;
Decimal expectedValue;
BigInteger bigInteger;
if (value < 0)
{
expectedValue = Math.Ceiling(value);
}
else
{
expectedValue = Math.Floor(value);
}
bigInteger = new BigInteger(value);
if (!expectedValue.ToString().Equals(bigInteger.ToString(), StringComparison.OrdinalIgnoreCase))
{
Console.WriteLine("Decimal.ToString() and BigInteger.ToString()");
ret = false;
}
if (expectedValue != (Decimal)bigInteger)
{
Console.WriteLine("Round tripped Decimal");
ret = false;
}
if (expectedValue != Math.Floor(Decimal.MaxValue))
{
if ((Decimal)(expectedValue + 1) != (Decimal)(bigInteger + 1))
{
Console.WriteLine("BigInteger added to 1");
ret = false;
}
}
if (expectedValue != Math.Ceiling(Decimal.MinValue))
{
if ((Decimal)(expectedValue - 1) != (Decimal)(bigInteger - 1))
{
Console.WriteLine("BigInteger subtracted by 1");
ret = false;
}
}
Assert.True(VerifyBigintegerUsingIdentities(bigInteger, 0 == expectedValue), " Verification Failed");
return ret;
}
public static string ToHex(this BigInteger i)
{
return(i.ToString("X"));
}
private static void VerifyComparison(BigInteger x, UInt64 y, int expectedResult)
{
bool expectedEquals = 0 == expectedResult;
bool expectedLessThan = expectedResult < 0;
bool expectedGreaterThan = expectedResult > 0;
Assert.Equal(expectedEquals, x == y);
Assert.Equal(expectedEquals, y == x);
Assert.Equal(!expectedEquals, x != y);
Assert.Equal(!expectedEquals, y != x);
Assert.Equal(expectedEquals, x.Equals(y));
VerifyCompareResult(expectedResult, x.CompareTo(y), "x.CompareTo(y)");
if (expectedEquals)
{
Assert.Equal(x.GetHashCode(), ((BigInteger)y).GetHashCode());
Assert.Equal(x.ToString(), ((BigInteger)y).ToString());
}
Assert.Equal(x.GetHashCode(), x.GetHashCode());
Assert.Equal(((BigInteger)y).GetHashCode(), ((BigInteger)y).GetHashCode());
Assert.Equal(expectedLessThan, x < y);
Assert.Equal(expectedGreaterThan, y < x);
Assert.Equal(expectedGreaterThan, x > y);
Assert.Equal(expectedLessThan, y > x);
Assert.Equal(expectedLessThan || expectedEquals, x <= y);
Assert.Equal(expectedGreaterThan || expectedEquals, y <= x);
Assert.Equal(expectedGreaterThan || expectedEquals, x >= y);
Assert.Equal(expectedLessThan || expectedEquals, y >= x);
}
/// <summary>
/// Prompts the user for information for a new transaction, and
/// then submits the transaction to the network.
/// </summary>
/// <param name="wallet">The wallet from which the transaction will be sent.</param>
/// <param name="log">Logger.</param>
/// <returns>A task that represents the asynchronous operation.</returns>
internal static async Task SendTransaction(Wallet wallet, ILogger log)
{
string recipient = ConsoleEx.PromptForAddress("Recipient (hex notation)");
decimal amountInEth = ConsoleEx.PromptForDecimal("Amount (in ETH)");
BigInteger gasPriceInGwei = new BigInteger(40);
gasPriceInGwei = ConsoleEx.PromptForBigInteger(
string.Format("Gas price (in Gwei) [{0}]", gasPriceInGwei),
gasPriceInGwei);
BigInteger gasAllowance = new BigInteger(21000);
BigInteger?nonceOverride = ConsoleEx.PromptForOptionalBigInteger(
"Nonce override (empty == automatic) []",
null);
var maxFeeInWei = gasAllowance * gasPriceInGwei;
var maxFeeInEth = maxFeeInWei.WeiToEth();
var sendChoice = "Send";
var choice = await Menu(
() =>
{
Console.WriteLine();
Console.WriteLine("Do you want to send this transaction?");
Console.WriteLine("\tFrom: {0}", wallet.Address);
Console.WriteLine("\tTo: {0}", recipient);
Console.WriteLine("\tAmount: {0} ETH", amountInEth);
Console.WriteLine("\tMax fee: {0} ETH", maxFeeInEth);
Console.WriteLine("\tNonce: {0}", nonceOverride?.ToString() ?? "<automatic>");
Console.WriteLine();
},
new[] { sendChoice, "Cancel" });
if (choice == sendChoice)
{
Console.WriteLine("Wait a second, I'll check if we can afford this transaction... ");
Console.WriteLine();
var amountInWei = amountInEth.EthToWei();
var maxExpenditureInWei = maxFeeInWei + amountInWei;
var knownBalanceInWei = await wallet.FetchBalanceAsOfLastProcessedBlock();
if (maxExpenditureInWei > knownBalanceInWei)
{
Console.WriteLine("\tSORRY! I can not send this transaction:");
Console.WriteLine();
Console.WriteLine("\tThis transaction may require more ETH than you have.");
Console.WriteLine("\tIf you think this is an error, try re-synchronizing the wallet.");
return;
}
Console.Write("Sending... ");
try
{
var hash = await wallet.SendTransaction(
recipient,
amountInWei,
gasPriceInGwei.GweiToWei(),
gasAllowance,
nonceOverride);
Console.WriteLine("done.");
Console.WriteLine();
Console.WriteLine("You can see your transaction status at:");
Console.WriteLine("\thttps://rinkeby.etherscan.io/tx/{0}", hash);
Console.WriteLine();
}
catch (Exception e)
{
Console.WriteLine("FAILED: {0}", e.Message);
log.Error(e, "Failed to send transaction");
}
}
else
{
Console.WriteLine("Transaction cancelled");
}
}
public static Mono.Math.BigInteger ToMonoBigInteger(BigInteger value)
{
return Mono.Math.BigInteger.Parse(value.ToString(10));
}
static string AnyToAny(int inputBase, string number, int outputBase)
{
BigInteger resultDec = 0;
foreach (char digit in number)
{
int digitValue;
if (char.IsDigit(digit))
{
digitValue = digit - '0';
}
else
{
digitValue = digit - 'A' + 10;
}
resultDec = resultDec * inputBase + digitValue;
}
string result = "";
do
{
BigInteger leftoverNum = 0;
if ((resultDec % outputBase) % 1 == 0)
{
leftoverNum = resultDec % outputBase;
}
else
{
leftoverNum = (resultDec % outputBase) * outputBase;
}
string leftover = leftoverNum.ToString();
switch (leftover)
{
case "0": result = "0" + result; break;
case "1": result = "1" + result; break;
case "2": result = "2" + result; break;
case "3": result = "3" + result; break;
case "4": result = "4" + result; break;
case "5": result = "5" + result; break;
case "6": result = "6" + result; break;
case "7": result = "7" + result; break;
case "8": result = "8" + result; break;
case "9": result = "9" + result; break;
case "10": result = "A" + result; break;
case "11": result = "B" + result; break;
case "12": result = "C" + result; break;
case "13": result = "D" + result; break;
case "14": result = "E" + result; break;
case "15": result = "F" + result; break;
}
resultDec /= outputBase;
} while (resultDec != 0);
return(result);
}
public RSAParameters ParseRSAPrivateKey()
{
RSAParameters parameters = new RSAParameters();
// Current value
byte[] value = null;
// Checkpoint
int position = _parser.CurrentPosition();
// Sanity Check
int length = 0;
// Ignore Sequence - PrivateKeyInfo
length = _parser.NextSequence();
if (length != _parser.RemainingBytes())
{
StringBuilder sb = new StringBuilder("Incorrect Sequence Size. ");
sb.AppendFormat("Specified: {0}, Remaining: {1}",
length.ToString(CultureInfo.InvariantCulture), _parser.RemainingBytes().ToString(CultureInfo.InvariantCulture));
throw new BerDecodeException(sb.ToString(), position);
}
// Checkpoint
position = _parser.CurrentPosition();
// Version
value = _parser.NextInteger();
if (0x00 != value[0])
{
StringBuilder sb = new StringBuilder("Incorrect PrivateKeyInfo Version. ");
BigInteger v = new BigInteger(value);
sb.AppendFormat("Expected: 0, Specified: {0}", v.ToString(10));
throw new BerDecodeException(sb.ToString(), position);
}
// Checkpoint
position = _parser.CurrentPosition();
// Ignore Sequence - AlgorithmIdentifier
length = _parser.NextSequence();
if (length > _parser.RemainingBytes())
{
StringBuilder sb = new StringBuilder("Incorrect AlgorithmIdentifier Size. ");
sb.AppendFormat("Specified: {0}, Remaining: {1}",
length.ToString(CultureInfo.InvariantCulture),
_parser.RemainingBytes().ToString(CultureInfo.InvariantCulture));
throw new BerDecodeException(sb.ToString(), position);
}
// Checkpoint
position = _parser.CurrentPosition();
// Grab the OID
value = _parser.NextOID();
byte[] oid = { 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01 };
if (!EqualOid(value, oid))
{
throw new BerDecodeException("Expected OID 1.2.840.113549.1.1.1", position);
}
// Optional Parameters
if (_parser.IsNextNull())
{
_parser.NextNull();
// Also OK: value = parser.Next();
}
else
{
// Gracefully skip the optional data
value = _parser.Next();
}
// Checkpoint
position = _parser.CurrentPosition();
// Ignore OctetString - PrivateKey
length = _parser.NextOctetString();
if (length > _parser.RemainingBytes())
{
StringBuilder sb = new StringBuilder("Incorrect PrivateKey Size. ");
sb.AppendFormat("Specified: {0}, Remaining: {1}",
length.ToString(CultureInfo.InvariantCulture),
_parser.RemainingBytes().ToString(CultureInfo.InvariantCulture));
throw new BerDecodeException(sb.ToString(), position);
}
// Checkpoint
position = _parser.CurrentPosition();
// Ignore Sequence - RSAPrivateKey
length = _parser.NextSequence();
if (length < _parser.RemainingBytes())
{
StringBuilder sb = new StringBuilder("Incorrect RSAPrivateKey Size. ");
sb.AppendFormat("Specified: {0}, Remaining: {1}",
length.ToString(CultureInfo.InvariantCulture),
_parser.RemainingBytes().ToString(CultureInfo.InvariantCulture));
throw new BerDecodeException(sb.ToString(), position);
}
// Checkpoint
position = _parser.CurrentPosition();
// Version
value = _parser.NextInteger();
if (0x00 != value[0])
{
StringBuilder sb = new StringBuilder("Incorrect RSAPrivateKey Version. ");
BigInteger v = new BigInteger(value);
sb.AppendFormat("Expected: 0, Specified: {0}", v.ToString(10));
throw new BerDecodeException(sb.ToString(), position);
}
parameters.Modulus = TrimLeadingZero(_parser.NextInteger());
parameters.Exponent = TrimLeadingZero(_parser.NextInteger());
parameters.D = TrimLeadingZero(_parser.NextInteger());
parameters.P = TrimLeadingZero(_parser.NextInteger());
parameters.Q = TrimLeadingZero(_parser.NextInteger());
parameters.DP = TrimLeadingZero(_parser.NextInteger());
parameters.DQ = TrimLeadingZero(_parser.NextInteger());
parameters.InverseQ = TrimLeadingZero(_parser.NextInteger());
Debug.Assert(0 == _parser.RemainingBytes());
return(parameters);
}
/// <summary>
/// Converts a <see cref="BigInteger"/> to a hexadecimal string.
/// </summary>
/// <param name="bigint">A <see cref="BigInteger"/>.</param>
/// <returns>
/// A <see cref="System.String"/> containing a hexadecimal
/// representation of the supplied <see cref="BigInteger"/>.
/// </returns>
public static string ToHexadecimalString(this BigInteger bigint)
{
return(bigint.ToString("X"));
}
public void TestDivideAndRemainder()
{
// TODO More basic tests
var n = new BigInteger(48, Rnd);
BigInteger[] qr = n.DivideAndRemainder(One);
Assert.AreEqual(n, qr[0]);
Assert.AreEqual(Zero, qr[1]);
for (int rep = 0; rep < 10; ++rep)
{
var a = new BigInteger(100 - rep, 0, Rnd);
var b = new BigInteger(100 + rep, 0, Rnd);
var c = new BigInteger(10 + rep, 0, Rnd);
BigInteger d = a.Multiply(b).Add(c);
BigInteger[] es = d.DivideAndRemainder(a);
Assert.AreEqual(b, es[0]);
Assert.AreEqual(c, es[1]);
}
// Special tests for power of two since uses different code path internally
for (int i = 0; i < 100; ++i)
{
int shift = Rnd.Next(64);
BigInteger a = One.ShiftLeft(shift);
var b = new BigInteger(64 + Rnd.Next(64), Rnd);
BigInteger bShift = b.ShiftRight(shift);
BigInteger bMod = b.And(a.Subtract(One));
string data = "shift=" + shift + ", b=" + b.ToString(16);
qr = b.DivideAndRemainder(a);
Assert.AreEqual(bShift, qr[0], data);
Assert.AreEqual(bMod, qr[1], data);
qr = b.DivideAndRemainder(a.Negate());
Assert.AreEqual(bShift.Negate(), qr[0], data);
Assert.AreEqual(bMod, qr[1], data);
qr = b.Negate().DivideAndRemainder(a);
Assert.AreEqual(bShift.Negate(), qr[0], data);
Assert.AreEqual(bMod.Negate(), qr[1], data);
qr = b.Negate().DivideAndRemainder(a.Negate());
Assert.AreEqual(bShift, qr[0], data);
Assert.AreEqual(bMod.Negate(), qr[1], data);
}
}
private static bool VerifyCtorDouble(Double value)
{
bool ret = true;
BigInteger bigInteger;
Double expectedValue;
if (value < 0)
{
expectedValue = (Double)Math.Ceiling(value);
}
else
{
expectedValue = (Double)Math.Floor(value);
}
bigInteger = new BigInteger(value);
if (expectedValue != (Double)bigInteger)
{
Console.WriteLine("Expected BigInteger {0} to be equal to Double {1}", bigInteger, expectedValue);
ret = false;
}
// Single can only accurately represent integers between -16777216 and 16777216 exclusive.
// ToString starts to become inaccurate at this point.
if (expectedValue < 9007199254740992 && -9007199254740992 < expectedValue)
{
if (!expectedValue.ToString("G17").Equals(bigInteger.ToString(), StringComparison.OrdinalIgnoreCase))
{
Console.WriteLine("Single.ToString() and BigInteger.ToString() not equal");
ret = false;
}
}
Assert.True(VerifyBigintegerUsingIdentities(bigInteger, 0 == expectedValue), " Verification Failed");
return ret;
}
public RSAParameters ParseRSAPrivateKey()
{
var parameters = new RSAParameters();
// Current value
byte[] value = null;
// Checkpoint
int position = parser.CurrentPosition();
// Sanity Check
int length = 0;
// Ignore Sequence - PrivateKeyInfo
length = parser.NextSequence();
if (length != parser.RemainingBytes())
{
var sb = new StringBuilder("Incorrect Sequence Size. ");
sb.AppendFormat("Specified: {0}, Remaining: {1}",
length.ToString(CultureInfo.InvariantCulture),
parser.RemainingBytes().ToString(CultureInfo.InvariantCulture));
throw new BerDecodeException(sb.ToString(), position);
}
// Checkpoint
position = parser.CurrentPosition();
// Version
value = parser.NextInteger();
if (0x00 != value[0])
{
var sb = new StringBuilder("Incorrect PrivateKeyInfo Version. ");
var v = new BigInteger(value);
sb.AppendFormat("Expected: 0, Specified: {0}", v.ToString(10));
throw new BerDecodeException(sb.ToString(), position);
}
// Checkpoint
position = parser.CurrentPosition();
// Ignore Sequence - AlgorithmIdentifier
length = parser.NextSequence();
if (length > parser.RemainingBytes())
{
var sb = new StringBuilder("Incorrect AlgorithmIdentifier Size. ");
sb.AppendFormat("Specified: {0}, Remaining: {1}",
length.ToString(CultureInfo.InvariantCulture),
parser.RemainingBytes().ToString(CultureInfo.InvariantCulture));
throw new BerDecodeException(sb.ToString(), position);
}
// Checkpoint
position = parser.CurrentPosition();
// Grab the OID
value = parser.NextOID();
byte[] oid = {0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01};
if (!EqualOid(value, oid))
{
throw new BerDecodeException("Expected OID 1.2.840.113549.1.1.1", position);
}
// Optional Parameters
if (parser.IsNextNull())
{
parser.NextNull();
// Also OK: value = parser.Next();
}
else
{
// Gracefully skip the optional data
value = parser.Next();
}
// Checkpoint
position = parser.CurrentPosition();
// Ignore OctetString - PrivateKey
length = parser.NextOctetString();
if (length > parser.RemainingBytes())
{
var sb = new StringBuilder("Incorrect PrivateKey Size. ");
sb.AppendFormat("Specified: {0}, Remaining: {1}",
length.ToString(CultureInfo.InvariantCulture),
parser.RemainingBytes().ToString(CultureInfo.InvariantCulture));
throw new BerDecodeException(sb.ToString(), position);
}
// Checkpoint
position = parser.CurrentPosition();
// Ignore Sequence - RSAPrivateKey
length = parser.NextSequence();
if (length < parser.RemainingBytes())
{
var sb = new StringBuilder("Incorrect RSAPrivateKey Size. ");
sb.AppendFormat("Specified: {0}, Remaining: {1}",
length.ToString(CultureInfo.InvariantCulture),
parser.RemainingBytes().ToString(CultureInfo.InvariantCulture));
throw new BerDecodeException(sb.ToString(), position);
}
// Checkpoint
position = parser.CurrentPosition();
// Version
value = parser.NextInteger();
if (0x00 != value[0])
{
var sb = new StringBuilder("Incorrect RSAPrivateKey Version. ");
var v = new BigInteger(value);
sb.AppendFormat("Expected: 0, Specified: {0}", v.ToString(10));
throw new BerDecodeException(sb.ToString(), position);
}
parameters.Modulus = TrimLeadingZero(parser.NextInteger());
parameters.Exponent = TrimLeadingZero(parser.NextInteger());
parameters.D = TrimLeadingZero(parser.NextInteger());
parameters.P = TrimLeadingZero(parser.NextInteger());
parameters.Q = TrimLeadingZero(parser.NextInteger());
parameters.DP = TrimLeadingZero(parser.NextInteger());
parameters.DQ = TrimLeadingZero(parser.NextInteger());
parameters.InverseQ = TrimLeadingZero(parser.NextInteger());
Debug.Assert(0 == parser.RemainingBytes());
return parameters;
}
public void Keygen(BigInteger p, BigInteger q)
{
BigInteger n = p * q;
BigInteger fi = (p - BigInteger.One) * (q - BigInteger.One);
var rng = new RNGCryptoServiceProvider();
byte[] bytes = new byte[fi.ToByteArray().Length - 1];
BigInteger e;
do {
rng.GetBytes(bytes);
e = new BigInteger(bytes);
} while (!(e > 1 && e < fi && BigInteger.One == BigInteger.GreatestCommonDivisor(e, fi)));
BigInteger d = Util.GetModularInverse(e, fi);
byte [] content = Encoding.UTF8.GetBytes(Convert.ToBase64String(Encoding.UTF8.GetBytes(d.ToString() + "," + n.ToString())));
publicFile.Write(content, 0, content.Length);
content = Encoding.UTF8.GetBytes(Convert.ToBase64String(Encoding.UTF8.GetBytes(e.ToString() + "," + n.ToString())));
privateFile.Write(content, 0, content.Length);
}
public override string P1()
{
Parse(Process(Input[0]));
return(versionSum.ToString());
}
private static void VerifyComparison(BigInteger x, bool IsXNegative, BigInteger y, bool IsYNegative, int expectedResult)
{
bool expectedEquals = 0 == expectedResult;
bool expectedLessThan = expectedResult < 0;
bool expectedGreaterThan = expectedResult > 0;
if (IsXNegative == true)
{
x = x * -1;
}
if (IsYNegative == true)
{
y = y * -1;
}
Assert.Equal(expectedEquals, x == y);
Assert.Equal(expectedEquals, y == x);
Assert.Equal(!expectedEquals, x != y);
Assert.Equal(!expectedEquals, y != x);
Assert.Equal(expectedEquals, x.Equals(y));
Assert.Equal(expectedEquals, y.Equals(x));
Assert.Equal(expectedEquals, x.Equals((Object)y));
Assert.Equal(expectedEquals, y.Equals((Object)x));
VerifyCompareResult(expectedResult, x.CompareTo(y), "x.CompareTo(y)");
VerifyCompareResult(-expectedResult, y.CompareTo(x), "y.CompareTo(x)");
if (expectedEquals)
{
Assert.Equal(x.GetHashCode(), y.GetHashCode());
Assert.Equal(x.ToString(), y.ToString());
}
Assert.Equal(x.GetHashCode(), x.GetHashCode());
Assert.Equal(y.GetHashCode(), y.GetHashCode());
Assert.Equal(expectedLessThan, x < y);
Assert.Equal(expectedGreaterThan, y < x);
Assert.Equal(expectedGreaterThan, x > y);
Assert.Equal(expectedLessThan, y > x);
Assert.Equal(expectedLessThan || expectedEquals, x <= y);
Assert.Equal(expectedGreaterThan || expectedEquals, y <= x);
Assert.Equal(expectedGreaterThan || expectedEquals, x >= y);
Assert.Equal(expectedLessThan || expectedEquals, y >= x);
}
static void Main()
{
Queue <string> INPUT = new Queue <string>();
while (!INPUT.Contains("END"))
{
INPUT.Enqueue(Console.ReadLine().ToUpper());
}
BigInteger resultFirstTen = 1;
BigInteger resultOthers = 1;
int counter = 0; //first 10 elements or less
while (INPUT.Count > 1)
{
if (counter % 2 == 0)
{
foreach (char digit in INPUT.Dequeue().ToString())
{
resultFirstTen *= (digit - '0');
}
}
else
{
INPUT.Dequeue();
}
counter++;
if (counter == 10)
{
break;
}
}
while (INPUT.Count > 1)
{
if (counter % 2 == 0)
{
foreach (char digit in INPUT.Dequeue().ToString())
{
resultOthers *= (digit - '0');
}
}
else
{
INPUT.Dequeue();
}
counter++;
}
if (counter <= 10)
{
Console.WriteLine(resultFirstTen.ToString());
}
else
{
Console.WriteLine(resultFirstTen.ToString());
Console.WriteLine(resultOthers.ToString());
}
}
//***********************************************************************
// Tests the correct implementation of the modulo exponential function
// using RSA encryption and decryption (using pre-computed encryption and
// decryption keys).
//***********************************************************************
public static void RSATest(int rounds)
{
Random rand = new Random(1);
byte[] val = new byte[64];
// private and public key
BigInteger bi_e = new BigInteger("a932b948feed4fb2b692609bd22164fc9edb59fae7880cc1eaff7b3c9626b7e5b241c27a974833b2622ebe09beb451917663d47232488f23a117fc97720f1e7", 16);
BigInteger bi_d = new BigInteger("4adf2f7a89da93248509347d2ae506d683dd3a16357e859a980c4f77a4e2f7a01fae289f13a851df6e9db5adaa60bfd2b162bbbe31f7c8f828261a6839311929d2cef4f864dde65e556ce43c89bbbf9f1ac5511315847ce9cc8dc92470a747b8792d6a83b0092d2e5ebaf852c85cacf34278efa99160f2f8aa7ee7214de07b7", 16);
BigInteger bi_n = new BigInteger("e8e77781f36a7b3188d711c2190b560f205a52391b3479cdb99fa010745cbeba5f2adc08e1de6bf38398a0487c4a73610d94ec36f17f3f46ad75e17bc1adfec99839589f45f95ccc94cb2a5c500b477eb3323d8cfab0c8458c96f0147a45d27e45a4d11d54d77684f65d48f15fafcc1ba208e71e921b9bd9017c16a5231af7f", 16);
Console.WriteLine("e =\n" + bi_e.ToString(10));
Console.WriteLine("\nd =\n" + bi_d.ToString(10));
Console.WriteLine("\nn =\n" + bi_n.ToString(10) + "\n");
for(int count = 0; count < rounds; count++)
{
// generate data of random length
int t1 = 0;
while(t1 == 0)
t1 = (int)(rand.NextDouble() * 65);
bool done = false;
while(!done)
{
for(int i = 0; i < 64; i++)
{
if(i < t1)
val[i] = (byte)(rand.NextDouble() * 256);
else
val[i] = 0;
if(val[i] != 0)
done = true;
}
}
while(val[0] == 0)
val[0] = (byte)(rand.NextDouble() * 256);
Console.Write("Round = " + count);
// encrypt and decrypt data
BigInteger bi_data = new BigInteger(val, t1);
BigInteger bi_encrypted = bi_data.modPow(bi_e, bi_n);
BigInteger bi_decrypted = bi_encrypted.modPow(bi_d, bi_n);
// compare
if(bi_decrypted != bi_data)
{
Console.WriteLine("\nError at round " + count);
Console.WriteLine(bi_data + "\n");
return;
}
Console.WriteLine(" <PASSED>.");
}
}
private void button3_Click(object sender, EventArgs e)
{
BigInteger P = BigInteger.Parse(textBox3.Text), E = 0, Q = BigInteger.Parse(textBox2.Text);
BigInteger N = 0, Z = 0;
BigInteger ost = 0, ost_2 = 0, mul = 0, a1 = 0, b1 = 0;
N = P * Q;
textBox7.Text = N.ToString();
Z = (P - 1) * (Q - 1);
textBox8.Text = Z.ToString();
// нахождение простого числа E
// bool check = false;
// E = Z - 1;
E = Z;
//for (BigInteger i = E - 1; i >= 2; i--)
//{
// if (check)
// {
// E = i + 1;
// break;
// }
// check = true;
// for (int j = 2; j <= (i / 2); j++)
// {
// if (i % j == 0)
// check = false;
// }
//}
bool[] table;
List <BigInteger> primearray;
if (Z < 3000000)
{
table = new bool[(ulong)Z];
primearray = new List <BigInteger>();
for (BigInteger i = 0; i < Z; i++)
{
table[(ulong)i] = true;
}
for (BigInteger i = 2; i *i < Z; i++)
{
if (table[(ulong)i])
{
for (var j = 2 * i; j < Z; j += i)
{
table[(ulong)j] = false;
}
}
}
for (BigInteger i = 1; i < Z; i++)
{
if (table[(ulong)i])
{
primearray.Add(i);
}
}
}
else
{
table = new bool[(ulong)3000000];
primearray = new List <BigInteger>();
for (BigInteger i = 0; i < 3000000; i++)
{
table[(ulong)i] = true;
}
for (BigInteger i = 2; i *i < 3000000; i++)
{
if (table[(ulong)i])
{
for (var j = 2 * i; j < 3000000; j += i)
{
table[(ulong)j] = false;
}
}
}
for (BigInteger i = 1; i < 3000000; i++)
{
if (table[(ulong)i])
{
primearray.Add(i);
}
}
}
//проверка на взаимную простоту
BigInteger[] U_1 = new BigInteger[3];
BigInteger[] V_1 = new BigInteger[3];
BigInteger[] T_1 = new BigInteger[3];
do
{
Random rnd = new Random();
int value = rnd.Next(0, primearray.Count);
E = primearray[value];
U_1[0] = Z;
U_1[1] = 1;
U_1[2] = 0;
V_1[0] = E;
V_1[1] = 0;
V_1[2] = 1;
ost = Z; ost_2 = 0; mul = 1; a1 = Z; b1 = E;
BigInteger q_1 = 0;
while (V_1[0] != 0)
{
q_1 = U_1[0] / V_1[0];
T_1[0] = U_1[0] % V_1[0];
T_1[1] = U_1[1] - q_1 * V_1[1];
T_1[2] = U_1[2] - q_1 * V_1[2];
U_1[0] = V_1[0];
U_1[1] = V_1[1];
U_1[2] = V_1[2];
V_1[0] = T_1[0];
V_1[1] = T_1[1];
V_1[2] = T_1[1];
}
textBox1.Text = E.ToString();
} while (U_1[0] != 1);
// вычисление D
BigInteger[] U = new BigInteger[2];
BigInteger[] V = new BigInteger[2];
BigInteger[] T = new BigInteger[2];
U[0] = Z;
U[1] = 0;
V[0] = E;
V[1] = 1;
// ost = Z; ost_2 = 0; mul = 1; a1 = Z; b1 = E;
BigInteger D = 0, q = 0;
while (V[0] != 0)
{
D = T[1];
q = U[0] / V[0];
T[0] = U[0] % V[0];
T[1] = U[1] - q * V[1];
U[0] = V[0];
U[1] = V[1];
V[0] = T[0];
V[1] = T[1];
}
if (D < 0)
{
D += a1;
}
if (D == E)
{
D = D + Z;
}
textBox4.Text = D.ToString();
}
public void TestDivide()
{
for (int i = -5; i <= 5; ++i)
{
try
{
Val(i).Divide(Zero);
Assert.Fail("expected ArithmeticException");
}
catch (ArithmeticException)
{
}
}
const int product = 1*2*3*4*5*6*7*8*9;
const int productPlus = product + 1;
BigInteger bigProduct = Val(product);
BigInteger bigProductPlus = Val(productPlus);
for (int divisor = 1; divisor < 10; ++divisor)
{
// Exact division
BigInteger expected = Val(product/divisor);
Assert.AreEqual(expected, bigProduct.Divide(Val(divisor)));
Assert.AreEqual(expected.Negate(), bigProduct.Negate().Divide(Val(divisor)));
Assert.AreEqual(expected.Negate(), bigProduct.Divide(Val(divisor).Negate()));
Assert.AreEqual(expected, bigProduct.Negate().Divide(Val(divisor).Negate()));
expected = Val((product + 1)/divisor);
Assert.AreEqual(expected, bigProductPlus.Divide(Val(divisor)));
Assert.AreEqual(expected.Negate(), bigProductPlus.Negate().Divide(Val(divisor)));
Assert.AreEqual(expected.Negate(), bigProductPlus.Divide(Val(divisor).Negate()));
Assert.AreEqual(expected, bigProductPlus.Negate().Divide(Val(divisor).Negate()));
}
for (int rep = 0; rep < 10; ++rep)
{
var a = new BigInteger(100 - rep, 0, Rnd);
var b = new BigInteger(100 + rep, 0, Rnd);
var c = new BigInteger(10 + rep, 0, Rnd);
BigInteger d = a.Multiply(b).Add(c);
BigInteger e = d.Divide(a);
Assert.AreEqual(b, e);
}
// Special tests for power of two since uses different code path internally
for (int i = 0; i < 100; ++i)
{
int shift = Rnd.Next(64);
BigInteger a = One.ShiftLeft(shift);
var b = new BigInteger(64 + Rnd.Next(64), Rnd);
BigInteger bShift = b.ShiftRight(shift);
string data = "shift=" + shift + ", b=" + b.ToString(16);
Assert.AreEqual(bShift, b.Divide(a), data);
Assert.AreEqual(bShift.Negate(), b.Divide(a.Negate()), data);
Assert.AreEqual(bShift.Negate(), b.Negate().Divide(a), data);
Assert.AreEqual(bShift, b.Negate().Divide(a.Negate()), data);
}
// Regression
{
int shift = 63;
BigInteger a = One.ShiftLeft(shift);
var b = new BigInteger(1, "2504b470dc188499".HexToBytes());
BigInteger bShift = b.ShiftRight(shift);
string data = "shift=" + shift + ", b=" + b.ToString(16);
Assert.AreEqual(bShift, b.Divide(a), data);
Assert.AreEqual(bShift.Negate(), b.Divide(a.Negate()), data);
// Assert.AreEqual(bShift.Negate(), b.Negate().Divide(a), data);
Assert.AreEqual(bShift, b.Negate().Divide(a.Negate()), data);
}
}
private static void SetText(TextMeshProUGUI textField, TextMeshProUGUI submitField, bool isEnough, BigInteger cost)
{
textField.text = cost.ToString(CultureInfo.InvariantCulture);
submitField.text = textField.text;
SetTextColor(textField, submitField, isEnough);
}
public void TestToString()
{
string s = "12345667890987654321";
Assert.AreEqual(s, new BigInteger(s).ToString());
Assert.AreEqual(s, new BigInteger(s, 10).ToString(10));
Assert.AreEqual(s, new BigInteger(s, 16).ToString(16));
for (int i = 0; i < 100; ++i)
{
var n = new BigInteger(i, Rnd);
Assert.AreEqual(n, new BigInteger(n.ToString(2), 2));
Assert.AreEqual(n, new BigInteger(n.ToString(10), 10));
Assert.AreEqual(n, new BigInteger(n.ToString(16), 16));
}
}
public ECKey(BigInteger privateKey, ECPoint publicPoint)
{
_privateKey = new ECPrivateKeyParameters(new BigInteger(privateKey.ToString()), Curve);
Pub = publicPoint;
}
/// <inheritdoc/>
public override object Solve()
{
BigInteger result = base.ReadResourceLines().Select(x => BigInteger.Parse(x)).Sum();
return(new string(result.ToString().Take(10).ToArray()));
}
public async Task Execute()
{
IList <Erc20Token> erc20Tokens = null;
try
{
var tradeableAssets = await _assetsService.AssetGetAllAsync();
var supportedTokenAssets = tradeableAssets.Where(asset =>
asset.Type == Lykke.Service.Assets.Client.Models.AssetType.Erc20Token && asset.IsTradable);
var assetIds = supportedTokenAssets.Select(x => x.Id);
var tradableTokens = await _assetsService.Erc20TokenGetBySpecificationAsync(new Lykke.Service.Assets.Client.Models.Erc20TokenSpecification()
{
Ids = assetIds.ToList(),
});
erc20Tokens = tradableTokens?.Items;
}
catch (Exception exc)
{
await _logger.WriteErrorAsync(nameof(Erc20DepositMonitoringContracts),
nameof(Execute),
"Assets Service unavailable",
exc,
DateTime.UtcNow);
return;
}
if (erc20Tokens != null && !erc20Tokens.Any())
{
await _logger.WriteWarningAsync(nameof(Erc20DepositMonitoringContracts),
nameof(Execute),
"",
"No tokens available for trade",
DateTime.UtcNow);
return;
}
await _erc20DepositContractService.ProcessAllAsync(async (item) =>
{
try
{
//Check that deposit contract assigned to user
if (!string.IsNullOrEmpty(item.UserAddress))
{
// null - means we ask for all balances on current address
var tokenBalances = await _erc20BalanceService.GetBalancesForAddress(item.ContractAddress, new string[0]);
if (tokenBalances != null)
{
foreach (var tokenBalance in tokenBalances)
{
string tokenAddress = tokenBalance.Erc20TokenAddress?.ToLower();
string formattedAddress =
_userTransferWalletRepository.FormatAddressForErc20(item.ContractAddress, tokenAddress);
IUserTransferWallet wallet =
await _userTransferWalletRepository.GetUserContractAsync(item.UserAddress, formattedAddress);
if (wallet == null ||
string.IsNullOrEmpty(wallet.LastBalance) ||
wallet.LastBalance == "0")
{
BigInteger balance =
await _ercInterfaceService.GetBalanceForExternalTokenAsync(item.ContractAddress, tokenAddress);
if (balance > 0)
{
await _userTransferWalletRepository.ReplaceAsync(new UserTransferWallet()
{
LastBalance = balance.ToString(),
TransferContractAddress = formattedAddress,
UserAddress = item.UserAddress,
UpdateDate = DateTime.UtcNow
});
await _erc20DepositTransactionService.PutContractTransferTransaction(new Erc20DepositContractTransaction()
{
Amount = balance.ToString(),
UserAddress = item.UserAddress,
TokenAddress = tokenAddress,
ContractAddress = item.ContractAddress,
CreateDt = DateTime.UtcNow,
});
await _logger.WriteInfoAsync(nameof(Erc20DepositMonitoringContracts),
nameof(Execute), "", $"Balance on transfer address - {item.ContractAddress} is {balance} (Tokens of {tokenBalance.Erc20TokenAddress})" +
$" transfer belongs to user {item.UserAddress}", DateTime.UtcNow);
}
}
}
}
}
else
{
//TODO
//Notify That deposit contract does not have a user;
}
}
catch (Exception e)
{
await _logger.WriteErrorAsync(nameof(Erc20DepositMonitoringContracts),
nameof(Execute), "", e, DateTime.UtcNow);
}
});
}