def generate(cls, xprv=None, prv=None, seed=None, child=None, username=None):
mnemonic = Mnemonic('english')
# generate 12 word mnemonic seed
if not seed and not xprv and not prv:
seed = mnemonic.generate(256)
private_key = None
if seed:
# create bitcoin wallet
entropy = mnemonic.to_entropy(seed)
key = BIP32Key.fromEntropy(entropy)
private_key = key.PrivateKey().hex()
extended_key = key.ExtendedKey()
else:
raise Exception('No Seed')
if prv:
private_key = PrivateKey.from_hex(bytes.fromhex(prv)).to_hex()
extended_key = ''
if xprv:
key = BIP32Key.fromExtendedKey(xprv)
private_key = key.PrivateKey().hex()
extended_key = key.ExtendedKey()
if xprv and child:
for x in child:
key = key.ChildKey(int(x))
private_key = key.PrivateKey().hex()
if not private_key:
raise Exception('No key')
return cls({
"seed": seed or '',
"xprv": extended_key or '',
"private_key": private_key,
"wif": cls.generate_wif(private_key),
"public_key": PublicKey.from_point(key.K.pubkey.point.x(), key.K.pubkey.point.y()).format().hex(),
"address": str(key.Address()),
"serve_host": "0.0.0.0",
"serve_port": 8000,
"use_pnp": True,
"ssl": False,
"origin": '',
"polling": 0,
"post_peer": False,
# "public_ip": "", # TODO
"peer_host": "",
"peer_port": 8000,
"web_server_host": "0.0.0.0",
"web_server_port": 5000,
"peer": "http://localhost:8000",
"callbackurl": "http://0.0.0.0:5000/create-relationship",
"fcm_key": "",
"database": "yadacoin",
"site_database": "yadacoinsite",
"mongodb_host": "localhost",
"mixpanel": "",
"username": username or '',
"network": "mainnet"
})
def verify_range_proof_fast(public_key, A, B, A0_s, A1_s, B0_s, B1_s, c0, c1,
r0_ss, r1_ss):
try:
n = 2**hash_length
r0_ss_ = long_to_bytes(r0_ss)
c0_ = long_to_bytes(c0)
r1_ss_ = long_to_bytes(r1_ss)
c1_ = long_to_bytes(c1)
base_ = PublicKey.from_point(base.x, base.y)
public_key_ = PublicKey.from_point(public_key.x, public_key.y)
A0_s_ = PublicKey.from_point(A0_s[0], A0_s[1])
A_ = PublicKey.from_point(A[0], A[1])
A1_s_ = PublicKey.from_point(A1_s[0], A1_s[1])
B0_s_ = PublicKey.from_point(B0_s[0], B0_s[1])
B_ = PublicKey.from_point(B[0], B[1])
B1_s_ = PublicKey.from_point(B1_s[0], B1_s[1])
b0 = (base_.multiply(r0_ss_) == A0_s_.combine(
[A0_s_, A_.multiply(c0_)]))
b1 = (base_.multiply(r1_ss_) == A1_s_.combine(
[A1_s_, A_.multiply(c1_)]))
b2 = (public_key_.multiply(r0_ss_) == B0_s_.combine(
[B0_s_, B_.multiply(c0_)]))
b3 = (public_key_.multiply(r1_ss_) == B1_s_.combine([
B1_s_,
base_.combine([B_, PublicKey.from_point(base.x,
p - base.y)]).multiply(c1_)
]))
c = hash_points(
[public_key,
P(A), P(B),
P(A0_s),
P(B0_s),
P(A1_s),
P(B1_s)])
b4 = ((c0 + c1) % n == c)
return b0 and b1 and b2 and b3 and b4
except:
return False
def generate(cls,
xprv=None,
prv=None,
seed=None,
child=None,
username=None,
mongodb_host=None,
db_name=None):
mnemonic = Mnemonic('english')
# generate 12 word mnemonic seed
if not seed and not xprv and not prv:
seed = mnemonic.generate(256)
private_key = None
if seed:
# create new wallet
entropy = mnemonic.to_entropy(seed)
key = BIP32Key.fromEntropy(entropy)
private_key = key.PrivateKey().hex()
extended_key = key.ExtendedKey()
public_key = PublicKey.from_point(
key.K.pubkey.point.x(), key.K.pubkey.point.y()).format().hex()
address = str(key.Address())
if prv:
key = PrivateKey.from_hex(prv)
private_key = key.to_hex()
extended_key = ''
public_key = key.public_key.format().hex()
address = str(
P2PKHBitcoinAddress.from_pubkey(bytes.fromhex(public_key)))
if xprv:
key = BIP32Key.fromExtendedKey(xprv)
private_key = key.PrivateKey().hex()
extended_key = key.ExtendedKey()
public_key = PublicKey.from_point(
key.K.pubkey.point.x(), key.K.pubkey.point.y()).format().hex()
address = str(key.Address())
if xprv and child:
for x in child:
key = key.ChildKey(int(x))
private_key = key.PrivateKey().hex()
public_key = PublicKey.from_point(
key.K.pubkey.point.x(),
key.K.pubkey.point.y()).format().hex()
address = str(key.Address())
if not private_key:
raise Exception('No key')
try:
u = UPnP(None, None, 200, 0)
u.discover()
u.selectigd()
peer_host = u.externalipaddress()
except:
try:
import urllib.request
peer_host = urllib.request.urlopen(
'https://ident.me').read().decode('utf8')
except:
peer_host = ''
return cls({
"modes": ['node', 'web', 'pool'],
"root_app": '',
"seed": seed or '',
"xprv": extended_key or '',
"private_key": private_key,
"wif": cls.generate_wif(private_key),
"public_key": public_key,
"address": address,
"api_whitelist": [],
"serve_host": "0.0.0.0",
"serve_port": 8001,
"use_pnp": False,
"ssl": False,
"origin": '',
"sia_api_key": '',
"post_peer": False,
"peer_host": peer_host,
"peer_port": 8000,
"peer_type": "user",
"peer": "http://localhost:8000",
"callbackurl": "http://0.0.0.0:8001/create-relationship",
"jwt_public_key": None,
"fcm_key": "",
"database": db_name or "yadacoin",
"site_database": db_name + "site" if db_name else "yadacoinsite",
"mongodb_host": mongodb_host or "localhost",
"mixpanel": "",
"username": username or '',
"network": "mainnet",
"wallet_host_port": 'http://localhost:8001',
"credits_per_share": 5,
"shares_required": False,
"pool_payout": False,
"pool_take": .01,
"payout_frequency": 6
})
modulo = gmpy2.mpz(modulo)
order = gmpy2.mpz(order)
Gx = gmpy2.mpz(Gx)
Gy = gmpy2.mpz(Gy)
class Point:
def __init__(self, x=0, y=0): # Affine
#def __init__(self, x=0, y=0, z=1): # Jacobian
self.x = x
self.y = y
#self.z = 1 # Jacobian
if (not flag_gmpy2) and flag_coincurve:
Gp = PublicKey.from_point(Gx, Gy) # basePoint
#Gp = PublicKey.from_valid_secret(int_to_bytes_padded(1)) # basePoint
else:
Gp = Point(Gx, Gy)
Zp = Point(0, 0) # zero-point, infinite in real x,y - plane
#######################
# math, raw python
# from arulberoECC library
# more fastest
def invert(b, p=modulo):
u, v = b % p, p
x1, x2 = 1, 0
while u != 1:
