Письмо из Kraken-а от 20.10.2022:

"
Здравствуйте!

В связи с новым европейским законодательством мы обязаны принять меры, которые ограничат ваш аккаунт Kraken. Вам будет разрешено вывести активы со своего аккаунта, если вы захотите это сделать.

Мы будем обновлять наш Центр поддержки, если будут какие-либо изменения. Если у вас есть дополнительные вопросы, пожалуйста, свяжитесь с нашей службой поддержки.

Приносим свои извинения за доставленные неудобства.

Спасибо,

команда Kraken
"

Ордера не выставляются...

Правильные картинки. То, что для различных точек "у" может повторяться - работа модуля по полю. Так и должно быть. Но для любого "х" может существовать только два "у" с разными знаками, а никак не три или более.
Часто в различных статьях изображают кривую биткоина неверно (с волнами, где горизонтальная прямая может пересечь кривую в трёх точках), что вводит читателя в заблуждение.


Что в Вашем понимании означают "программные методы генерации точек"? Это определение точек кривой без формулы для этой кривой?
И что означает "когда точки уже известны"? Они появились из ниоткуда сами собой без формулы?

Проблема неоднозначности давно решена - достаточно одного бита, тем более, байта, чтобы определить знак "у". Но складывать по одной координате нельзя не из-за неоднозначности, а из-за отсутствия самой координаты "y".


Ни одна горизонтальная прямая не пересекает кривую в трёх точках. Это легко доказывается исходя из формулы биткоина y^2 = x^3 + 7.


А обе координаты как получить, как не с помощью формулы?

Особенность кривой Curve25519 заключается в том, что коэффициенты в ней подобраны таким образом, что вычисления проходят быстрее, чем по другим кривым.
https://habr.com/ru/post/247873/

К сожалению, не всё так просто с использованием в вычислениях только одной координаты. Кривая Монтгомери b*y^2=x^3+a*x^2+x (Curve25519 - частный случай этой кривой, где b = 1 и a = 486662) преобразуется в трёхмерный вид с помощью проективной геометрии. Точка выражается через новые координаты X, Z. Вот эти координаты и находятся при сложении / умножении. Координата y, если необходимо, вычисляется уже после.
Здесь кратко по кривой Монтгомери:
https://www.hyperelliptic.org/EFD/g1p/auto-montgom-xz.html
https://trustica.cz/en/2020/02/06/montgomery-curves-in-projective-coordinates/
В последней ссылке формула BY^Z=X^3+AX^Z+XZ^2 - хрень! Правильные формулы - ниже на картинке.

Моё мнение, что "чисто" по одной координате нельзя вычислять суммы и произведения точек на число. В любом случае должна присутствовать формула кривой, а это равносильно участию в процессе, хоть и косвенно, второй координаты.

Модули p - простые числа. У биткоина p почти в 2 раза больше (~2^256 против ~2^255), наверное, ещё и поэтому разница в скорости.

В первом приближении интуитивно кажется, что проективную геометрию для преобразования биткоиновской кривой y^2 = x^3 + 7 применить можно. Но для точного ответа надо досконально знать эту тему. Может, это уже работает в современных библиотеках? С ответом напряг, программисты, похоже, здесь не живут.

Раскладывать в сумму по степеням и прогонять по алгоритму - не одно и тоже, потому и опускается. В первой программе есть и то и другое, причём расклад идёт на выбор для любого натурального числа  для основания, начиная с двойки. Во второй программе только алгоритм выделения для 16-ричного числа.
Вы, наверное, программист, если пользуетесь таким словом как "парсить". Тогда Вам не сложно рассмотреть алгоритм второй программы. Вы увидите, что она работает равносильно программе с разложением по степеням не 16-ти, а 16^4 = 65536. Но там нет и намёка раскладывать приватный ключ по степеням 65536. Есть только алгоритм по выделению из готового числа сразу по четыре знака.

Да, Вы правы. Любое число может существовать только не иначе как представленным суммой степеней с коэффициентами не более, чем на единицу меньше основания. В данном случае 16-ричное число удобно тем, что оно уже изначально "готово к употреблению", поэтому процесс его разложения на сумму степеней опускается. Конечно, можно такой же финт провернуть и с другим удобным основанием - десятеричным числом, но в этом случае увеличивается число слагаемых, что замедляет вычисление.

