def test_eth_account_recover_message(acct):
v, r, s = (
28,
'0xe6ca9bba58c88611fad66a6ce8f996908195593807c4b38bd528d2cff09d4eb3',
'0x3e5bfbbf4d3e39b1a2fd816a7680c19ebebaf3a141b239934ad43cb33fcec8ce',
)
message = "I♥SF"
message_hash = defunct_hash_message(text=message)
from_account = acct.recoverHash(message_hash, vrs=(v, r, s))
assert from_account == '0x5ce9454909639D2D17A3F753ce7d93fa0b9aB12E'
def test_eth_account_sign(acct, message, key, expected_bytes, expected_hash, v, r, s, signature):
message_hash = defunct_hash_message(text=message)
assert message_hash == expected_hash
signed = acct.signHash(message_hash, private_key=key)
assert signed.messageHash == expected_hash
assert signed.v == v
assert signed.r == r
assert signed.s == s
assert signed.signature == signature
account = acct.privateKeyToAccount(key)
assert account.signHash(message_hash) == signed
def owner(self):
# defunct_hash_message prepends `\x19Ethereum Signed Message:\n32`
message_hash = defunct_hash_message(primitive=self.safe_tx_hash)
return get_signing_address(message_hash, self.v - 4, self.r, self.s)
def generate_signature(self, message):
signature = bytes(self.sdk_web3.eth.account.signHash(defunct_hash_message(message),
self.account.signer_private_key).signature)
return signature
def sign_message_after_soliditySha3(self, message):
h = defunct_hash_message(message)
return self.w3.eth.account.signHash(h, self.private_key).signature
def __sign(self, json):
msg = dumps(json)
message_hash = defunct_hash_message(text=msg)
signature = self.__account.signHash(message_hash)['signature']
return "{}\n---\n{}".format(msg, w3.toHex(signature))
def ecVerify(message, signature):
message_hash = defunct_hash_message(text=message)
return w3.eth.account.recoverHash(message_hash, signature=signature)
def sign_hash(self, text: str = None, hexstr: str = None) -> str:
msg_hash: str = defunct_hash_message(hexstr=hexstr, text=text)
signature_dict: AttributeDict = self._account.signHash(msg_hash)
signature: str = signature_dict["signature"].hex()
return signature
def _eth_hashser(data):
return _EthHasher(defunct_hash_message(data))
def sign_offer(msg):
msg.nonce = os.urandom(32)
signed_hash = self.__account.signHash(defunct_hash_message(offer_hash(msg)))
msg.signature = signed_hash.signature
rospy.loginfo('bidhash: %s signature: %s', binascii.hexlify(offer_hash(msg)), binascii.hexlify(msg.signature))
self.signed_offer.publish(msg)
def sign_result(msg):
signed_hash = self.__account.signHash(defunct_hash_message(result_hash(msg)))
msg.signature = signed_hash.signature
rospy.loginfo('reshash: %s signature: %s', binascii.hexlify(result_hash(msg)), binascii.hexlify(msg.signature))
self.signed_result.publish(msg)
def handle_subdomain_post_request(request, github_handle):
# setup
signed_msg = request.POST.get('signedMsg', '')
signer = request.POST.get('signer', '').lower()
if signed_msg and signer:
# validation
message_hash = defunct_hash_message(
text=f'Github Username : {github_handle}')
recovered_signer = w3.eth.account.recoverHash(
message_hash, signature=signed_msg).lower()
if recovered_signer != signer:
return JsonResponse({
'success': False,
'msg': _('Sign Mismatch Error')
})
if not request.user.profile.trust_profile and request.user.profile.github_created_on > (
timezone.now() - timezone.timedelta(days=7)):
return JsonResponse({
'success':
False,
'msg':
_('For SPAM prevention reasons, you may not perform this action right now. '
'Please contact support if you believe this message is in error.'
)
})
# actually setup subdomain
start_nonce = get_nonce()
nonce = start_nonce
txn_hash_1 = set_owner(signer, github_handle, nonce)
nonce += 1
txn_hash_2 = set_resolver(signer, github_handle, nonce)
nonce += 1
txn_hash_3 = set_address_at_resolver(signer, github_handle, nonce)
gas_price = get_gas_price()
gas_cost_eth = (RESOLVER_GAS_COST + OWNER_GAS_COST +
SET_ADDRESS_GAS_COST) * gas_price / 10**18
profile = Profile.objects.filter(handle=github_handle.lower()).first()
if not txn_hash_1 or not txn_hash_2 or not txn_hash_3:
return JsonResponse({
'success':
False,
'msg':
_('Your ENS request has failed. Please try again.')
})
ENSSubdomainRegistration.objects.create(
profile=profile,
subdomain_wallet_address=signer,
txn_hash_1=txn_hash_1,
txn_hash_2=txn_hash_2,
txn_hash_3=txn_hash_3,
pending=True,
signed_msg=signed_msg,
start_nonce=start_nonce,
end_nonce=nonce,
gas_cost_eth=gas_cost_eth,
)
return JsonResponse({
'success':
True,
'msg':
_('Your request has been submitted. Please wait for the transaction to mine!'
)
})
return handle_default_response(request, github_handle)
def post(self):
""" Handle POST request """
if not self.request.body:
log.warning('Missing body')
self.set_status(400)
self.write_json({
'success': False,
'clicks': None,
'token': '',
})
return
req = json.loads(self.request.body)
token = req.get('token')
recipient = req.get('recipient')
contract = req.get('contract')
invalids = []
if not is_valid_token(token):
invalids.append('token')
if not recipient or not is_address(recipient):
invalids.append('recipient')
if not contract or not is_address(contract):
invalids.append('contract')
recipient = Web3.toChecksumAddress(recipient)
contract = Web3.toChecksumAddress(contract)
if len(invalids) > 0:
log.warning('Invalid input: {}'.format(', '.join(invalids)))
self.set_status(400)
self.write_json({
'success': False,
'clicks': None,
'token': '',
'message': 'Invalid input'
})
return
# Verify it exists
clicks = rgetint(self.redis, token, 0)
if not clicks:
log.warning('Token has no clicks')
self.write_json({
'success': False,
'clicks': None,
'token': token,
'message': 'Try clicking first'
})
return
log.info('create_claim({}, {}, {}, {})'.format(recipient,
add_0x_prefix(token),
clicks * int(1e18),
contract))
# Assemble claim
claim = create_claim(recipient, add_0x_prefix(token),
clicks * int(1e18), contract)
prefixed_claim_hash = defunct_hash_message(claim)
# Docstring for this function sugests this does not prefix messages, so
# we're prefixing above
signed = self.accounts.eth_account.signHash(
prefixed_claim_hash, self.signer_account_privkey)
self.write_json({
'success': True,
'clicks': clicks,
'token': token,
'claim': claim.hex(),
'signature': signed.signature.hex(),
'contract': contract,
})
def device_discovered(self, device):
mac_address = device.mac_address.replace(':', '_').upper()
path = '/org/bluez/%s/dev_%s' % (self.adapter_name, mac_address)
device_object = bus.get_object("org.bluez", path)
d = dbus.Interface(device_object, "org.bluez.Device1")
device_properties = dbus.Interface(d,
"org.freedesktop.DBus.Properties")
uuids = [
str(x) for x in device_properties.Get("org.bluez.Device1", "UUIDs")
]
if uuids:
device_uuids[device.mac_address].union(set(uuids))
for u in uuids:
# - decrypt with firefly_key
ack_uuid = uuid.UUID('urn:uuid:{}'.format(u))
decrypted_payload = decrypt(ack_uuid.bytes)
# - verify it contains crc24 + data
pl_crc = decrypted_payload[:3]
pl_data = decrypted_payload[3:]
crc_val = crc24(pl_data)
ver_crc = (crc_val).to_bytes(3, byteorder='big', signed=False)
if pl_crc != ver_crc:
# print("CRC24 mismatch\nCalculated {}\nExpected {}".format(
# [str(sbyte(b)) for b in ver_crc],
# [str(sbyte(b)) for b in pl_crc]
# ))
break
# henceforth we know it's a firefly message
print('MAC Address ', device.mac_address)
print('UUID Payload ', u)
print("Decrypted Payload {}".format(
[str(sbyte(b)) for b in decrypted_payload]))
# - break data based on firefly semantics
blecast_ctl = pl_data[0].to_bytes(1, byteorder="big")
firefly_cmd = pl_data[1].to_bytes(1, byteorder="big")
firefly_data = pl_data[2:]
# print(blecast_ctl)
if blecast_ctl != b'\x00':
print(
'messages dependent on multiple advertisements are not supported yet'
)
break
# - sign actual payload
if firefly_cmd != b'\x02':
print('unsupported firefly command {}'.format(firefly_cmd))
self.stop()
break
print()
resp = input('sign "{}"? (y/N) '.format(
str(firefly_data))).strip()
if resp.lower() != 'y' and resp.lower() != 'yes':
break
message_hash = defunct_hash_message(primitive=firefly_data)
signed_message = w3.eth.account.signHash(
message_hash, private_key=eth_account.privateKey)
recovered = w3.eth.account.recoverHash(
message_hash,
vrs=(28, hex(signed_message['r']),
hex(signed_message['s'])))
assert (recovered == eth_account.address)
# print('r\t', hex(signed_message['r']))
# print('s\t', hex(signed_message['s']))
# print('v\t', hex(signed_message['v']))
# print()
# print(firefly_data)
# print([str(sbyte(b)) for b in firefly_data])
# print()
# print(message_hash.hex())
# print(len(message_hash))
# print([str(sbyte(b)) for b in message_hash])
# print()
# print(signed_message)
# print()
sig_s = 'SIG:S/{}'.format(hex(signed_message['s']))
sig_r = 'SIG:R/{}'.format(hex(signed_message['r']))
qr_s = qrcode.make(sig_s)
qr_r = qrcode.make(sig_r)
w, h = qr_s.size
new_im = Image.new('L', (w * 2, h))
new_im.paste(qr_r)
new_im.paste(qr_s, (w, 0))
new_im.show()
self.stop()
def test_eth_account_hash_message_hexstr(acct, message, expected):
assert defunct_hash_message(hexstr=message) == expected
# get the deeID contract
deeIDContract = w3.eth.contract(
address=address,
abi=abi,
)
# address of the identity holder
#address = Web3.toChecksumAddress("0xf2beae25b23f0ccdd234410354cb42d08ed54981")
address = Web3.toChecksumAddress(req_data['recDID'])
# the public key we wish to verify
# WE NEED msg AND sig
# NOT SECURE, IN THE FUTURE RUN PROPER MSG PROCESSING
msgHash = defunct_hash_message(text=req_data['msg'])
verPubKey = w3.eth.account.recoverHash(msgHash, signature=req_data['sig'])
#verPubKey = "0x627306090abab3a6e1400e9345bc60c78a8bef57"
"""
# set pre-funded account as sender
w3.eth.defaultAccount = w3.eth.accounts[1]
print(Web3.toChecksumAddress(w3.eth.defaultAccount))
# get the DID contract
DIDContract = w3.eth.contract(
address=address,
abi=abi,
)
# search through the keys
def keySearch(DIDContract):
def hash_message(msg_bytes):
return defunct_hash_message(msg_bytes)
def _verify_my_signature(self, signature, mpe_address, channel_id, nonce, amount):
message = self._compose_message_to_sign(mpe_address, channel_id, nonce, amount)
message_hash = defunct_hash_message(message)
sign_address = self.ident.w3.eth.account.recoverHash(message_hash, signature=signature)
return sign_address == self.ident.address
def sign(message, privateKey):
messageHash = defunct_hash_message(text=message)
signedMessage = web3.eth.account.signHash(messageHash,
private_key=privateKey)
return web3.toHex(signedMessage.signature)
def mission_diplomacy_room_helper(request, game):
# handle invites
users_players = GamePlayer.objects.filter(active=True,
profile=request.user.profile)
users_games = Game.objects.filter(pk__in=users_players.values_list("game"))
users_player = users_players.first()
if game not in users_games:
if request.user.is_authenticated:
# too many user condition
if game.active_players.count() >= max_players_per_game:
messages.info(
request,
f'There are already {max_players_per_game} in the game. Wait for someone to leave + try again.'
)
return mission_diplomacy_helper(request)
# show invite
if request.GET.get('join'):
game.add_player(request.user.profile.handle)
else:
return mission_diplomacy_helper(request, invited_to_game=game)
else:
# logged out condition
messages.info(request, f'Please login to join this game.')
# in game experience
is_member = game.is_active_player(request.user.profile.handle)
is_admin = game.players.filter(admin=True,
profile=request.user.profile).exists()
if is_admin:
if request.GET.get('remove'):
remove_this_fool = request.GET.get('remove')
for player in game.players.filter(
active=True, profile__handle=remove_this_fool):
game.remove_player(player.profile.handle)
messages.info(request, f'{remove_this_fool} has been removed')
# delete game
if is_member and request.GET.get('delete'):
game.remove_player(request.user.profile.handle)
messages.info(request, f'You have left this game.')
return redirect('/quadraticlands/mission/diplomacy')
# chat in game
if is_member and request.POST.get('chat'):
game.chat(request.user.profile.handle, request.POST.get('chat'))
# make a move
if is_member and request.POST.get('signature'):
package = request.POST.get('package')
moves = json.loads(package)
signature = request.POST.get('signature')
recipient_address = Web3.toChecksumAddress(moves['account'])
web3 = get_web3('mainnet')
gtc = web3.eth.contract(address=Web3.toChecksumAddress(
'0xde30da39c46104798bb5aa3fe8b9e0e1f348163f'),
abi=erc20_abi)
balance = int(
(gtc.functions.balanceOf(recipient_address).call()) / (10**18))
claimed_balance = int(moves['balance'])
signer_address = Web3.toChecksumAddress(
web3.eth.account.recoverHash(defunct_hash_message(text=package),
signature=signature))
claimed_address = Web3.toChecksumAddress(moves['account'])
if claimed_balance != balance:
return HttpResponse('not authorized - bad balance', status=401)
if claimed_address != signer_address:
return HttpResponse('not authorized - bad addr', status=401)
data = {
'moves': moves,
'signature': signature,
}
game.make_move(request.user.profile.handle, data)
return JsonResponse({'msg': 'OK', 'url': game.url})
# game view
params = {
'title': game.title,
'users_player': users_player,
'game': game,
'is_admin': is_admin,
'max_players': max_players_per_game,
}
return TemplateResponse(request,
'quadraticlands/mission/diplomacy/room.html',
params)
def buildUnsignedOrder(message):
message_hash = defunct_hash_message(text=message)
signed_msg = w3.eth.account.signHash(message_hash, private_key=private_key)
signed_msg = signed_msg.signature
signature = w3.toHex(signed_msg)
return signature
from web3.auto import w3
from eth_account.messages import defunct_hash_message
import json, binascii
from hexbytes import HexBytes
import asyncio
import websockets
# Acting like the mobile phone
msg = 'bmMfnO5HE2m2'
pk = '0xb50c18d670e82f3f559142d63773b5f60882d337f7d40e78f87973484740ab0d'
msgHash = defunct_hash_message(text=msg)
signedMsg = w3.eth.account.signHash(msgHash, private_key=pk)
#hexdecimal = "".join(["{:02X}".format(b) for b in hb])
#print(hexdecimal)
hexSig = binascii.hexlify(signedMsg.signature)
sig = str(hexSig).split("'")[1]
print('------------------------------')
print(w3.eth.account.recoverHash(msgHash, signature=signedMsg.signature))
print('------------------------------')
v = json.dumps({
'type' : 'loginSig',
'host' : msg,
'signature' : str(sig)
})
print(v)
def deploy(ctx_obj):
"""
Deploys a new instance of ERC20Mintable.sol on MaticVigil.
When prompted, enter a JSON-compatible list of constructor inputs to be passed on to the ERC20Mintable contract.
For example, ["My Token", "SYMBOL", 18] corresponding to ERC20 standards: token name, token symbol, token decimals
NOTE: Enter double quoted strings. Single quoted strings are not supported as JSON serialized.
Check deploy.py for a code example
"""
msg = "Trying to deploy"
message_hash = defunct_hash_message(text=msg)
private_key = ctx_obj['private_key']
contract_addr = ctx_obj['contract_address']
if contract_addr != '':
if click.confirm(
'You already have a contract address specified in the settings file. '
'Do you want to proceed with deploying another contract? '):
pass
else:
return
click.echo('Enter the list of constructor inputs: ')
constructor_inputs = input()
if constructor_inputs.strip() == "":
if click.confirm(
'Do you want to use the defaults ["My Token", "SYMBOL", 18]'):
constructor_inputs = ["My Token", "SYMBOL", 18]
else:
return
else:
try:
constructor_inputs = json.loads(constructor_inputs)
except json.JSONDecodeError:
click.echo("Enter a valid JSON list for constructor inputs")
if click.confirm(
'Do you want to use the defaults ["My Token", "SYMBOL", 18]'
):
constructor_inputs = ["My Token", "SYMBOL", 18]
else:
return
sig_msg = Account.signHash(message_hash, private_key)
with open('./ERC20Mintable.sol', 'r') as f:
contract_code = f.read()
deploy_params = {
'msg': msg,
'sig': sig_msg.signature.hex(),
'name': 'ERC20Mintable',
'inputs': constructor_inputs,
'code': contract_code
}
click.echo('Deploying with constructor arguments: ')
click.echo(constructor_inputs)
# API call to deploy
headers = {
'accept': 'application/json',
'Content-Type': 'application/json'
}
r = requests.post(ctx_obj['internal_api_endpoint'] + '/deploy',
json=deploy_params,
headers=headers)
rj = r.json()
click.echo('Deployed contract results')
click.echo(rj)
if rj['success']:
click.echo('Copy the contract address into settings.json')
def sign_message(self, message, out_f, agent_version=2):
if agent_version == 1:
h = defunct_hash_message(hexstr=self.w3.sha3(hexstr=message).hex())
else:
h = defunct_hash_message(text=message.lower())
return self.w3.eth.account.signHash(h, self.private_key).signature
def deploy(self, contract_file, contract_name, inputs):
"""
Deploys a smart contract from the solidity source code specified
:param contract_file : path to the contract file name
:param contract_name : the contract name to be deployed from the file
:param inputs : mapping of constructor arguments
"""
contract_src = ""
if self._verbose:
print('Got unordered constructor inputs: ')
print(inputs)
sources = dict()
if contract_file[0] == '~':
contract_full_path = os.path.expanduser(contract_file)
else:
contract_full_path = contract_file
resident_directory = ''.join(
map(lambda x: x + '/',
contract_full_path.split('/')[:-1]))
contract_file_name = contract_full_path.split('/')[-1]
contract_file_obj = open(file=contract_full_path)
main_contract_src = ''
while True:
chunk = contract_file_obj.read(1024)
if not chunk:
break
main_contract_src += chunk
sources[f'ev-py-sdk/{contract_file_name}'] = {
'content': main_contract_src
}
# loop through imports and add them to sources
source_unit = parser.parse(main_contract_src)
source_unit_obj = parser.objectify(source_unit)
for each in source_unit_obj.imports:
import_location = each['path'].replace("'", "")
# TODO: follow specified relative paths and import such files too
if import_location[:2] != './':
ev_core_logger.error(
'You can only import files from within the same directory as of now'
)
raise EVBaseException(
'You can only import files from within the same directory as of now'
)
# otherwise read the file into the contents mapping
full_path = resident_directory + import_location[2:]
imported_contract_obj = open(full_path, 'r')
contract_src = ''
while True:
chunk = imported_contract_obj.read(1024)
if not chunk:
break
contract_src += chunk
sources[f'ev-py-sdk/{import_location[2:]}'] = {
'content': contract_src
}
abi_json = extract_abi(self._settings, {
'sources': sources,
'sourceFile': f'ev-py-sdk/{contract_file_name}'
})
abp = ABIParser(abi_json=abi_json)
abp.load_abi()
c_inputs = abp.ordered_map_to_ev_constructor_args(inputs)
if self._verbose:
print('Ordered constructor inputs: \n', c_inputs)
msg = "Trying to deploy"
message_hash = defunct_hash_message(text=msg)
signed_msg = Account.signHash(message_hash,
self._settings['PRIVATEKEY'])
deploy_json = {
'msg': msg,
'sig': signed_msg.signature.hex(),
'name': contract_name,
'inputs': c_inputs,
'sources': sources,
'sourceFile': f'ev-py-sdk/{contract_file_name}'
}
# --MATICVIGIL API CALL---
r = make_http_call(request_type='post',
url=self._settings['INTERNAL_API_ENDPOINT'] +
'/deploy',
params=deploy_json)
if self._verbose:
ev_core_logger.debug('MaticVigil deploy response: ')
ev_core_logger.debug(r)
return r['data']
def sign_message_with_private_key(w3, private_key, message):
h = defunct_hash_message(message)
return w3.eth.account.signHash(h, private_key).signature
def sign_message(account, message_str):
msg_hash = defunct_hash_message(text=message_str)
full_signature = account.sign_message(msg_hash)
return full_signature.signature.hex()
def verify_sign(address, signature, primitive=None, hexstr=None, text=None):
msg_hash = defunct_hash_message(primitive, hexstr, text)
signature = w3.toBytes(hexstr=signature)
return address == w3.eth.account.recoverHash(msg_hash, signature=signature)
def test_commit_access_requested(client):
expire_seconds = 9999999999
consumer_account = ocean.web3.eth.accounts[1]
# consumer_account = '0x009c95E90369bED8ECCD3AA3DFaf0F8a90849b17'
provider_account = ocean.web3.eth.accounts[0]
# provider_account = '0x007341576b7F7fB0A135728C1A9DA487b1191124'
print("Starting test_commit_access_requested")
print("buyer: %s" % consumer_account)
print("seller: %s" % provider_account)
resource_id = market_concise.generateId(
'resource', transact={'from': provider_account})
print("recource_id: %s" % resource_id)
resource_price = 10
json_consume['assetId'] = ocean.web3.toHex(resource_id)
client.post(BaseURLs.BASE_PROVIDER_URL + '/assets/metadata',
data=json.dumps(json_consume),
content_type='application/json')
pubprivkey = generate_encryption_keys()
pubkey = pubprivkey.public_key
privkey = pubprivkey.private_key
market_concise.requestTokens(2000, transact={'from': provider_account})
market_concise.requestTokens(2000, transact={'from': consumer_account})
# TODO Use the events with the filters intitialized by the application insetad of this
# filter_access_consent = ocean.watch_event(OceanContracts.OACL, 'AccessConsentRequested',
# ocean.commit_access_request, 250,
# fromBlock='latest', filters={"address": provider_account})
# filter_payment = ocean.watch_event(OceanContracts.OMKT, 'PaymentReceived', ocean.publish_encrypted_token, 2500,
# fromBlock='latest', filters={"address": provider_account})
# 1. Provider register an asset
market_concise.register(resource_id,
resource_price,
transact={'from': provider_account})
# 2. Consumer initiate an access request
expiry = int(time.time() + expire_seconds)
req = acl_concise.initiateAccessRequest(
resource_id,
provider_account,
pubkey,
expiry,
transact={'from': consumer_account})
receipt = ocean.get_tx_receipt(req)
send_event = acl.events.AccessConsentRequested().processReceipt(receipt)
request_id = send_event[0]['args']['_id']
# events = get_events(filter_access_consent)
# assert send_event[0] in events
assert acl_concise.statusOfAccessRequest(
request_id) == 0 or acl_concise.statusOfAccessRequest(request_id) == 1
filter_token_published = ocean.watch_event(
OceanContracts.OACL,
'EncryptedTokenPublished',
process_enc_token,
0.25,
fromBlock='latest') # , filters={"id": request_id})
# 3. Provider commit the request in commit_access_request
# Verify consent has been emited
i = 0
while (acl_concise.statusOfAccessRequest(request_id)
== 1) is False and i < 100:
i += 1
time.sleep(0.1)
assert acl_concise.statusOfAccessRequest(request_id) == 1
# 4. consumer make payment after approve spend token
token.approve(ocean.web3.toChecksumAddress(market_concise.address),
resource_price,
transact={'from': consumer_account})
buyer_balance_start = token.balanceOf(consumer_account)
seller_balance_start = token.balanceOf(provider_account)
print('starting buyer balance = ', buyer_balance_start)
print('starting seller balance = ', seller_balance_start)
send_payment = market_concise.sendPayment(request_id,
provider_account,
resource_price,
expiry,
transact={
'from': consumer_account,
'gas': 400000
})
print('buyer balance = ', token.balanceOf(consumer_account))
print('seller balance = ', token.balanceOf(provider_account))
# tx_hashes = set()
# events = get_events(filter_payment)
# for ev in events:
# tx_hashes.add(ev['transactionHash'])
# assert events
# assert send_payment in tx_hashes
# assert acl_concise.getTempPubKey(request_id, call={"from": provider_account}) == pubkey
events = get_events(filter_token_published)
assert events
assert events[0].args['_id'] == request_id
on_chain_enc_token = events[0].args["_encryptedAccessToken"]
on_chain_enc_token2 = acl_concise.getEncryptedAccessToken(
request_id, call={'from': consumer_account})
decrypted_token = dec(on_chain_enc_token, privkey)
# pub_key = ocean.encoding_key_pair.public_key
access_token = decode(decrypted_token)
assert pubkey == access_token['temp_pubkey']
signature = ocean.web3.eth.sign(consumer_account, data=on_chain_enc_token)
fixed_msg = defunct_hash_message(
hexstr=ocean.web3.toHex(on_chain_enc_token))
sig = ocean.split_signature(signature)
#
# assert acl_concise.isSigned(consumer_account,
# ocean.web3.toHex(fixed_msg),
# sig.v,
# sig.r,
# sig.s,
# call={'from': provider_account})
json_request_consume['fixed_msg'] = ocean.web3.toHex(fixed_msg)
json_request_consume['consumerId'] = consumer_account
json_request_consume['sigEncJWT'] = ocean.web3.toHex(signature)
json_request_consume['jwt'] = ocean.web3.toBytes(
hexstr=ocean.web3.toHex(decrypted_token)).decode('utf-8')
post = client.post(access_token['service_endpoint'].split('5000')[1] +
'/%s' % ocean.web3.toHex(resource_id),
data=json.dumps(json_request_consume),
content_type='application/json')
print(post.data.decode('utf-8'))
assert post.status_code == 200
assert acl_concise.statusOfAccessRequest(request_id) == 3
buyer_balance = token.balanceOf(consumer_account)
seller_balance = token.balanceOf(provider_account)
print('end: buyer balance -- current %s, starting %s, diff %s' %
(buyer_balance, buyer_balance_start,
(buyer_balance - buyer_balance_start)))
print('end: seller balance -- current %s, starting %s, diff %s' %
(seller_balance, seller_balance_start,
(seller_balance - seller_balance_start)))
assert token.balanceOf(
consumer_account) == buyer_balance_start - resource_price
assert token.balanceOf(
provider_account) == seller_balance_start + resource_price
print('All good \/')
def test_eth_account_hash_message_text(message, expected):
assert defunct_hash_message(text=message) == expected
def _verify_my_signature(self, signature, mpe_address, channel_id, nonce, amount):
message = self._compose_message_to_sign(mpe_address, channel_id, nonce, amount)
message_hash = defunct_hash_message(message)
sign_address = self.ident.w3.eth.account.recoverHash(message_hash, signature=signature)
return sign_address == self.ident.address
def generate_signature_bytes(self, data_types, values, signer_key):
signer_key = "0x" + signer_key if not signer_key.startswith("0x") else signer_key
message = web3.Web3.soliditySha3(data_types, values)
signature = self.web3_object.eth.account.signHash(defunct_hash_message(message), signer_key)
return bytes(signature.signature)
def recover_to_addr(token, signature):
msghash = defunct_hash_message(text=token)
address = w3.eth.account.recoverHash(msghash, signature=signature)
res = is_hex_address(address)
return address
