def full_verkey(self):
if self.abbreviated:
rtn = friendlyToRaw(self.identifier)
rtn += friendlyToRaw(self.verkey[1:])
return rawToFriendly(rtn)
else:
return self.verkey
def full_verkey(self):
if self.abbreviated:
rtn = friendlyToRaw(self.identifier)
rtn += friendlyToRaw(self.verkey[1:])
return rawToFriendly(rtn)
else:
return self.verkey
def client1Signer():
seed = b'client1Signer secret key........'
signer = DidSigner(seed=seed)
testable_verkey = friendlyToRaw(signer.identifier)
testable_verkey += friendlyToRaw(signer.verkey[1:])
testable_verkey = base58.b58encode(testable_verkey)
assert testable_verkey == '6JvpZp2haQgisbXEXE9NE6n3Tuv77MZb5HdF9jS5qY8m'
return signer
def connectTo(self, ha, verkey, pubkey):
if not self.isConnectedTo(ha=ha):
assert pubkey, 'Need public key to connect to {}'.format(ha)
zvk = z85.encode(friendlyToRaw(verkey)) if verkey else None
zpk = z85.encode(friendlyToRaw(pubkey))
self.connect(name=verkey or pubkey, ha=ha, verKey=zvk, publicKey=zpk)
else:
logger.debug('{} already connected {}'.format(self, ha))
def client1Signer():
seed = b'client1Signer secret key........'
signer = DidSigner(seed=seed)
testable_verkey = friendlyToRaw(signer.identifier)
testable_verkey += friendlyToRaw(signer.verkey[1:])
testable_verkey = base58.b58encode(testable_verkey).decode("utf-8")
assert testable_verkey == '6JvpZp2haQgisbXEXE9NE6n3Tuv77MZb5HdF9jS5qY8m'
return signer
def connectTo(self, linkName=None, link=None):
assert linkName or link
if link is None:
link = self.wallet.getLink(linkName, required=True)
ha = link.getRemoteEndpoint(required=True)
self.endpoint.connectIfNotConnected(
name=link.name,
ha=ha,
verKeyRaw=friendlyToRaw(link.remoteVerkey)
if link.remoteVerkey else None,
publicKeyRaw=friendlyToRaw(
link.remotePubKey)) if link.remotePubKey else None
def __init__(self, identifier, verkey=None, rawVerkey=None):
self.abbreviated = None
if (verkey is None or verkey == '') and (rawVerkey is None or rawVerkey == ''):
if identifier:
self._identifier = identifier
if (verkey is None and rawVerkey is None):
self._verkey = None
else:
self._verkey = ''
return
if not ((verkey or rawVerkey) and not (verkey and rawVerkey)):
raise ValueError(
"Both verkey {} and rawVerkey {} can't be specified"
.format(verkey, rawVerkey)
)
if identifier:
self._identifier = identifier
if rawVerkey:
self._verkey = rawToFriendly(rawVerkey)
self.abbreviated = False
else:
if verkey.startswith("~"):
self._verkey = verkey[1:]
self.abbreviated = True
else:
self._verkey = verkey
self.abbreviated = False
else:
verraw = rawVerkey or friendlyToRaw(verkey)
self._identifier = rawToFriendly(verraw[:16])
self._verkey = rawToFriendly(verraw[16:])
self.abbreviated = True
def __init__(self, identifier, verkey=None, rawVerkey=None):
self.abbreviated = None
if (verkey is None or verkey == '') and (rawVerkey is None
or rawVerkey == ''):
if identifier:
self._identifier = identifier
if (verkey is None and rawVerkey is None):
self._verkey = None
else:
self._verkey = ''
return
if not ((verkey or rawVerkey) and not (verkey and rawVerkey)):
raise ValueError(
"Both verkey {} and rawVerkey {} can't be specified".format(
verkey, rawVerkey))
if identifier:
self._identifier = identifier
if rawVerkey:
self._verkey = rawToFriendly(rawVerkey)
self.abbreviated = False
else:
if verkey.startswith("~"):
self._verkey = verkey[1:]
self.abbreviated = True
else:
self._verkey = verkey
self.abbreviated = False
else:
verraw = rawVerkey or friendlyToRaw(verkey)
self._identifier = rawToFriendly(verraw[:16])
self._verkey = rawToFriendly(verraw[16:])
self.abbreviated = True
def __init__(self, identifier, verkey=None, rawVerkey=None):
self.abbreviated = None
if (verkey is None or verkey == '') and (rawVerkey is None
or rawVerkey == ''):
if identifier:
self._identifier = identifier
if (verkey is None and rawVerkey is None):
self._verkey = None
else:
self._verkey = ''
return
assert (verkey or rawVerkey) and not (verkey and rawVerkey)
if identifier:
self._identifier = identifier
if rawVerkey:
self._verkey = rawToFriendly(rawVerkey)
self.abbreviated = False
else:
if verkey.startswith("~"):
self._verkey = verkey[1:]
self.abbreviated = True
else:
self._verkey = verkey
self.abbreviated = False
else:
verraw = rawVerkey or friendlyToRaw(verkey)
self._identifier = rawToFriendly(verraw[:16])
self._verkey = rawToFriendly(verraw[16:])
self.abbreviated = True
def testSendGetNymFailsIfDestIsPassedInHexFormat(looper, sdk_pool_handle,
sdk_wallet_trustee):
# Sometimes hex representation can use only base58 compatible characters
while True:
uuidIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
hexEncodedUuidIdentifier = hexlify(
friendlyToRaw(uuidIdentifier)).decode()
if not check_str_is_base58_compatible(hexEncodedUuidIdentifier):
break
sdk_add_new_nym(looper,
sdk_pool_handle,
sdk_wallet_trustee,
dest=uuidIdentifier,
verkey=abbrevVerkey)
_, s_did = sdk_wallet_trustee
get_nym_req = looper.loop.run_until_complete(
build_get_nym_request(s_did, uuidIdentifier))
get_nym_req = modify_field(get_nym_req, hexEncodedUuidIdentifier,
IDENTIFIER)
req = sdk_sign_and_send_prepared_request(looper, sdk_wallet_trustee,
sdk_pool_handle, get_nym_req)
with pytest.raises(RequestNackedException) as e:
sdk_get_and_check_replies(looper, [req])
e.match('should not contain the following chars')
def connectTo(self, linkName=None, link=None):
assert linkName or link
if link is None:
link = self.wallet.getLink(linkName, required=True)
ha = link.getRemoteEndpoint(required=True)
verKeyRaw = friendlyToRaw(link.full_remote_verkey) if link.full_remote_verkey else None
publicKeyRaw = friendlyToRaw(link.remotePubkey) if link.remotePubkey else None
if verKeyRaw is None and publicKeyRaw is None:
raise InvalidLinkException("verkey or publicKey is required for connection.")
if publicKeyRaw is None:
publicKeyRaw = rawVerkeyToPubkey(verKeyRaw)
self.endpoint.connectIfNotConnected(
name=link.name,
ha=ha,
verKeyRaw=verKeyRaw,
publicKeyRaw=publicKeyRaw)
def connectTo(self, linkName=None, link=None):
assert linkName or link
if link is None:
link = self.wallet.getLink(linkName, required=True)
ha = link.getRemoteEndpoint(required=True)
verKeyRaw = friendlyToRaw(link.full_remote_verkey) if link.full_remote_verkey else None
publicKeyRaw = friendlyToRaw(link.remotePubkey) if link.remotePubkey else None
if verKeyRaw is None and publicKeyRaw is None:
raise InvalidLinkException("verkey or publicKey is required for connection.")
if publicKeyRaw is None:
publicKeyRaw = rawVerkeyToPubkey(verKeyRaw)
self.endpoint.connectIfNotConnected(
name=link.name,
ha=ha,
verKeyRaw=verKeyRaw,
publicKeyRaw=publicKeyRaw)
def __init__(self, identifier, verkey=None, rawVerkey=None):
assert (verkey or rawVerkey) and not (verkey and rawVerkey)
if identifier:
self._identifier = identifier
self._verkey = verkey or rawToFriendly(rawVerkey)
self.abbreviated = False
else:
verraw = rawVerkey or friendlyToRaw(verkey)
self._identifier = rawToFriendly(verraw[:16])
self._verkey = rawToFriendly(verraw[16:])
self.abbreviated = True
def test_signer_compatable():
seed = b'Falcon00000000000000000000000000'
s_signer = SimpleSigner(seed=seed)
did_signer = DidSigner(seed=seed)
assert friendlyToRaw(s_signer.identifier).startswith(friendlyToRaw(did_signer.identifier))
if did_signer.abbreviated:
verkey = friendlyToRaw(did_signer.identifier)
verkey += friendlyToRaw(did_signer.verkey[1:])
else:
verkey = friendlyToRaw(did_signer.verkey)
assert friendlyToRaw(s_signer.verkey) == verkey
assert friendlyToRaw(s_signer.verkey) == friendlyToRaw(did_signer.full_verkey)
def test_signer_compatable():
seed = b'Falcon00000000000000000000000000'
s_signer = SimpleSigner(seed=seed)
did_signer = DidSigner(seed=seed)
assert friendlyToRaw(s_signer.identifier).startswith(
friendlyToRaw(did_signer.identifier))
if did_signer.abbreviated:
verkey = friendlyToRaw(did_signer.identifier)
verkey += friendlyToRaw(did_signer.verkey[1:])
else:
verkey = friendlyToRaw(did_signer.verkey)
assert friendlyToRaw(s_signer.verkey) == verkey
assert friendlyToRaw(s_signer.verkey) == friendlyToRaw(
did_signer.full_verkey)
def testSendGetNymFailsIfDestIsPassedInHexFormat(be, do, poolNodesStarted,
trusteeCli):
uuidIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
addNym(be, do, trusteeCli, idr=uuidIdentifier, verkey=abbrevVerkey)
hexEncodedUuidIdentifier = hexlify(friendlyToRaw(uuidIdentifier)).decode()
parameters = {'dest': hexEncodedUuidIdentifier}
be(trusteeCli)
do('send GET_NYM dest={dest}',
mapper=parameters,
expect="should not contain the following chars",
within=2)
def testSendGetNymFailsIfDestIsPassedInHexFormat(
be, do, poolNodesStarted, trusteeCli):
uuidIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
addNym(be, do, trusteeCli, idr=uuidIdentifier, verkey=abbrevVerkey)
hexEncodedUuidIdentifier = hexlify(friendlyToRaw(uuidIdentifier)).decode()
parameters = {
'dest': hexEncodedUuidIdentifier
}
be(trusteeCli)
do('send GET_NYM dest={dest}',
mapper=parameters, expect="should not contain the following chars", within=2)
def testSendAttribFailsIfDestIsPassedInHexFormat(be, do, poolNodesStarted,
trusteeCli):
uuidIdentifier = createUuidIdentifier()
addNym(be, do, trusteeCli, idr=uuidIdentifier)
hexEncodedUuidIdentifier = hexlify(friendlyToRaw(uuidIdentifier)).decode()
parameters = {
'dest': hexEncodedUuidIdentifier,
'raw': json.dumps({'name': 'Alice'})
}
be(trusteeCli)
do('send ATTRIB dest={dest} raw={raw}',
mapper=parameters,
expect=ERROR,
within=2)
def testSendAttribFailsIfDestIsPassedInHexFormat(
be, do, poolNodesStarted, trusteeCli):
uuidIdentifier = createUuidIdentifier()
addNym(be, do, trusteeCli, idr=uuidIdentifier)
hexEncodedUuidIdentifier = hexlify(friendlyToRaw(uuidIdentifier)).decode()
parameters = {
'dest': hexEncodedUuidIdentifier,
'raw': json.dumps({
'name': 'Alice'
})
}
be(trusteeCli)
do('send ATTRIB dest={dest} raw={raw}',
mapper=parameters, expect=ERROR, within=2)
def testSendGetNymFailsIfDestIsPassedInHexFormat(be, do, poolNodesStarted,
trusteeCli):
# Sometimes hex representation can use only base58 compatible characters
while True:
uuidIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
hexEncodedUuidIdentifier = hexlify(
friendlyToRaw(uuidIdentifier)).decode()
if not check_str_is_base58_compatible(hexEncodedUuidIdentifier):
break
addNym(be, do, trusteeCli, idr=uuidIdentifier, verkey=abbrevVerkey)
parameters = {'dest': hexEncodedUuidIdentifier}
be(trusteeCli)
do('send GET_NYM dest={dest}',
mapper=parameters,
expect="should not contain the following chars",
within=2)
def testSendGetNymFailsIfDestIsPassedInHexFormat(
be, do, poolNodesStarted, trusteeCli):
# Sometimes hex representation can use only base58 compatible characters
while True:
uuidIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
hexEncodedUuidIdentifier = hexlify(
friendlyToRaw(uuidIdentifier)).decode()
if not check_str_is_base58_compatible(hexEncodedUuidIdentifier):
break
addNym(be, do, trusteeCli, idr=uuidIdentifier, verkey=abbrevVerkey)
parameters = {
'dest': hexEncodedUuidIdentifier
}
be(trusteeCli)
do('send GET_NYM dest={dest}',
mapper=parameters,
expect="should not contain the following chars",
within=2)
def friendlyVerkeyToPubkey(verkey):
vkRaw = friendlyToRaw(verkey)
pkraw = ed25519PkToCurve25519(vkRaw)
return rawToFriendly(pkraw)
def friendlyVerkeyToPubkey(verkey):
vkRaw = friendlyToRaw(verkey)
pkraw = ed25519PkToCurve25519(vkRaw)
return rawToFriendly(pkraw)