Именно то, о чём Вы говорите, и реализуется в первой программе, если в качестве основания для разложения по степеням ввести двойку.
В этом случае создаётся база из 256 элементов (пуб. ключи, соответствующие 2^0, 2^1, 2^2, ..., 2^254, 2^255). МЕста в памяти такая база займёт совсем немного, почти ничего. Далее, при вычислении любого пуб. ключа никаких удвоений уже не происходит. Число (приватный ключ) представляется в виде суммы степеней двойки с соответствующими коэффициентами (0 или 1), и пуб. ключ вычисляется в соответствии с этими коэффициентами как сумма элементов базы.
При раскладывании на степени другого числа больше двойки число слагаемых уменьшается, что приводит к росту скорости вычисления пуб. ключа, но в таком случае растёт и размер базы.
Для относительно больших значений приватника библиотека работает быстрее. Для "маленьких" ключей библиотека отстаёт.
Возможны три причины "тормоза". 1-я: медленное разложение приватника в сумму степеней (во второй программе этот шаг отсутствует!). 2-я: использование словаря не самый эффективный способ хранения элементов базы. 3-я: медленно работает функция сложения пуб. ключей. Что скажут программисты?

Нашёл другой способ вычисления публичного ключа из приватного, в котором последний раскладывать по степеням совсем не обязательно!
Если приватник выражается 64-значным 16-ричным числом, его можно представить как сумму не более 64-х чисел, каждое из которых
содержит только одно отличное от нуля значение.
Например:
Key = F1F3BE4BDBC7AB23D7BE32B818FD727C31086FC924E8303CBEAA88572D9FAB38

Сумма:
1) F000...............0000
2) 0100...............0000
3) 00F0...............0000
4) 0003...............0000
................................
61) 0000...............A000
62) 0000...............0B00
63) 0000...............0030
64) 0000...............0008

Зная публичные ключи для каждого из указанных слагаемых, искомый публичник для Key будет просто равен их сумме.
Максимальное число слагаемых - 64.
Поскольку интересны только 15 значений (от 1 до F), общая база ключей составит всего 15*64 = 960 элементов.
Пока писал "пробную" программку, пришла идея для уменьшения числа слагаемых (увеличения скорости расчёта)
разбивать приватник не по одному элементу, а по четыре:
Получаем сумму:
1) F1F30000...................00000000
2) 0000BE4B...................00000000
.................................................
15) 00000000...................2D9F0000
16) 00000000...................0000AB38

В этом случае максимальное число слагаемых составит всего 16, а общее количество публичных ключей в базе = 16^4 * 16 - 16 = 1 048 560
(- 16 означает игнорирование "нулевых" значений).

К сожалению, как и в случае с разложением приватного ключа в степенной ряд, для "больших" приватников" библиотека рулит".
Видимо, её разработчик был большим спецом.

Программка второго варианта (без защиты от кривых рук):

import binascii, ecdsa
import datetime

# ----------------------------------- Сложение публичных ключей ------------------------------------

def EC_Add(P, Q):
    if P == '0': return Q
    if Q == '0': return P
    p = 115792089237316195423570985008687907853269984665640564039457584007908834671663
    px = int(P[2:66], 16)
    py = int(P[66:], 16)
    qx = int(Q[2:66], 16)
    qy = int(Q[66:], 16)
    if (px == qx) and (py == qy):
        dydx = (3 * px**2) * pow(2 * py, p - 2, p)
    else:
        dydx = (qy - py) * pow(qx - px, p - 2, p)
    x = (dydx**2 - px - qx) % p
    y = (dydx * (px - x) - py) % p
    return '04' + hex(x)[2:].zfill(64) + hex(y)[2:].zfill(64)

# --------------------- Публичный ключ от произвольного числа HEX (библиотека) ---------------------

def U_pub(x):
    sk = ecdsa.SigningKey.from_string(binascii.unhexlify(x.encode()), curve=ecdsa.SECP256k1)
    vk = sk.get_verifying_key()
    return '04' + binascii.hexlify(vk.to_string()).decode()

# --------------------------------------------------------------------------------------------------


Max = 115792089237316195423570985008687907852837564279074904382605163141518161494336

simbols = '0123456789abcdef'

Base_pub = dict()

print('Ждите, идёт создание базы публичных ключей ...')

for i in range(16):
    for k in range(16):
        for m in range(16):
            for n in range(16):
                for q in range(16):
                    if (str(simbols[k:k + 1]) + str(simbols[m:m + 1]) + str(simbols[n:n + 1]) + str(simbols[q:q + 1])) != '0000':
                        Base_pub[str(i * 4 + 1).zfill(2) + str(simbols[k:k + 1]) + str(simbols[m:m + 1]) + str(simbols[n:n + 1]) + str(simbols[q:q + 1])] = U_pub('0' * (i * 4) + (simbols[k:k + 1] + simbols[m:m + 1] + simbols[n:n + 1] + simbols[q:q + 1] + '0' * (60 - i * 4)))

print('Ключей в базе :', len(Base_pub))

PK_0 = int(input('Введите приватный ключ: ("0" - завершение программы) '))
if PK_0 > Max: PK_0 = int(str(PK_0)[:77])

while PK_0 != 0:

    MM = int(input('Введите число итераций : '))

    date_1 = datetime.datetime.today()

    for k in range(MM):
        PK = PK_0 + k
        hexPrv = hex(PK)[2:66].zfill(64)

        Priv_set = set()

        P = '0'

        for i in range(16):
            if hexPrv[i * 4:i * 4 + 4] != '0000':
                Priv_set.add(Base_pub[str(i * 4 + 1).zfill(2) + hexPrv[i * 4:i * 4 + 4]])

        for i in Priv_set:
            P = EC_Add(P, i)

    date_2 = datetime.datetime.today()
    print('продолжительность :', date_2 - date_1)

    print('Key =', PK, '; P =', P)

    date_1 = datetime.datetime.today()

    for i in range(MM):
        PK = PK_0 + k
        P = U_pub(hex(PK)[2:66].zfill(64))

    date_2 = datetime.datetime.today()
    print('продолжительность :', date_2 - date_1)

    print('Key =', PK, '; P =', P)

    PK_0 = int(input('Введите приватный ключ: ("0" - завершение программы) '))
    if PK_0 > Max: PK_0 = int(str(PK_0)[:77])

P.S.
Претензии по качеству софта не принимаются - я не программист.

C WebMoney работаю c 1999 г. Торговал на INDX. Персональный аттестат с 2001 г. Хорошо знаю эту систему, очень надёжная технически (к сожалению, это единственное значительное преимущество перед другими ПС). Только один раз в 2000-х с их стороны был прокол, но быстро исправлен.

Работал через их Черногорский (Монтенегро) банк. Конечно же, Вы лучше знаете, чем он кончил примерно 20 лет назад.

А это одна из некоторых проблем за последние годы: https://www.cnews.ru/news/top/2022-02-11_starejshaya_platezhnaya_sistema

Сколько уже лет нельзя вывести средства 1:1? Но это не для Вас, верно? Выводите $, покупаете BTC по 29, нет проблем.
Без сомнения, система будет продолжать работать, но того былого авторитета уже нет, плюс некоторые ограничения, поэтому и паритетного курса вывода можно не ждать.

1WMZ - это не 1$. Спёкся WebMoney!
Имея на счету WMZ, с радостью купил бы сейчас за 35, пока ещё больше не стало.

Лучше уже вряд ли удастся найти:
https://exchanger.web.money/asp/wmlist.asp

При использовании N = 2 в качестве основания степени максимальное количество слагаемых - 255 (не 256 !), соответственно, максимальное количество сложений - 254.
Если использовать N больше двойки, макс. количество слагаемых будет уменьшаться. Например, для 3 - 162, для 16 - 64, для 1024 - 26, для 1 048 576 = 2^20 - 13. В последнем случае база публичных ключей содержит 12 648 435 элементов и в памяти компьютера занимает 3,750 GB.
Для современного компьютера это не проблематично (в моём натыкано 8 модулей по 16 GB каждый).

Ради интереса "склепал" программку на Python-е. Сравнение по скорости стандартной библиотеки и "склёпанной" не в пользу последней.
Использование словаря / разложение по степеням - неоптимальные варианты?
Хотя при больших N и относительно небольших числах в качестве ключей результат противоположный.

Программка (без защиты от кривых рук):

import math
import datetime
import binascii, ecdsa

# --------------------------- Разложение числа по степеням другого числа ---------------------------

