Вот Вам простая программка на Python-е, дающая "нереальный эффект", повторяя баг ice.scalar_multiplication. Учтите, что "правильный" баг получите только в случае, если складываемые приват. ключи имеют сумму > N.
Пользуйтесь на здоровье! Не забудьте включить в соавторы после получения признания величайшего открытия.

def Wonder_func():
    print('Два варианта сложения пуб. ключей: простой (корректный) и усложнённый (с нереальным эффектом)')
    p = 115792089237316195423570985008687907853269984665640564039457584007908834671663
    P = input('Пуб. ключ №1 : ')
    Q = input('Пуб. ключ №2 : ')
    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):
        py2 = 2 * py
        dydx = (3 * px**2) * pow(py2, -1, p)
    else:
        qpx = qx - px
        dydx = (qy - py) * pow(qpx, -1, p)
    x = (dydx**2 - px - qx) % p
    y = (dydx * (px - x) - py) % p
    R = '04' + hex(x)[2:].zfill(64) + hex(y)[2:].zfill(64)
    print('\nПравильный суммарный пуб. ключ :')
    print(R)
    x0 = 100056811408208733275829432225571761443897154861420255832015183193056831248263
    y0 = 60566526027762671372996215584771165169296852327468804800455915050077397931708
    qpx = x0 - x
    dydx = (y0 - y) * pow(qpx, -1, p)
    x1 = (dydx**2 - x - x0) % p
    y1 = (dydx * (x - x1) - y) % p
    F = '04' + hex(x1)[2:].zfill(64) + hex(y1)[2:].zfill(64)
    print('\nПуб. ключ с "нереальным эффектом" :')
    print(F)

P.S.
Такое ощущение, будто кого-то обманул...

Так называемый "прыжок за пределы N" - совершенно неверный результат вычисления ключа суммы двух точек, если модуль N равен вышеприведённому значению.
И как достичь этого при сложении готовых точек a и b? Никак.

Модульная арифметика, она на то и модульная арифметика, что всё в ней считается по модулю. Если хотите чтобы ваше число M "выпрыгивало" за модуль и "гуляло" по полю, можно прибавлять к нему сколько угодно раз сам модуль. Т.е. M + (k * N), где модуль N = 115792089237316195423570985008687907852837564279074904382605163141518161494337, k - любое целое число.
Но должен Вас разочаровать, в результате таких добавлений конечный результат не изменится.
Для данных из Вашего примера (a = N-10, b = (N-1)/2):
P(a) = 04a0434d9e47f3c86235477c7b1ae6ae5d3442d49b1943c2b752a68e2a47e247c776c545bdabe64 3d85c4938196c5db3969086b3d127885ea6c3411ac3fc8c9358
P(b) = 0400000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c633f3979bf72ae8 202983dc989aec7f2ff2ed91bdd69ce02fc0700ca100e59ddf3
P(a) + P(b) = 041fb527e94e9c70e8657de7458b81ef9ee3c2b4e0128a675bf7e28980e18b201ebab00a0911454 07e693d53537818bd3049e1f3640757d22858b8aac5416e3e78
P(a+b) = 041fb527e94e9c70e8657de7458b81ef9ee3c2b4e0128a675bf7e28980e18b201ebab00a0911454 07e693d53537818bd3049e1f3640757d22858b8aac5416e3e78
P(a+b + 1000000*N) = 041fb527e94e9c70e8657de7458b81ef9ee3c2b4e0128a675bf7e28980e18b201ebab00a0911454 07e693d53537818bd3049e1f3640757d22858b8aac5416e3e78

У последних трёх ключей координаты x и y одинаковые!

Ищите ошибку в функции ice.scalar_multiplication, тем более, что в инете есть информация, что эта функция считает с ошибками. Никогда с ней не работал (за ненадобностью), но есть подозрение, что она выдаёт неправильный результат для чисел > N.

Если взять точки N+N-10 и ( N-10) для любых N, не равных 5, 10 или 115792089237316195423570985008687907852837564279074904382605163141518161494337. Не будет никакой аналогии.
Вычислить N×G + (N-10)×G - получится (2N - 10)xG.

Можете на примере с конкретными числами показать, что это за точки, аналогичные по модулю, но другие; что значит закручивать в модуль N; и опять же, что означает "гуляние" по полю p? У вас модуль N или p?

Пожалуйста, приведите конкретный пример. Разберёмся.

Возьмём, к примеру, пару точек a = 10 и b = 15.

1. Библиотечная функция выдаёт

для a*G = 10*G:
x_10 = 72488970228380509287422715226575535698893157273063074627791787432852706183111
y_10 = 62070622898698443831883535403436258712770888294397026493185421712108624767191

для b*G = 15*G:
x_15 = 97505755694356382817881959832717013755620551362654128955029190924747025549326
y_15 = 39856815248295663243990443767776362321337592747889787217974905533720651000664

для (a + b)*G = 25*G:
x_25 = 66165162229742397718677620062386824252848999675912518712054484685772795754260
y_25 = 52018513869565587577673992057861898728543589604141463438466108080111932355586

2. Теперь сложим вручную точки a*G и b*G:

p = 2**256 - 2**32 - 977 = 115792089237316195423570985008687907853269984665640564039457584007908834671663

dd = (y_15 - y_10) * pow(x_15 - x_10, -1, p)
x_new = (dd**2 - x_10 - x_15) % p
y_new = (dd * (x_10 - x_new) - y_10) % p

Численные вычисления показывают, что x_new = x_25 и y_new = y_25, это одна и та же точка, т.е. (a + b)*G = a*G + b*G.

Что означает "гулять" по полю?

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

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

И жаль, что Вы не кандидат.

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

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

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

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

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

Спасибо,

команда Kraken
"

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

Повторю некоторые условия для совместной работы: ВЫСОКИЙ УРОВЕНЬ ПРОФЕССИОНАЛИЗМА и ПОРЯДОЧНОСТЬ. Только при уверенности в обладании претендентом этими качествами поделюсь всеми наработками.

Для посредников: оплачу услугу поиска программиста не до, а после начала работы над проектом.

Для всех : пока тема не закрыта, предложение актуально.

Программисты, а-у-у-у!!!
Сложно поверить, что в форуме собрались только спецы по 1С и технические писатели.

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

Конечный цифровой продукт - не статистика по транзакциям. Она используется только для внутреннего пользования, дабы не допустить накладок.

Если есть сложности с математикой блокчейна, разберёмся вместе. С дизайном сайта и переводом на английский аналогично.

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


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

Проблема неоднозначности давно решена - достаточно одного бита, тем более, байта, чтобы определить знак "у". Но складывать по одной координате нельзя не из-за неоднозначности, а из-за отсутствия самой координаты "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-ричное число удобно тем, что оно уже изначально "готово к употреблению", поэтому процесс его разложения на сумму степеней опускается. Конечно, можно такой же финт провернуть и с другим удобным основанием - десятеричным числом, но в этом случае увеличивается число слагаемых, что замедляет вычисление.

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

Ради интереса "склепал" программку на Pyton-е. Сравнение по скорости стандартной библиотеки и "склёпанной" не в пользу последней.
Использование словаря / разложение по степеням - неоптимальные варианты?
Хотя при больших 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('Введите число итераций : '))

    PK = PK_0

    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)

    PK = PK_0

    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.
Претензии по качеству софта не принимаются - я не программист.