def recover_eip712_signer(channel_adr, channel_seq, balance, signature): """ Recover the signer address the given EIP712 signature was signed with. :param channel_adr: Channel contract address. :type channel_adr: bytes :param channel_seq: Payment channel off-chain transaction sequence number. :type channel_seq: int :param balance: Balance remaining in the payment/paying channel after buying/selling the key. :type balance: int :param signature: The EIP712 (32+32+1 raw bytes) signature to verify. :type signature: bytes :return: The (computed) signer address the signature was signed with. :rtype: bytes """ assert type(channel_adr) == bytes and len(channel_adr) == 20 assert type(channel_seq) == int assert type(balance) == int assert type(signature) == bytes and len(signature) == _EIP712_SIG_LEN # recreate EIP712 typed data object data = _create_eip712_data(channel_adr, channel_seq, balance) # this returns the signer (checksummed) address as a string, eg "0xE11BA2b4D45Eaed5996Cd0823791E0C93114882d" signer_address = signing.recover_typed_data( data, *signing.signature_to_v_r_s(signature)) return a2b_hex(signer_address[2:])
def recover_eip712_member_login(chainId: int, verifyingContract: bytes, member: bytes, loggedIn: int, timestamp: int, member_email: str, client_pubkey: bytes, signature: bytes) -> bytes: """ Recover the signer address the given EIP712 signature was signed with. :return: The (computed) signer address the signature was signed with. :rtype: bytes """ assert type(chainId) == int assert type(verifyingContract) == bytes and len(verifyingContract) == 20 assert type(member) == bytes and len(member) == 20 assert type(loggedIn) == int assert type(timestamp) == int assert type(member_email) == str assert type(client_pubkey) == bytes and len(client_pubkey) == 32 assert type(signature) == bytes and len(signature) == _EIP712_SIG_LEN # recreate EIP712 typed data object data = _create_eip712_member_login(chainId, verifyingContract, member, loggedIn, timestamp, member_email, client_pubkey) # this returns the signer (checksummed) address as a string, eg "0xE11BA2b4D45Eaed5996Cd0823791E0C93114882d" signer_address = signing.recover_typed_data( data, *signing.signature_to_v_r_s(signature)) return a2b_hex(signer_address[2:])
def main(accounts): from py_eth_sig_utils import signing data['message'] = { 'channel_adr': '0x254dffcd3277C0b1660F6d42EFbB754edaBAbC2B', 'channel_seq': 39, 'balance': 2700, } # signature: 0xe32976b152f5d3107a789bee8512741493c262984145415c1ffb3a42c1a80e7224dd52cc552bf86665dd185d9e04004eb8d783f624eeb6aab0011c21757e6bb21b # generate a new raw random private key if True: # maker_key # pkey_raw = a2b_hex('6370fd033278c143179d81c5526140625662b8daa446c22ee2d73db3707e620c') # consumer_delegate_key #pkey_raw = a2b_hex('e485d098507f54e7733a205420dfddbe58db035fa577fc294ebd14db90767a52') pkey_raw = a2b_hex( 'a4985a2ed93107886e9a1f12c7b8e2e351cc1d26c42f3aab7f220f3a7d08fda6') else: pkey_raw = os.urandom(32) print('Using private key: {}'.format(b2a_hex(pkey_raw).decode())) # make a private key object from the raw private key bytes pkey = eth_keys.keys.PrivateKey(pkey_raw) # make a private account from the private key acct = Account.privateKeyToAccount(pkey) # get the public key of the account addr = pkey.public_key.to_canonical_address() print('Account address: {}'.format(b2a_hex(addr).decode())) # get the canonical address of the account caddr = web3.Web3.toChecksumAddress(addr) print('Account canonical address: {}'.format(caddr)) # step-wise computation of signature msg_hash = signing.encode_typed_data(data) print('Ok, MSG_HASH = 0x{}'.format(b2a_hex(msg_hash).decode())) sig_vrs = utils.ecsign(msg_hash, pkey_raw) sig = signing.v_r_s_to_signature(*sig_vrs) signature = signing.v_r_s_to_signature( *signing.sign_typed_data(data, pkey_raw)) assert len(signature) == 32 + 32 + 1 #assert signature == sig print('Ok, signed typed data (using key {}):\nSIGNATURE = 0x{}'.format( caddr, b2a_hex(signature).decode())) signer_address = signing.recover_typed_data( data, *signing.signature_to_v_r_s(signature)) assert signer_address == caddr print('Ok, verified signature was signed by {}'.format(signer_address))
def recover(data, signature): """ Recover the Ethereum address of the signer, given the data and signature. :param data: Signed data. :param signature: Signature. :return: Signing address. """ assert type(signature) == bytes and len(signature) == _EIP712_SIG_LEN signer_address = signing.recover_typed_data(data, *signing.signature_to_v_r_s(signature)) return a2b_hex(signer_address[2:])
def main(accounts): from py_eth_sig_utils import signing, utils from autobahn.xbr import _util verifying_adr = a2b_hex('0x254dffcd3277C0b1660F6d42EFbB754edaBAbC2B'[2:]) channel_adr = a2b_hex('0x254dffcd3277C0b1660F6d42EFbB754edaBAbC2B'[2:]) data = _util._create_eip712_data(verifying_adr, channel_adr, 39, 2700, False) # use fixed or generate a new raw random private key if True: # maker_key pkey_raw = a2b_hex( 'a4985a2ed93107886e9a1f12c7b8e2e351cc1d26c42f3aab7f220f3a7d08fda6') else: pkey_raw = os.urandom(32) print('Using private key: {}'.format(b2a_hex(pkey_raw).decode())) # make a private key object from the raw private key bytes pkey = eth_keys.keys.PrivateKey(pkey_raw) # make a private account from the private key acct = Account.privateKeyToAccount(pkey) # get the public key of the account addr = pkey.public_key.to_canonical_address() print('Account address: {}'.format(b2a_hex(addr).decode())) # get the canonical address of the account caddr = web3.Web3.toChecksumAddress(addr) print('Account canonical address: {}'.format(caddr)) # step-wise computation of signature msg_hash = signing.encode_typed_data(data) print('Ok, MSG_HASH = 0x{}'.format(b2a_hex(msg_hash).decode())) sig_vrs = utils.ecsign(msg_hash, pkey_raw) sig = signing.v_r_s_to_signature(*sig_vrs) signature = signing.v_r_s_to_signature( *signing.sign_typed_data(data, pkey_raw)) assert len(signature) == 32 + 32 + 1 #assert signature == sig print('Ok, signed typed data (using key {}):\nSIGNATURE = 0x{}'.format( caddr, b2a_hex(signature).decode())) signer_address = signing.recover_typed_data( data, *signing.signature_to_v_r_s(signature)) assert signer_address == caddr print('Ok, verified signature was signed by {}'.format(signer_address))
def recover_eip712_signer(eth_adr, ed25519_pubkey, key_id, channel_seq, amount, balance, signature): """ Recover the signer address the given EIP712 signature was signed with. :param eth_adr: Input typed data for signature. :type eth_adr: bytes :param ed25519_pubkey: Input typed data for signature. :type ed25519_pubkey: bytes :param key_id: Input typed data for signature. :type key_id: bytes :param channel_seq: Input typed data for signature. :type channel_seq: int :param amount: Input typed data for signature. :type amount: int :param balance: Input typed data for signature. :type balance: int :param signature: The EIP712 signature to verify. :type signature: bytes :return: The (computed) signer address the signature was signed with. :rtype: bytes """ assert type(eth_adr) == bytes and len(eth_adr) == 20 assert type(ed25519_pubkey) == bytes and len(ed25519_pubkey) == 32 assert type(key_id) == bytes and len(key_id) == 16 assert type(channel_seq) == int assert type(amount) == int assert type(balance) == int assert type(signature) == bytes and len(signature) == _EIP712_SIG_LEN # recreate EIP712 typed data object data = _create_eip712_data(eth_adr, ed25519_pubkey, key_id, channel_seq, amount, balance) # this returns the signer (checksummed) address as a string, eg "0xE11BA2b4D45Eaed5996Cd0823791E0C93114882d" signer_address = signing.recover_typed_data( data, *signing.signature_to_v_r_s(signature)) return a2b_hex(signer_address[2:])
def recover_eip712_channel_close(chainId: int, verifyingContract: bytes, closeAt: int, marketId: bytes, channelId: bytes, channelSeq: int, balance: int, isFinal: bool, signature: bytes) -> bytes: """ Recover the signer address the given EIP712 signature was signed with. :return: The (computed) signer address the signature was signed with. :rtype: bytes """ # create EIP712 typed data object data = _create_eip712_channel_close(chainId, verifyingContract, closeAt, marketId, channelId, channelSeq, balance, isFinal) assert type(signature) == bytes and len(signature) == _EIP712_SIG_LEN signer_address = signing.recover_typed_data( data, *signing.signature_to_v_r_s(signature)) return a2b_hex(signer_address[2:])
def main(accounts): from py_eth_sig_utils import signing data = data2 # generate a new raw random private key if True: pkey_raw = a2b_hex( 'a4985a2ed93107886e9a1f12c7b8e2e351cc1d26c42f3aab7f220f3a7d08fda6') else: pkey_raw = os.urandom(32) print('Using private key: {}'.format(b2a_hex(pkey_raw).decode())) # make a private key object from the raw private key bytes pkey = eth_keys.keys.PrivateKey(pkey_raw) # make a private account from the private key acct = Account.privateKeyToAccount(pkey) # get the public key of the account addr = pkey.public_key.to_canonical_address() print('Account address: {}'.format(b2a_hex(addr).decode())) # get the canonical address of the account caddr = web3.Web3.toChecksumAddress(addr) print('Account canonical address: {}'.format(caddr)) signature = signing.v_r_s_to_signature( *signing.sign_typed_data(data, pkey_raw)) assert len(signature) == 32 + 32 + 1 print('Ok, signed typed data using {}:\nSIGNATURE = 0x{}'.format( caddr, b2a_hex(signature).decode())) signer_address = signing.recover_typed_data( data, *signing.signature_to_v_r_s(signature)) assert signer_address == caddr print('Ok, verified signature was signed by {}'.format(signer_address))
def recover_eip712_channel_open(chainId: int, verifyingContract: bytes, ctype: int, openedAt: int, marketId: bytes, channelId: bytes, actor: bytes, delegate: bytes, marketmaker: bytes, recipient: bytes, amount: int, signature: bytes) -> bytes: """ Recover the signer address the given EIP712 signature was signed with. :return: The (computed) signer address the signature was signed with. :rtype: bytes """ # create EIP712 typed data object data = _create_eip712_channel_open(chainId, verifyingContract, ctype, openedAt, marketId, channelId, actor, delegate, marketmaker, recipient, amount) assert type(signature) == bytes and len(signature) == _EIP712_SIG_LEN signer_address = signing.recover_typed_data( data, *signing.signature_to_v_r_s(signature)) return a2b_hex(signer_address[2:])
def recover_eip712_member_register(chainId: int, verifyingContract: bytes, member: bytes, registered: int, eula: str, profile: str, signature: bytes) -> bytes: """ Recover the signer address the given EIP712 signature was signed with. :return: The (computed) signer address the signature was signed with. :rtype: bytes """ assert type(chainId) == int assert type(verifyingContract) == bytes and len(verifyingContract) == 20 assert type(member) == bytes and len(member) == 20 assert type(registered) == int assert type(eula) == str assert profile is None or type(profile) == str assert type(signature) == bytes and len(signature) == _EIP712_SIG_LEN # recreate EIP712 typed data object data = _create_eip712_member_register(chainId, verifyingContract, member, registered, eula, profile) # this returns the signer (checksummed) address as a string, eg "0xE11BA2b4D45Eaed5996Cd0823791E0C93114882d" signer_address = signing.recover_typed_data(data, *signing.signature_to_v_r_s(signature)) return a2b_hex(signer_address[2:])
def main(accounts): from py_eth_sig_utils import signing data = data2 # generate a new raw random private key if True: # maker_key # pkey_raw = a2b_hex('6370fd033278c143179d81c5526140625662b8daa446c22ee2d73db3707e620c') # consumer_delegate_key pkey_raw = a2b_hex('e485d098507f54e7733a205420dfddbe58db035fa577fc294ebd14db90767a52') else: pkey_raw = os.urandom(32) print('Using private key: {}'.format(b2a_hex(pkey_raw).decode())) # make a private key object from the raw private key bytes pkey = eth_keys.keys.PrivateKey(pkey_raw) # make a private account from the private key acct = Account.privateKeyToAccount(pkey) # get the public key of the account addr = pkey.public_key.to_canonical_address() print('Account address: {}'.format(b2a_hex(addr).decode())) # get the canonical address of the account caddr = web3.Web3.toChecksumAddress(addr) print('Account canonical address: {}'.format(caddr)) signature = signing.v_r_s_to_signature(*signing.sign_typed_data(data, pkey_raw)) assert len(signature) == 32 + 32 + 1 print('Ok, signed typed data using {}:\nSIGNATURE = 0x{}'.format(caddr, b2a_hex(signature).decode())) signer_address = signing.recover_typed_data(data, *signing.signature_to_v_r_s(signature)) assert signer_address == caddr print('Ok, verified signature was signed by {}'.format(signer_address))
def recover(data, signature): assert type(signature) == bytes and len(signature) == _EIP712_SIG_LEN signer_address = signing.recover_typed_data(data, *signing.signature_to_v_r_s(signature)) return a2b_hex(signer_address[2:])