def pow_num(a, b):
    R = []
    M = int(round((math.log(a) / math.log(b)), 0))
    if b**M > a: M = M - 1
    for i in range(M + 1):
        k = M - i
        p = a // (b ** k)
        if p * b ** k > a:
            R.append(0)
        else:
            R.append(p)
            a = a - p * b ** k
    R.reverse()
    return R

# ----------------------------------- Сложение публичных ключей ------------------------------------

def EC_Add(P, Q):
    if P == '0': return Q
    if Q == '0': return P
    p = 115792089237316195423570985008687907853269984665640564039457584007908834671663
    px = int(P[2:66], 16)
    py = int(P[66:], 16)
    qx = int(Q[2:66], 16)
    qy = int(Q[66:], 16)
    if (px == qx) and (py == qy):
        dydx = (3 * px**2) * pow(2 * py, p - 2, p)
    else:
        dydx = (qy - py) * pow(qx - px, p - 2, p)
    x = (dydx**2 - px - qx) % p
    y = (dydx * (px - x) - py) % p
    return '04' + hex(x)[2:].zfill(64) + hex(y)[2:].zfill(64)

# ---------------------------- Публичный ключ из приватного (библиотека) ---------------------------

def U_pub(x):
    hexPrv = hex(x)[2:].zfill(64)
    sk = ecdsa.SigningKey.from_string(binascii.unhexlify(hexPrv.encode()), curve=ecdsa.SECP256k1)
    vk = sk.get_verifying_key()
    return '04' + binascii.hexlify(vk.to_string()).decode()

# --------------------------------------------------------------------------------------------------

# p = 115792089237316195423570985008687907853269984665640564039457584007908834671663
Max = 115792089237316195423570985008687907852837564279074904382605163141518161494336
# P1 = '0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c 4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8'

N = int(input('Введите основание для разложения по степеням : '))

Pow = pow_num(Max, N)

N_p = len(Pow) # количество степеней (0 включительно)

D_N = dict()

for i in range(N_p - 1):
    for k in range(N - 1):
        D_N[str(k + 1).zfill(len(str(N))) + str(i).zfill(len(str(N_p)))] = U_pub((k + 1)*N**i)

N1 = Pow[-1]

for k in range(N1):
    D_N[str(k + 1).zfill(len(str(N))) + str(N_p - 1).zfill(len(str(N_p)))] = U_pub((k + 1)*N**(N_p - 1))

print('Размер базы :', len(D_N))
print('Макс. к-во слагаемых :', N_p)

PK_0 = int(input('Введите приватный ключ: ("0" - завершение программы) '))
if PK_0 > Max: PK_0 = int(str(PK_0)[:77])

while PK_0 != 0:

    MM = int(input('Введите число итераций : '))

    date_1 = datetime.datetime.today()

    for k in range(MM):
        PK = PK_0 + k
        Pow_key = pow_num(PK, N)
        P = '0'
        for m in range(len(Pow_key)):
            if Pow_key[m] != 0:
                Q = D_N[str(Pow_key[m]).zfill(len(str(N))) + str(m).zfill(len(str(N_p)))]
                P = EC_Add(P, Q)

    date_2 = datetime.datetime.today()
    print('продолжительность :', date_2 - date_1)

    print('Key =', PK, '; P =', P)

    date_1 = datetime.datetime.today()

    for k in range(MM):
        PK = PK_0 + k
        P = U_pub(PK)

    date_2 = datetime.datetime.today()
    print('продолжительность :', date_2 - date_1)

    print('Key =', PK, '; P =', P)

    PK_0 = int(input('Введите приватный ключ: ("0" - завершение программы) '))
    if PK_0 > Max: PK_0 = int(str(PK_0)[:77])

P.S.
Претензии по качеству софта не принимаются - я не программист.

Почему считал по степени 255.
Если ключ = 2^1 = 2, то публ. ключ = G1 = 2 * G0 = (G0 + G0), G0 = G (одно удвоение)
Если ключ = 2^2 = 4, то публ. ключ = 4 * G0 = 2 * G1 = G1 + G1 = (G0 + G0) + (G0 + G0)  (два удвоения)
...
Если ключ = 2^255, то публ. ключ = 2^255 * G0 = 2^254 * (G0 + G0) = 2^254 * G1 = 2^253 * (G1 + G1) = 2^253 * [(G0 + G0) + (G0 + G0)] = ...   (255 удвоений)

