def test_export_private_key(fx_test_client: FlaskClient, fx_session: Session,
fx_user: User, fx_private_key: PrivateKey):
fx_test_client.post('/login',
data={
'private_key': fx_private_key.to_hex(),
},
follow_redirects=True)
response = fx_test_client.get('/export/')
assert response.headers['Content-Disposition'] == \
f'attachment;filename={fx_user.address}.csv'
assert response.headers['Content-Type'] == 'text/csv'
assert response.data == fx_private_key.to_hex().encode()
def test_get_new_novice_broadcasting(
fx_test_client: FlaskClient,
fx_user: User,
fx_private_key: PrivateKey,
fx_session: scoped_session,
):
with unittest.mock.patch('nekoyume.game.multicast') as m:
fx_test_client.post('/login',
data={
'private_key': fx_private_key.to_hex(),
'name': 'test_user',
},
follow_redirects=True)
res = fx_test_client.get('/new')
assert res.status_code == 200
move = fx_session.query(Move).filter(
Move.name == 'create_novice', ).first()
assert move
serialized = move.serialize(
use_bencode=False,
include_signature=True,
include_id=True,
)
assert m.called
args = m.call_args[1]
assert serialized == args['serialized']
my_node = args['my_node']
assert isinstance(my_node, Node)
assert my_node.url == 'http://localhost'
broadcast = args['broadcast']
assert isinstance(broadcast, typing.Callable)
assert broadcast.__name__ == 'broadcast_move'
def __save_key(key_folder: str, pk: coincurve.PrivateKey) -> str:
path = os.path.abspath(key_folder)
if not os.path.exists(path):
os.makedirs(path)
with open(os.path.join(path, Client.KEY_FILE_NAME), "wb") as file_out:
file_out.write(pk.to_hex().encode())
return path
def get_web3(eth_tester: EthereumTester, deployer_key: CCPrivateKey) -> Web3:
"""Returns an initialized Web3 instance"""
provider = EthereumTesterProvider(eth_tester)
web3 = Web3(provider)
# add faucet account to tester
eth_tester.add_account(deployer_key.to_hex())
# make faucet rich
eth_tester.send_transaction(
{
"from": eth_tester.get_accounts()[0],
"to": private_key_to_address(deployer_key.to_hex()),
"gas": 21000,
"value": FAUCET_ALLOWANCE,
}
)
return web3
def test_new_character_creation(fx_test_client, fx_session):
privkey = PrivateKey()
fx_test_client.post('/login',
data={
'private_key': privkey.to_hex(),
},
follow_redirects=True)
assert fx_session.query(Move).filter_by(
user_address=get_address(privkey.public_key),
user_public_key=privkey.public_key.format(compressed=True),
name='create_novice').first()
def deploy_contract(
web3: Web3,
contracts_manager: ContractManager,
contract_name: str,
deployer_key: CCPrivateKey,
args: List[Any],
) -> Contract:
deployer_address = private_key_to_address(deployer_key.to_hex())
json_contract = contracts_manager.get_contract(contract_name)
contract = web3.eth.contract(abi=json_contract["abi"], bytecode=json_contract["bin"])
tx_hash = contract.constructor(*args).transact(TxParams({"from": deployer_address}))
contract_address = web3.eth.get_transaction_receipt(tx_hash)["contractAddress"]
return contract(contract_address)
def generateKey():
# [type] PrivateKey
priKey = PrivateKey()
# [type] bytes
pubKey = priKey.public_key.format(compressed=False)[1:]
# address
addr = keccak_256(pubKey).digest()[-20:]
return {
"privateKey": str(priKey.to_hex()),
"publicKey": str(pubKey.hex()),
"address": str(addr.hex()),
"address(EIP-55)": str(addCheckSum(addr))
}
def deploy_contract(
web3: Web3,
contracts_manager: ContractManager,
contract_name: str,
deployer_key: PrivateKey,
args: Optional[List] = None,
) -> Contract:
deployer_address = private_key_to_address(deployer_key.to_hex())
json_contract = contracts_manager.get_contract(contract_name)
contract = web3.eth.contract(abi=json_contract["abi"],
bytecode=json_contract["bin"])
tx_hash = contract.constructor(*args).call_and_transact(
{"from": deployer_address})
contract_address = web3.eth.getTransactionReceipt(tx_hash).contractAddress
return contract(contract_address)
def __init__(self):
super().__init__()
self.log = list()
self.settle_timeout = 10
deployer_key = PrivateKey(secret=b'deploy_key')
pyevm_main.GENESIS_GAS_LIMIT = 6 * 10**6
self.tester_chain = ethereum_tester()
self.web3 = get_web3(self.tester_chain, deployer_key)
self.tokens = [
deploy_custom_token(
self.web3,
deployer_key,
),
deploy_custom_token(
self.web3,
deployer_key,
),
]
self.token = self.tokens[0]
self.token_addresses = [token.address for token in self.tokens]
self.private_keys = [
PrivateKey(secret=b'p1'),
PrivateKey(secret=b'p2'),
PrivateKey(secret=b'p3'),
]
# Create and fund accounts with Ether and CustomToken
self.addresses = []
token_amount = 100000
for private_key in self.private_keys:
self.tester_chain.add_account(private_key.to_hex())
address = private_key_to_address(private_key.to_hex())
self.tester_chain.send_transaction({
'from':
self.tester_chain.get_accounts()[0],
'to':
address,
'gas':
21000,
'value':
self.web3.toWei(100, 'ether'),
})
self.token.functions.transfer(
address,
token_amount,
).transact({
'from': private_key_to_address(deployer_key.to_hex()),
})
self.addresses.append(address)
self.secret_registry = deploy_contract(
self.web3,
CONTRACT_SECRET_REGISTRY,
deployer_key,
[], # No Libs
[], # No Args
)
self.token_network_registry = deploy_contract(
self.web3,
CONTRACT_TOKEN_NETWORK_REGISTRY,
deployer_key,
[],
[
self.secret_registry.address,
1,
TEST_SETTLE_TIMEOUT_MIN,
TEST_SETTLE_TIMEOUT_MAX,
],
)
self.token_network_registry.functions.createERC20TokenNetwork(
self.token.address,
MAX_ETH_CHANNEL_PARTICIPANT,
MAX_ETH_TOKEN_NETWORK,
).transact()
token_network_address = self.token_network_registry.functions.token_to_token_networks(
self.token.address, ).call()
self.token_network = get_token_network(
self.web3,
to_checksum_address(token_network_address),
)
channel_identifier = self.open_channel()
self.closing_address = None
self.update_transfer_called = False
self.participant_addresses = {
self.addresses[0],
self.addresses[1],
}
self.channel_addresses = [
channel_identifier,
make_address(),
]
class Kutil:
def __init__(self, network: str, privkey=None, seed=None, wif=None):
'''wif=<WIF> import private key from your wallet in WIF format
privkey=<privkey> import private key in binary format
network=<network> specify network [ppc, tppc, btc]
seed=<seed> specify seed (string) to make the privkey from'''
if privkey is not None:
self.keypair = PrivateKey(unhexlify(privkey))
if seed is not None:
self.keypair = PrivateKey(sha256(seed.encode()).hexdigest())
if wif is not None:
key = self.wif_to_privkey(wif)
self.keypair = PrivateKey(key["privkey"])
network = key['net_prefix']
if privkey == seed == wif is None:
self.keypair = PrivateKey()
if not is_ecdsa:
self.privkey = self.keypair.to_hex().encode()
self.pubkey = hexlify(self.keypair.public_key.format())
else:
self.privkey = self.keypair.private_key
self.pubkey = self.keypair.public_key
self.load_network_parameters(network)
def load_network_parameters(self, network: str) -> None:
'''loads network parameters and sets class variables'''
for field, var in zip(query(network)._fields, query(network)):
setattr(self, field, var)
def wif_to_privkey(self, wif: str) -> dict:
'''import WIF'''
if not 51 <= len(wif) <= 52:
return 'Invalid WIF length'
b58_wif = b58decode(wif)
return {'privkey': b58_wif[1:33], 'net_prefix': hexlify(b58_wif[0:1])}
@property
def address(self) -> str:
'''generate an address from pubkey'''
key = unhexlify(self.pubkey) # compressed pubkey as default
keyhash = unhexlify(
self.pubkeyhash +
hexlify(new('ripemd160',
sha256(key).digest()).digest()))
checksum = sha256(sha256(keyhash).digest()).digest()[0:4]
address = keyhash + checksum
return b58encode(address)
@property
def wif(self) -> str:
'''convert raw private key to WIF'''
extkey = unhexlify(self.wif_prefix + self.privkey +
b'01') # compressed by default
extcheck = extkey + sha256(sha256(extkey).digest()).digest()[0:4]
wif = b58encode(extcheck)
return wif
def generate_private_key():
"""Generates a private key."""
privkey = PrivateKey()
return bytes(bytearray.fromhex(privkey.to_hex()))
class BaseKey:
"""This class represents a point on the elliptic curve secp256k1 and
provides all necessary cryptographic functionality. You shouldn't use
this class directly.
:param wif: A private key serialized to the Wallet Import Format. If the
argument is not supplied, a new private key will be created.
The WIF compression flag will be adhered to, but the version
byte is disregarded. Compression will be used by all new keys.
:type wif: ``str``
:raises TypeError: If ``wif`` is not a ``str``.
"""
def __init__(self, wif=None):
if wif:
if isinstance(wif, str):
private_key_bytes, compressed, version = wif_to_bytes(wif)
self._pk = ECPrivateKey(private_key_bytes)
elif isinstance(wif, ECPrivateKey):
self._pk = wif
compressed = True
else:
raise TypeError('Wallet Import Format must be a string.')
else:
self._pk = ECPrivateKey()
compressed = True
self._public_point = None
self._public_key = self._pk.public_key.format(compressed=compressed)
@property
def public_key(self):
"""The public point serialized to bytes."""
return self._public_key
@property
def public_point(self):
"""The public point (x, y)."""
if self._public_point is None:
self._public_point = Point(*public_key_to_coords(self._public_key))
return self._public_point
def sign(self, data):
"""Signs some data which can be verified later by others using
the public key.
:param data: The message to sign.
:type data: ``bytes``
:returns: A signature compliant with BIP-62.
:rtype: ``bytes``
"""
return self._pk.sign(data)
def verify(self, signature, data):
"""Verifies some data was signed by this private key.
:param signature: The signature to verify.
:type signature: ``bytes``
:param data: The data that was supposedly signed.
:type data: ``bytes``
:rtype: ``bool``
"""
return self._pk.public_key.verify(signature, data)
def pub_to_hex(self):
""":rtype: ``str`` """
return bytes_to_hex(self.public_key)
def to_hex(self):
""":rtype: ``str``"""
return self._pk.to_hex()
def to_bytes(self):
""":rtype: ``bytes``"""
return self._pk.secret
def to_der(self):
""":rtype: ``bytes``"""
return self._pk.to_der()
def to_pem(self):
""":rtype: ``bytes``"""
return self._pk.to_pem()
def to_int(self):
""":rtype: ``int``"""
return self._pk.to_int()
def is_compressed(self):
"""Returns whether or not this private key corresponds to a compressed
public key.
:rtype: ``bool``
"""
return True if len(self.public_key) == 33 else False
def __eq__(self, other):
return self.to_int() == other.to_int()
