Merge pull request #299 from anikitinDSR/rc-1.0.2

[RC-1.0.2] Release candidate for plugins

Author: ashcherbakov

devops/Makefile

@@ -53,7 +53,7 @@ ifeq ($(SRC_DIR_NAME),sovtoken)
 # 	pypi: indy-plenum
 # 	apt: indy-plenum (stable component)
 
-FPM_P_DEPENDS := indy-node(=1.9.1)
+FPM_P_DEPENDS := indy-node(=1.9.2~rc1)
 FPM_ARGS := --no-python-dependencies $(FPM_ARGS)
 endif
 

devops/docker/ci/xenial/Dockerfile

@@ -25,8 +25,8 @@ RUN apt-key adv --keyserver keyserver.ubuntu.com --recv-keys CE7709D068DB5E88 \
 RUN add-apt-repository "deb https://repo.sovrin.org/sdk/deb xenial master" \
     && apt-get update && apt-get install -y \
         libindy-crypto=0.4.5 \
-        libindy=1.9.0~1132 \
-        libsovtoken=0.9.7~66 \
+        libindy=1.11.0~1282 \
+        libsovtoken=1.0.0~79 \
     && rm -rf /var/lib/apt/lists/*
 
 RUN mkdir -p /etc/indy && echo "ENABLED_PLUGINS = ['sovtoken', 'sovtokenfees']" > /etc/indy/indy_config.py \

sovtoken/setup.py

@@ -19,7 +19,7 @@
 with open(os.path.join(here, 'sovtoken', '__metadata__.py'), 'r') as f:
     exec(f.read(), metadata)
 
-tests_require = ['pytest==4.6.2', 'pytest-xdist', 'mock', 'python3-indy==1.10.0-dev-1198']
+tests_require = ['pytest==4.6.2', 'pytest-xdist', 'mock', 'python3-indy==1.11.0-dev-1282']
 
 setup(
     name=metadata['__title__'],
@@ -38,7 +38,7 @@
              '*.css', '*.ico', '*.png', 'LICENSE', 'LEGAL', 'sovtoken']},
     include_package_data=True,
 
-    install_requires=['indy-node==1.9.1'],
+    install_requires=['indy-node==1.9.2rc1'],
 
     setup_requires=['pytest-runner'],
     extras_require={

sovtoken/sovtoken/client_authnr.py

@@ -1,16 +1,13 @@
-from copy import deepcopy
-
 import base58
 from base58 import b58decode
 
 from common.serializers.serialization import serialize_msg_for_signing
-from plenum.common.constants import TXN_TYPE, IDENTIFIER
-from plenum.common.exceptions import (CouldNotAuthenticate,
-                                      InsufficientCorrectSignatures,
+from indy_node.server.client_authn import LedgerBasedAuthNr
+from plenum.common.constants import TXN_TYPE
+from plenum.common.exceptions import (InsufficientCorrectSignatures,
                                       InvalidSignatureFormat)
 from plenum.common.types import OPERATION, PLUGIN_TYPE_AUTHENTICATOR, f
 from plenum.common.verifier import DidVerifier, Verifier
-from plenum.server.client_authn import CoreAuthNr
 from sovtoken.constants import (ADDRESS, INPUTS, MINT_PUBLIC, OUTPUTS, SIGS,
                                 XFER_PUBLIC, EXTRA)
 from sovtoken.util import address_to_verkey
@@ -26,7 +23,7 @@ def verify(self, sig, msg) -> bool:
         return self._vr.verify(sig, msg)
 
 
-class TokenAuthNr(CoreAuthNr):
+class TokenAuthNr(LedgerBasedAuthNr):
     pluginType = PLUGIN_TYPE_AUTHENTICATOR
 
     # ------------------------------------------------------------------------------------

sovtoken/sovtoken/main.py

@@ -100,5 +100,5 @@ def register_authentication(node):
     token_authnr = TokenAuthNr(ACCEPTABLE_WRITE_TYPES,
                                ACCEPTABLE_QUERY_TYPES,
                                ACCEPTABLE_ACTION_TYPES,
-                               node.states[DOMAIN_LEDGER_ID])
+                               node.db_manager.idr_cache)
     node.clientAuthNr.register_authenticator(token_authnr)

sovtoken/sovtoken/test/helpers/helper_request.py

@@ -4,7 +4,7 @@
 from indy.ledger import build_nym_request, build_schema_request, \
     build_acceptance_mechanisms_request, build_txn_author_agreement_request, \
     build_get_txn_author_agreement_request, append_txn_author_agreement_acceptance_to_request
-from indy.payment import build_get_payment_sources_request, build_payment_req, build_mint_req, \
+from indy.payment import build_get_payment_sources_with_from_request, build_payment_req, build_mint_req, \
     prepare_payment_extra_with_acceptance_data
 from sovtoken.test.constants import VALID_IDENTIFIER
 
@@ -44,17 +44,13 @@ def __init__(
         self._client_wallet = client_wallet
         self._steward_wallet = steward_wallet
 
-    def get_utxo(self, address, from_seqno=None):
+    def get_utxo(self, address, from_seqno=-1):
         """ Builds a get_utxo request. """
 
-        get_utxo_request_future = build_get_payment_sources_request(self._client_wallet_handle, VALID_IDENTIFIER, address)
+        get_utxo_request_future = build_get_payment_sources_with_from_request(self._client_wallet_handle, VALID_IDENTIFIER, address, from_seqno)
         get_utxo_request = self._looper.loop.run_until_complete(get_utxo_request_future)[0]
         get_utxo_request = self._sdk.sdk_json_to_request_object(json.loads(get_utxo_request))
 
-        # TODO: as soon as SDK gets implemented "from", remove this two lines and pass it to the builder
-        if from_seqno:
-            get_utxo_request.operation[FROM_SEQNO] = from_seqno
-
         return get_utxo_request
 
     def get_txn(self, ledger_id, seq_no):
@@ -92,15 +88,15 @@ def add_transaction_author_agreement_to_request(self, request, text, mechanism,
         extra = self._looper.loop.run_until_complete(extra_future)
         return extra
 
-    def mint(self, outputs, text=None, mechanism=None, version=None):
+    def mint(self, outputs, text=None, mechanism=None, version=None, number_signers=3):
         """ Builds a mint request. """
         outputs_ready = self._prepare_outputs(outputs)
 
         mint_request_future = build_mint_req(self._client_wallet_handle, self._wallet._trustees[0], json.dumps(outputs_ready), None)
         mint_request = self._looper.loop.run_until_complete(mint_request_future)[0]
         if text and mechanism and version:
             mint_request = self.add_transaction_author_agreement_to_request(mint_request, text, mechanism, version)
-        mint_request = self._wallet.sign_request_trustees(mint_request, number_signers=3)
+        mint_request = self._wallet.sign_request_trustees(mint_request, number_signers=number_signers)
         mint_request = json.loads(mint_request)
         signatures = mint_request["signatures"]
         mint_request = self._sdk.sdk_json_to_request_object(mint_request)

sovtoken/sovtoken/test/req_handlers/mint_req_handler/test_mint_req_handler_dynamic_validation.py

@@ -9,7 +9,7 @@ def test_mint_handler_dynamic_validation_valid_request(mint_handler, mint_reques
 
 
 def test_mint_handler_dynamic_validation_not_enough_signatures(mint_handler, mint_request):
-    mint_request.signatures = dict([(k, v) for k, v in mint_request.signatures.items()][:-1])
+    mint_request.signatures = {mint_request.identifier: mint_request.signatures[mint_request.identifier]}
     with pytest.raises(UnauthorizedClientRequest, match='Not enough TRUSTEE signatures'):
         mint_handler.dynamic_validation(mint_request)
 

sovtoken/sovtoken/test/test_client_authnr.py

@@ -8,10 +8,8 @@
 from sovtoken.test.helpers.helper_request import SEC_PER_DAY
 
 from indy_common.types import Request
-from plenum.common.constants import DOMAIN_LEDGER_ID
-from plenum.common.exceptions import UnknownIdentifier, InvalidSignatureFormat, InsufficientCorrectSignatures, \
-    CouldNotAuthenticate
-from plenum.server.client_authn import CoreAuthNr
+from indy_node.server.client_authn import LedgerBasedAuthNr
+from plenum.common.exceptions import UnknownIdentifier, InvalidSignatureFormat, InsufficientCorrectSignatures
 from sovtoken.test.wallet import TokenWallet
 from sovtoken.client_authnr import TokenAuthNr, AddressSigVerifier
 from sovtoken.constants import INPUTS, OUTPUTS, EXTRA, ACCEPTABLE_WRITE_TYPES, ACCEPTABLE_QUERY_TYPES, \
@@ -118,7 +116,7 @@ def test_authenticate_invalid_signatures_format(helpers, node, addresses):
     token_authnr = TokenAuthNr(ACCEPTABLE_WRITE_TYPES,
                                ACCEPTABLE_QUERY_TYPES,
                                ACCEPTABLE_ACTION_TYPES,
-                               node[0].states[DOMAIN_LEDGER_ID])
+                               node[0].db_manager.idr_cache)
     outputs = [{"address": SF_address, "amount": 30}, {"address": user1_address, "amount": 30}]
     request = helpers.request.mint(outputs)
     req_data = request.as_dict
@@ -137,7 +135,7 @@ def test_authenticate_insufficient_valid_signatures_data(helpers, node, addresse
     token_authnr = TokenAuthNr(ACCEPTABLE_WRITE_TYPES,
                                ACCEPTABLE_QUERY_TYPES,
                                ACCEPTABLE_ACTION_TYPES,
-                               node[0].states[DOMAIN_LEDGER_ID])
+                               node[0].db_manager.idr_cache)
     outputs = [{"address": SF_address, "amount": 30}, {"address": user1_address, "amount": 30}]
     request = helpers.request.mint(outputs)
     req_data = request.as_dict
@@ -153,7 +151,7 @@ def test_authenticate_success_3_sigs(helpers, node, addresses):
     token_authnr = TokenAuthNr(ACCEPTABLE_WRITE_TYPES,
                                ACCEPTABLE_QUERY_TYPES,
                                ACCEPTABLE_ACTION_TYPES,
-                               node[0].states[DOMAIN_LEDGER_ID])
+                               node[0].db_manager.idr_cache)
     outputs = [{"address": SF_address, "amount": 30}, {"address": user1_address, "amount": 30}]
     request = helpers.request.mint(outputs)
     req_data = request.as_dict
@@ -167,7 +165,7 @@ def test_authenticate_calls_authenticate_xfer(helpers, node, addresses):
     token_authnr = TokenAuthNr(ACCEPTABLE_WRITE_TYPES,
                                ACCEPTABLE_QUERY_TYPES,
                                ACCEPTABLE_ACTION_TYPES,
-                               node[0].states[DOMAIN_LEDGER_ID])
+                               node[0].db_manager.idr_cache)
     inputs = [{"source": utxo_from_addr_and_seq_no(SF_address, 1)}]
     outputs = [{"address": user1_address, "amount": 10}, {"address": SF_address, "amount": 10}]
     request = helpers.request.transfer(inputs, outputs)
@@ -185,7 +183,7 @@ def test_authenticate_xfer_success(node, user2_token_wallet, user2_address, user
     token_authnr = TokenAuthNr(ACCEPTABLE_WRITE_TYPES,
                                ACCEPTABLE_QUERY_TYPES,
                                ACCEPTABLE_ACTION_TYPES,
-                               node[0].states[DOMAIN_LEDGER_ID])
+                               node[0].db_manager.idr_cache)
     inputs = [[user2_token_wallet, user2_address, 1]]
     outputs = [{"address": user1_address, "amount": 10}, {"address": user2_address, "amount": 10}]
     request = xfer_request(inputs, outputs)
@@ -199,7 +197,7 @@ def test_authenticate_xfer_invalid_signature_format(node, user2_token_wallet, us
     token_authnr = TokenAuthNr(ACCEPTABLE_WRITE_TYPES,
                                ACCEPTABLE_QUERY_TYPES,
                                ACCEPTABLE_ACTION_TYPES,
-                               node[0].states[DOMAIN_LEDGER_ID])
+                               node[0].db_manager.idr_cache)
     inputs = [[user2_token_wallet, user2_address, 1]]
     outputs = [[user1_address, 10], [user2_address, 10]]
     request = xfer_request(inputs, outputs)
@@ -215,7 +213,7 @@ def test_authenticate_xfer_insufficient_correct_signatures(node, user2_token_wal
     token_authnr = TokenAuthNr(ACCEPTABLE_WRITE_TYPES,
                                ACCEPTABLE_QUERY_TYPES,
                                ACCEPTABLE_ACTION_TYPES,
-                               node[0].states[DOMAIN_LEDGER_ID])
+                               node[0].db_manager.idr_cache)
     inputs = [[user2_token_wallet, user2_address, 1], [SF_token_wallet, SF_address, 2]]
     outputs = [[user1_address, 10], [user2_address, 10]]
     request = xfer_request(inputs, outputs)
@@ -232,7 +230,7 @@ def test_authenticate_xfer_with_extra(helpers, node, addresses):
     token_authnr = TokenAuthNr(ACCEPTABLE_WRITE_TYPES,
                                ACCEPTABLE_QUERY_TYPES,
                                ACCEPTABLE_ACTION_TYPES,
-                               node[0].states[DOMAIN_LEDGER_ID])
+                               node[0].db_manager.idr_cache)
     inputs = [{"source": utxo_from_addr_and_seq_no(SF_address, 1)}]
     outputs = [{"address": user1_address, "amount": 10}, {"address": SF_address, "amount": 10}]
     request = helpers.request.transfer(inputs, outputs, extra=json.dumps({"aaa": "bbb"}))
@@ -246,7 +244,7 @@ def test_authenticate_xfer_with_extra_not_signed(helpers, node, addresses):
     token_authnr = TokenAuthNr(ACCEPTABLE_WRITE_TYPES,
                                ACCEPTABLE_QUERY_TYPES,
                                ACCEPTABLE_ACTION_TYPES,
-                               node[0].states[DOMAIN_LEDGER_ID])
+                               node[0].db_manager.idr_cache)
     inputs = [{"source": utxo_from_addr_and_seq_no(SF_address, 1)}]
     outputs = [{"address": user1_address, "amount": 10}, {"address": SF_address, "amount": 10}]
     request = helpers.request.transfer(inputs, outputs)
@@ -262,7 +260,7 @@ def test_authenticate_xfer_with_taa(helpers, node, addresses):
     token_authnr = TokenAuthNr(ACCEPTABLE_WRITE_TYPES,
                                ACCEPTABLE_QUERY_TYPES,
                                ACCEPTABLE_ACTION_TYPES,
-                               node[0].states[DOMAIN_LEDGER_ID])
+                               node[0].db_manager.idr_cache)
     inputs = [{"source": utxo_from_addr_and_seq_no(SF_address, 1)}]
     outputs = [{"address": user1_address, "amount": 10}, {"address": SF_address, "amount": 10}]
     extra = helpers.request.add_transaction_author_agreement_to_extra(None, "text", "mechanism", "version")
@@ -276,7 +274,7 @@ def test_authenticate_xfer_with_taa_not_signed(helpers, node, addresses, looper)
     token_authnr = TokenAuthNr(ACCEPTABLE_WRITE_TYPES,
                                ACCEPTABLE_QUERY_TYPES,
                                ACCEPTABLE_ACTION_TYPES,
-                               node[0].states[DOMAIN_LEDGER_ID])
+                               node[0].db_manager.idr_cache)
     inputs = [{"source": utxo_from_addr_and_seq_no(SF_address, 1)}]
     outputs = [{"address": user1_address, "amount": 10}, {"address": SF_address, "amount": 10}]
     request = helpers.request.transfer(inputs, outputs)
@@ -295,13 +293,13 @@ def test_authenticate_xfer_with_taa_not_signed(helpers, node, addresses, looper)
 # -------------------------Test serializeForSig method------------------------------------------------------------------
 
 # This test that the serializeForSig method is being called when a XFER_PUBLIC request is submitted
-@mock.patch.object(CoreAuthNr, 'serializeForSig', return_value=True)
+@mock.patch.object(LedgerBasedAuthNr, 'serializeForSig', return_value=True)
 def test_serializeForSig_XFER_PUBLIC_path(node, user2_token_wallet, user2_address,
                                           SF_token_wallet, SF_address, user1_address):
     token_authnr = TokenAuthNr(ACCEPTABLE_WRITE_TYPES,
                                ACCEPTABLE_QUERY_TYPES,
                                ACCEPTABLE_ACTION_TYPES,
-                               node[0].states[DOMAIN_LEDGER_ID])
+                               node[0].db_manager.idr_cache)
     inputs = [[user2_token_wallet, user2_address, 1], [SF_token_wallet, SF_address, 2]]
     outputs = [[user1_address, 10], [user1_address, 10]]
     request = xfer_request(inputs, outputs)
@@ -311,13 +309,13 @@ def test_serializeForSig_XFER_PUBLIC_path(node, user2_token_wallet, user2_addres
 
 
 # This test that the serializeForSig method is being called when a MINT_PUBLIC request is submitted
-@mock.patch.object(CoreAuthNr, 'serializeForSig')
+@mock.patch.object(LedgerBasedAuthNr, 'serializeForSig')
 def test_serializeForSig_MINT_PUBLIC_path(helpers, node, addresses):
     [SF_address, user1_address] = addresses
     token_authnr = TokenAuthNr(ACCEPTABLE_WRITE_TYPES,
                                ACCEPTABLE_QUERY_TYPES,
                                ACCEPTABLE_ACTION_TYPES,
-                               node[0].states[DOMAIN_LEDGER_ID])
+                               node[0].db_manager.idr_cache)
     outputs = [[SF_address, 30], [user1_address, 30]]
     request = helpers.request.mint(outputs)
     msg = request.as_dict
@@ -333,7 +331,7 @@ def test_getVerkey_success(node):
     token_authnr = TokenAuthNr(ACCEPTABLE_WRITE_TYPES,
                                ACCEPTABLE_QUERY_TYPES,
                                ACCEPTABLE_ACTION_TYPES,
-                               node[0].states[DOMAIN_LEDGER_ID])
+                               node[0].db_manager.idr_cache)
     ver_key = token_authnr.getVerkey(VALID_IDENTIFIER, Request())
     assert len(ver_key) == 23
     assert ver_key[0] == '~'
@@ -344,7 +342,7 @@ def test_getVerkey_pay_address_success(node):
     token_authnr = TokenAuthNr(ACCEPTABLE_WRITE_TYPES,
                                ACCEPTABLE_QUERY_TYPES,
                                ACCEPTABLE_ACTION_TYPES,
-                               node[0].states[DOMAIN_LEDGER_ID])
+                               node[0].db_manager.idr_cache)
     # TODO change these to indicate they are addresses
     identifier_43 = 'sjw1ceG7wtym3VcnyaYtf1xo37gCUQHDR5VWcKWNPLRZ1X8eC'
     ver_key = token_authnr.getVerkey(identifier_43, Request())
@@ -356,7 +354,7 @@ def test_getVerkey_invalid_identifier(node):
     token_authnr = TokenAuthNr(ACCEPTABLE_WRITE_TYPES,
                                ACCEPTABLE_QUERY_TYPES,
                                ACCEPTABLE_ACTION_TYPES,
-                               node[0].states[DOMAIN_LEDGER_ID])
+                               node[0].db_manager.idr_cache)
     identifier_invalid = 'INVALID_IDENTIFIER'
     with pytest.raises(UnknownIdentifier):
         token_authnr.getVerkey(identifier_invalid, Request())
@@ -370,7 +368,7 @@ def test_get_xfer_ser_data_success(node, user2_token_wallet, user2_address,
     token_authnr = TokenAuthNr(ACCEPTABLE_WRITE_TYPES,
                                ACCEPTABLE_QUERY_TYPES,
                                ACCEPTABLE_ACTION_TYPES,
-                               node[0].states[DOMAIN_LEDGER_ID])
+                               node[0].db_manager.idr_cache)
     inputs = [[user2_token_wallet, user2_address, 1], [SF_token_wallet, SF_address, 2]]
     outputs = [[user1_address, 10], [user1_address, 10]]
     request = xfer_request(inputs, outputs)

sovtoken/sovtoken/test/test_get_utxo_state_proof.py

@@ -0,0 +1,48 @@
+from random import randint
+
+import pytest
+from plenum.test.stasher import delay_rules
+from plenum.test.delayers import req_delay
+from sovtoken.constants import UTXO_LIMIT, TOKEN_LEDGER_ID
+from sovtoken.request_handlers.token_utils import TokenStaticHelper
+from sovtoken.test.helper import libsovtoken_address_to_address
+
+
+@pytest.fixture
+def addresses(helpers):
+    return helpers.wallet.create_new_addresses(2)
+
+
+@pytest.fixture(scope='function')
+def make_tokens(helpers, nodeSetWithIntegratedTokenPlugin, addresses):
+    address, address_2 = addresses
+    states = [n.db_manager.get_state(TOKEN_LEDGER_ID) for n in nodeSetWithIntegratedTokenPlugin]
+    utxos = []
+
+    for i in range(UTXO_LIMIT+200):
+        amount = randint(1, 5)
+        seq_no = i+5
+        key = TokenStaticHelper.create_state_key(libsovtoken_address_to_address(address), seq_no)
+        utxos.append((key, amount, seq_no))
+        for state in states:
+            state.set(key, str(amount).encode())
+
+    total = 1000
+    outputs = [{"address": address_2, "amount": total}]
+    helpers.general.do_mint(outputs)
+
+
+@pytest.fixture(scope='function', params=['all_responding', 'one_responding'])
+def nodeSetWithOneRespondingNode(request, nodeSetWithIntegratedTokenPlugin, make_tokens):
+    if request.param == 'all_responding':
+        yield nodeSetWithIntegratedTokenPlugin
+    else:
+        stashers = [node.clientIbStasher for node in nodeSetWithIntegratedTokenPlugin[1:]]
+        with delay_rules(stashers, req_delay()):
+            yield nodeSetWithIntegratedTokenPlugin
+
+
+def test_state_proof_get_utxo_read(helpers, addresses, make_tokens, nodeSetWithOneRespondingNode):
+    address, _ = addresses
+    request = helpers.request.get_utxo(address)
+    helpers.sdk.send_and_check_request_objects([request])