----------------------------------------
Ключ = 2^255 - 1.
Если решать задачу в лоб для ключа = 2^255 - 1, всё оказывается достаточно просто:
2^255 - 1 = 2^254 + 2^253 + 2^252 + ... + 2^2 + 2^1 + 2^0
Складывайте 255 слагаемых и будет Вам счастье.

Если пойти немного более сложным путём (но всё равно, простым) и строго придерживаться правила сложения, то получается ещё гораздо проще:
(2^255 - 1) * G = 2^255 * G + (-G),
где -G = (x, -y), если G = (x, y)
Далее опять смотрите раздел "Алгебраическое сложение".

P.S.
(Частный случай) любое число до 2^256 может быть единственным образом представлено суммой ортогональных многочленов со степенью не более 255.

Классная статья, лучше всех, которые довелось видеть до этой! После НГ надо обязательно внимательно прочесть.


Умножение базовой точки на закрытый ключ сводится к сложению базовой точки, результатов удвоения базовой точки, последующих удвоений удвоения и т.д.
Удвоение - это, в свою очередь, просто сложение точки с самой собой. В итоге, любое умножение сводится к определённому количеству сложений (базовой точки и результатов сложения).

Например (аналогично смотрите в статье), 23 * G = 2^4 * G + 2^2 * G + 2^1 * G + 1 * G = G4 + G2 + G1 + G0, где
G4 = G3 + G3 (G3 = G2 + G2), G2 = G1 + G1, G1 = G0 + G0, G0 = G.

Теперь, почему полученные числа не превысят значений больше 78 разрядов, смотрите раздел "Поле целых чисел по модулю p".

Сложение на эллиптических кривых - это не просто привычное для всех арифметическое сложение. Здесь сложение определяется пересечением кривой y^2 = x^3 + 7 прямой линией, используя замечательное свойство кривой: любая прямая (не вертикальная), пересекающая кривую в двух точках, всегда будет пересекать ее и в третьей точке (за исключением касательной, которая пересечёт её ровно в ещё одной точке).
О сложении смотрите разделы "Геометрическое сложение" и "Алгебраическое сложение".

Публичный ключ - это произведение базовой точки и приватного ключа. Для ключа = 1 получаем базовую точку:
x = 79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 (dec = 55066263022277343669578718895168534326250603453777594175500187360389116729240)
y = 483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 (dec = 32670510020758816978083085130507043184471273380659243275938904335757337482424)

Чтобы умножить базовую точку на ключ = 2^255, нужно всего-навсего 255 раз провести операцию удвоения (сложения с самой собой), начиная со сложения базовой точки G. Это любому компьютеру сделать под силу за доли секунды.

Считаю, Вы совершили величайшее открытие, предложив такой грандиозный проект. По масштабности, вряд ли с ним может сравниться любой другой за последние лет шестьдесят.

Верно, в космосе стоимость электричества гораздо ниже, чем на Земле, т.к. при использовании солнечных батарей на орбите солнечные лучи не проходят через атмосферу (АМ0), а значит Солнце светит там ярче раза в 1,5, чем в самом лучшем случае на Земле. Опять же облака не набегут. В космосе проще направлять батареи к Солнцу, чем на Земле. А если плоскость орбиты будет перпендикулярна направлению к Солнцу, свет будет поступать беспрерывно!

Абсолютно верное утверждение о множестве источников электроэнергии в космосе. Кроме видимого солнечного света, это и мощные потоки заряженных частиц (альфа, бета) и большая интенсивность рентгеновского и гамма-излучения, которые, увы, поверхности Земли почти не достигают из-за вредного воздействия злополучной атмосферы. Земное магнитное поле также вредит проходу заряженных частиц. Можно также ловить пролетающие мимо с большой скоростью метеориты. А какие там замечательные переменные электромагнитные поля! Опять же их к Земле не пускает ионосфера. В космосе и звёзды светят ярче.

А вот в этом пункте таится самое главное преимущество майнинга в космосе. Вы едва не раскрыли самую большую тайну последнего века. Но обо всём по порядку. Почему вентиляторы на видеокартах будут вообще легко крутиться в условиях невесомости? Преподаватели в школе и учебники нам твердили, что в космосе якобы только невесомость. Но ни один учитель или автор книг там не был, а потому не знает правды о законах физики на орбите. А правда в том, что кроме невесомости там и масса равна нулю! Потому и вентиляторы крутятся легко! Дополнительное доказательство нулевой массы – орбитальная станция не падает на Землю, а космонавты не падают ни на пол, ни на потолок. Теперь главное – электроны в проводах и полупроводниках из-за своего нулевого веса и массы разгоняются до сверхсветовых скоростей, а потому вычислительная скорость процессора достигает невероятных величин! Мат. плата с процом 286/87 совершает 10^40 операций в секунду. А скорости 386-х и выше компьютеров даже не поддаются измерению.

Если ферму расположить в тени, где температура близка к абсолютному нулю, все проводники от холода превращаются в сверхпроводники. А тогда все токи закольцовываются и начинают протекать без потерь, а значит ферма будет работать без подведения электричества!

Идея просто замечательная. Но для её реализации сначала просто-напросто надо построить свой независимый (частный) космический корабль и орбитальную станцию. Потом можно будет строить целые орбитальные города для майнинга. А в недалёком будущем реализовать и межгалактический проект «Бит-Майнинг-Нью-Васюки». СпрОсите, почему сейчас на МКС ничего не майнят. Ответ прост: во-первых, наши с американцами заключили договор о необрушении финансовых систем друг друга, а во-вторых, чтобы не рухнули криптовалюты.
Так что будущее майнинга за Вами!
Успехов!

П.С. Заранее приношу извинения, если повторил уже упомянутые факты. Кроме первого поста в ветке другие не читал.

Не считаю себя спецом в подобных вещах, но не удержался, чтобы не внести некоторые тривиальные уточнения.

На самом деле, закрытых ключей в очень большом приближении всё таки 2^256, а не 2^160.
(0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140≈0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff+1=2^256=
=115792089237316195423570985008687907853269984665640564039457584007913129639936≈10^77).

Для фанатов математики: 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140=2^255.99999999999999999999999999999999999999461231979328931570871878708855078033043787641519129048544479673630840996526007370172002...

Другое дело, количество адресов, которые генерируются, как известно, из публичного ключа.
А зашифрованный открытый ключ - это 40-значное шестнадцатиричное число. Следовательно, всех открытых ключей,  т.е. различных адресов, может быть не более 16^40=2^160≈10^48. Получается, что на каждый адрес приходится 10^29 приватных ключей!

Если уж быть более точным, нужно ещё учесть и адреса, полученные через сжатый приватный ключ.  Это и привычный адрес, начинающийся с "1", и адреса P2SH и BECH32.

Интересные именные адреса можно получить, если на клавиатуре перебрать много разных приватников (главное, нажимать только кнопочки с цифрами и буквами "a, b, c, d, e, f"), например:

Приватный ключ:
BBBFAF40A53E849D2CC55712AEF20FC42DC9B043945466D9B214C3F21ECBB250
Соответствующие адреса:
1Govnoed7sLpiEXp4yQG3mo1ojXU73kA2M
1FNkWLPJF2ap97rXW3s7oYbA6AahJQ47jF
3QBKzeRfdgncVYnBFzw6toK3zgp62c4tJ2
bc1qnkhdq8v7ttle8z233w06vuyhnvdrechyznwaua

Или так:
Приватный ключ:
BB38F7FFB44BD91985943451F26099BA1FD6B79ABBBA9F124F9EE688601E0915
Соответствующие адреса:
12ozZ6v6HrPz4V3Q2LWR4aiBJm47sdgSZP
1Gyx13H1aUNtmEBLEPtQjQmZgvmdf27xqk
3QueenFzBZYKMEYuFVbMKMEiUyE6eeuw5e
bc1q4a8303jv3ysfm0cnguayr8zmlhqftpfy792gk7

P.S. Пользоваться этими "красивыми" адресами никому не советую.

(У): Вы не должны задавать вопросы

В начале этого года русский язык уже был, а появился, может быть, гораздо раньше. Такую возможность заметил случайно, т.к. проблемой тоже не являлось. Перейти можно в нижней части страницы справа (всего около десятка языков).

Это первое.

И второе:
Золотые слова для проплаченных говнобиржей "дочерей офицеров":

Поднимаем тему?

А зачем Вам новые акции, достаточно действующей - говнобиржа под надуманным предлогом (алгоритму что-то показалось) блокирует пользователей, чтобы те не могли вывести средства, заработанные с помощью бонуса.

Почитайте всю тему, у такой шарашкиной конторы нет никаких перспектив.