def two_requests(looper, sdk_wallet_steward):
    wh, did = sdk_wallet_steward

    op = {TXN_TYPE: AUCTION_START, DATA: {'id': 'xyz'}}

    req1 = sdk_gen_request(op,
                           protocol_version=CURRENT_PROTOCOL_VERSION,
                           identifier=did).as_dict
    field = list(PLUGIN_CLIENT_REQUEST_FIELDS.keys())[0]
    req1[field] = 'x' * 10

    req2 = copy.deepcopy(req1)
    req2[field] = 'z' * 10

    req1 = sdk_multisign_request_object(looper, sdk_wallet_steward,
                                        json.dumps(req1))
    req_obj1 = Request(**json.loads(req1))

    req2 = sdk_multisign_request_object(looper, sdk_wallet_steward,
                                        json.dumps(req2))
    req_obj2 = Request(**json.loads(req2))

    assert req_obj1.payload_digest == req_obj2.payload_digest
    assert req_obj1.digest != req_obj2.digest
    return req1, req2
Beispiel #2
0
    def signRequest(self,
                    req: Request,
                    identifier: Identifier = None) -> Request:
        """
        Signs request. Modifies reqId and signature. May modify identifier.

        :param req: request
        :param requestIdStore: request id generator
        :param identifier: signer identifier
        :return: signed request
        """

        idr = self.requiredIdr(idr=identifier or req._identifier)
        # idData = self._getIdData(idr)
        req._identifier = idr
        req.reqId = req.gen_req_id()
        # req.digest = req.getDigest()
        # QUESTION: `self.ids[idr]` would be overwritten if same identifier
        # is used to send 2 requests, why is `IdData` persisted?
        # self.ids[idr] = IdData(idData.signer, req.reqId)
        req.signature = self.signMsg(msg=req.signingState(identifier=idr),
                                     identifier=idr,
                                     otherIdentifier=req.identifier)

        return req
def test_get_txn_response_as_expected(looper, steward1, stewardWallet):
    req, wallet = sendAddNewClient(STEWARD, "name", steward1, stewardWallet)

    timeout = waits.expectedTransactionExecutionTime(len(
        steward1.inBox)) + c_delay
    nym_response = \
        looper.run(eventually(check_sufficient_replies_received,
                              steward1, req.identifier, req.reqId,
                              retryWait=1, timeout=timeout))
    op = {
        TXN_TYPE: GET_TXN,
        f.LEDGER_ID.nm: DOMAIN_LEDGER_ID,
        DATA: nym_response['seqNo']
    }
    req = Request(identifier=stewardWallet.defaultId,
                  operation=op,
                  reqId=Request.gen_req_id(),
                  protocolVersion=CURRENT_PROTOCOL_VERSION)
    steward1.submitReqs(req)

    get_txn_response = \
        looper.run(eventually(check_sufficient_replies_received,
                              steward1, req.identifier, req.reqId,
                              retryWait=1, timeout=timeout))

    nym_response.pop('txnTime', None)
    get_txn_response[DATA].pop('txnTime', None)

    assert nym_response == get_txn_response[DATA]
Beispiel #4
0
def test_plugin_client_req_fields(txn_pool_node_set_post_creation, looper,
                                  stewardWallet, steward1, sdk_wallet_steward,
                                  sdk_pool_handle):
    """
    Test that plugin's addition of request fields and their validation is
    successful
    """
    op = {TXN_TYPE: GET_BAL, DATA: {'id': '123'}}

    # Valid field value results in successful processing
    req_obj = sdk_gen_request(
        op,
        identifier=sdk_wallet_steward[1],
        fix_length_dummy=randomString(dummy_field_length))
    req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
                                      sdk_wallet_steward, req_obj)
    sdk_get_reply(looper, req)

    # Invalid field value results in proper failure
    req = Request(operation=op,
                  reqId=Request.gen_req_id(),
                  protocolVersion=CURRENT_PROTOCOL_VERSION,
                  identifier=stewardWallet.defaultId,
                  fix_length_dummy=randomString(dummy_field_length + 1))
    steward1.submitReqs(req)
    for node in txn_pool_node_set_post_creation:
        looper.run(
            eventually(checkReqNackWithReason,
                       steward1,
                       'should have length',
                       node.clientstack.name,
                       retryWait=1))
Beispiel #5
0
    def signRequest(self,
                    req: Request,
                    identifier: Identifier=None) -> Request:
        """
        Signs request. Modifies reqId and signature. May modify identifier.

        :param req: request
        :param requestIdStore: request id generator
        :param identifier: signer identifier
        :return: signed request
        """

        idr = self.requiredIdr(idr=identifier or req._identifier)
        # idData = self._getIdData(idr)
        req._identifier = idr
        req.reqId = req.gen_req_id()
        # req.digest = req.getDigest()
        # QUESTION: `self.ids[idr]` would be overwritten if same identifier
        # is used to send 2 requests, why is `IdData` persisted?
        # self.ids[idr] = IdData(idData.signer, req.reqId)
        req.signature = self.signMsg(msg=req.signingState(identifier=idr),
                                     identifier=idr,
                                     otherIdentifier=req.identifier)

        return req
Beispiel #6
0
 def sign_using_output(self,
                       id,
                       seq_no,
                       op: Dict = None,
                       request: Request = None):
     assert lxor(op, request)
     if op:
         request = Request(reqId=Request.gen_req_id(),
                           operation=op,
                           protocolVersion=CURRENT_PROTOCOL_VERSION)
     # existing_inputs = request.operation.get(INPUTS, [])
     # request.operation[INPUTS] = [[id, seq_no], ]
     # payload = deepcopy(request.signingState(id))
     # # TEMPORARY
     # payload[OPERATION].pop(SIGS)
     # payload.pop(f.IDENTIFIER.nm)
     #
     # signature = self.addresses[id].signer.sign(payload)
     # request.operation[INPUTS] = existing_inputs + [[id, seq_no], ]
     # TODO: Account for `extra` field
     payload = [[
         {
             "address": id,
             "seqNo": seq_no
         },
     ], request.operation[OUTPUTS]]
     signature = self.addresses[id].signer.sign(payload)
     request.operation[INPUTS] = request.operation.get(INPUTS, []) + [
         {
             "address": id,
             "seqNo": seq_no
         },
     ]
     request.operation[SIGS].append(signature)
     return request
Beispiel #7
0
 def _create_request(self, payload, identifier=None):
     return Request(
         reqId=Request.gen_req_id(),
         operation=payload,
         protocolVersion=CURRENT_PROTOCOL_VERSION,
         identifier=identifier
     )
def test_static_validation(get_txn_author_agreement_aml_handler):
    request = Request(operation={TXN_TYPE: GET_TXN_AUTHOR_AGREEMENT_AML,
                                 GET_TXN_AUTHOR_AGREEMENT_AML_VERSION: "VERSION"})
    get_txn_author_agreement_aml_handler.static_validation(request)

    request = Request(operation={TXN_TYPE: GET_TXN_AUTHOR_AGREEMENT_AML,
                                 GET_TXN_AUTHOR_AGREEMENT_AML_TIMESTAMP: 1559299045})
    get_txn_author_agreement_aml_handler.static_validation(request)
Beispiel #9
0
 def evilCreatePropagate(self,
                         request: Request, identifier: str) -> Propagate:
     logger.debug("EVIL: Creating propagate request for client request {}".
                  format(request))
     request.operation["amount"] += random.random()
     request._digest = request.getDigest()
     if isinstance(identifier, bytes):
         identifier = identifier.decode()
     return Propagate(request.as_dict, identifier)
 def evilCreatePropagate(self,
                         request: Request, identifier: str) -> Propagate:
     logger.debug("EVIL: Creating propagate request for client request {}".
                  format(request))
     request.operation["amount"] = random.randint(10, 100000)
     request._digest = request.digest
     if isinstance(identifier, bytes):
         identifier = identifier.decode()
     return Propagate(request.as_dict, identifier)
Beispiel #11
0
 def sign_using_multi_sig(self, op: Dict=None, request: Request=None,
                          identifier=None) -> Request:
     # One and only 1 of `op` and `request` must be provided.
     # If `request` is provided it must have `reqId`
     assert lxor(op, request)
     identifier = identifier or self.defaultId
     if op:
         request = Request(reqId=Request.gen_req_id(), operation=op,
                           protocolVersion=CURRENT_PROTOCOL_VERSION)
     self.do_multi_sig_on_req(request, identifier)
     return request
def test_get_txn_for_invalid_ledger_id(looper, txnPoolNodeSet, steward1,
                                       stewardWallet):
    op = {TXN_TYPE: GET_TXN, f.LEDGER_ID.nm: 5908, DATA: 1}
    req = Request(identifier=stewardWallet.defaultId,
                  operation=op,
                  reqId=Request.gen_req_id(),
                  protocolVersion=CURRENT_PROTOCOL_VERSION)
    steward1.submitReqs(req)
    for node in txnPoolNodeSet:
        waitReqNackWithReason(looper, steward1, 'expected one of',
                              node.clientstack.name)
def test_get_txn_for_invalid_seq_no(looper, txnPoolNodeSet, steward1,
                                    stewardWallet):
    op = {TXN_TYPE: GET_TXN, f.LEDGER_ID.nm: DOMAIN_LEDGER_ID, DATA: -23}
    req = Request(identifier=stewardWallet.defaultId,
                  operation=op,
                  reqId=Request.gen_req_id(),
                  protocolVersion=CURRENT_PROTOCOL_VERSION)
    steward1.submitReqs(req)
    for node in txnPoolNodeSet:
        waitReqNackWithReason(looper, steward1, 'cannot be smaller',
                              node.clientstack.name)
def requests():
    def _getDigest(req: Request):
        return sha256(req.identifier.encode())

    requests = Requests()

    req = Request("1")
    req.getDigest = functools.partial(_getDigest, req)
    requests.add(req)

    assert len(requests) == 1
    return requests, req.key
def requests():
    def _getDigest(req: Request):
        return sha256(req.identifier.encode())

    requests = Requests()
    for id in req_identifiers:
        req = Request(id)
        req.getDigest = functools.partial(_getDigest, req)
        requests.add(req)

    assert len(requests) == 3
    return requests
Beispiel #16
0
def requests():
    def _getDigest(req: Request):
        return sha256(req.identifier.encode())

    requests = Requests()
    for id in req_identifiers:
        req = Request(id)
        req.getDigest = functools.partial(_getDigest, req)
        requests.add(req)

    assert len(requests) == 3
    return requests
def two_requests(looper, op, sdk_wallet_stewards):
    wh, did = sdk_wallet_stewards[0]

    req = json.dumps(sdk_gen_request(op, protocol_version=CURRENT_PROTOCOL_VERSION,
                                     identifier=did).as_dict)
    req1 = sdk_multisign_request_object(looper, sdk_wallet_stewards[0], req)
    req_obj1 = Request(**json.loads(req1))

    req2 = sdk_multisign_request_object(looper, sdk_wallet_stewards[1], req1)
    req_obj2 = Request(**json.loads(req2))

    assert req_obj1.payload_digest == req_obj2.payload_digest
    assert req_obj1.digest != req_obj2.digest
    return req1, req2
Beispiel #18
0
def reqToTxn(req):
    """
    Transform a client request such that it can be stored in the ledger.
    Also this is what will be returned to the client in the reply
    :param req:
    :return:
    """
    if isinstance(req, str):
        req = json.loads(req)
    if isinstance(req, dict):
        req = Request(identifier=req.get(f.IDENTIFIER.nm, None),
                      reqId=req.get(f.REQ_ID.nm, None),
                      operation=req.get(OPERATION, None),
                      signature=req.get(f.SIG.nm, None),
                      signatures=req.get(f.SIGS.nm, None),
                      protocolVersion=req.get(f.PROTOCOL_VERSION.nm, None))
    if isinstance(req, Request):
        req_data = req.as_dict
        req_data[f.DIGEST.nm] = req.digest
    else:
        raise TypeError("Expected dict or str as input, but got: {}".format(
            type(req)))

    req_data = deepcopy(req_data)
    return do_req_to_txn(req_data=req_data, req_op=req_data[OPERATION])
Beispiel #19
0
def revoc_reg_entry_request():
    return Request(identifier=randomString(),
                   reqId=5,
                   operation={
                       'type': REVOC_REG_ENTRY,
                       REVOC_REG_DEF_ID: 'sample'
                   })
Beispiel #20
0
def testSendGetTxnReqSameAsExpected(looper, steward1, stewardWallet):
    req, wallet = sendAddNewClient(STEWARD, "name", steward1, stewardWallet)

    timeout = waits.expectedTransactionExecutionTime(len(
        steward1.inBox)) + c_delay
    nym_response = looper.run(
        eventually(checkSufficientRepliesReceived,
                   steward1.inBox,
                   req.reqId,
                   fValue,
                   retryWait=1,
                   timeout=timeout))

    op = {TXN_TYPE: GET_TXN, DATA: nym_response['seqNo']}
    req = Request(identifier=stewardWallet.defaultId,
                  operation=op,
                  reqId=getTimeBasedId())
    steward1.submitReqs(req)

    get_txn_response = looper.run(
        eventually(checkSufficientRepliesReceived,
                   steward1.inBox,
                   req.reqId,
                   fValue,
                   retryWait=1,
                   timeout=timeout))
    get_txn_response = json.loads(get_txn_response[DATA])

    del nym_response['txnTime']
    del get_txn_response['txnTime']

    assert nym_response == get_txn_response
Beispiel #21
0
 def isFinalised(self, f):
     if self.finalised is None:
         req = checkIfMoreThanFSameItems([v.__getstate__() for v in
                                          self.propagates.values()], f)
         if req:
             self.finalised = Request.fromState(req)
     return self.finalised
def node():
    n = FakeSomething()
    n.new_future_primaries_needed = False
    n.requests = {
        'a':
        ReqState(
            Request(
                operation={
                    TARGET_NYM: 'nym7',
                    TXN_TYPE: NODE,
                    DATA: {
                        SERVICES: ['VALIDATOR'],
                        ALIAS: 'n7'
                    }
                }))
    }
    n.nodeReg = {'n1': 1, 'n2': 1, 'n3': 1, 'n4': 1, 'n5': 1, 'n6': 1}
    n.primaries = ['n1', 'n2']
    n.nodeIds = n.nodeReg
    n.primaries_selector = FakeSomething()
    n.primaries_selector.select_primaries = lambda view_no, instance_count, validators: [
        'n1', 'n2'
    ]
    n.viewNo = 0
    return n
def get_auth_rule_request(creator):
    return Request(identifier=creator,
                   reqId=5,
                   operation={
                       TXN_TYPE: GET_AUTH_RULE,
                       **generate_key()
                   })
def taa_disable_request(tconf, domain_state):
    identifier = "identifier"
    update_nym(domain_state, identifier, TRUSTEE)
    operation = {TXN_TYPE: TXN_AUTHOR_AGREEMENT_DISABLE}
    return Request(identifier=identifier,
                   signature="sign",
                   operation=operation)
Beispiel #25
0
def test_suspicious_primary_send_same_request_with_same_signatures(
        looper, txnPoolNodeSet, sdk_pool_handle, two_requests,
        sdk_wallet_stewards, tconf):
    couple = sdk_send_random_and_check(looper, txnPoolNodeSet, sdk_pool_handle,
                                       sdk_wallet_stewards[0], 1)[0]
    req = Request(**couple[0])
    replica = getPrimaryReplica(txnPoolNodeSet)
    replica._ordering_service._do_dynamic_validation = types.MethodType(
        malicious_dynamic_validation, replica.node)

    txnPoolNodeSet.remove(replica.node)
    old_reverts = {}
    for i, node in enumerate(txnPoolNodeSet):
        old_reverts[i] = node.master_replica._ordering_service.spylog.count(
            OrderingService._revert)
        node.seqNoDB._keyValueStorage.remove(req.digest)
        node.seqNoDB._keyValueStorage.remove(req.payload_digest)

    ppReq = replica._ordering_service.create_3pc_batch(DOMAIN_LEDGER_ID)
    ppReq._fields['reqIdr'] = [req.digest, req.digest]
    replica._ordering_service.send_pre_prepare(ppReq)

    def reverts():
        for i, node in enumerate(txnPoolNodeSet):
            assert old_reverts[
                i] + 1 == node.master_replica._ordering_service.spylog.count(
                    OrderingService._revert)

    looper.run(eventually(reverts))
Beispiel #26
0
def test_static_validation_fail_context_is_list_with_dict_and_bad_uri():
    context = [{
        "favoriteColor": "https://example.com/vocab#favoriteColor"
    }, "this is a bad uri"]
    operation = {
        META: {
            "name": "TestContext",
            "version": 1,
            "type": CONTEXT_TYPE
        },
        DATA: {
            CONTEXT_CONTEXT: context
        },
        RS_TYPE: "200"
    }
    req = Request(
        "test",
        1,
        operation,
        "sig",
    )
    ch = ContextHandler(None, None)
    with pytest.raises(InvalidClientRequest) as e:
        ch.static_validation(req)
    assert "@context URI this is a bad uri badly formed" in str(e.value)
Beispiel #27
0
def sdk_gen_request(operation,
                    protocol_version=CURRENT_PROTOCOL_VERSION,
                    identifier=None):
    return Request(operation=operation,
                   reqId=random.randint(10, 100000),
                   protocolVersion=protocol_version,
                   identifier=identifier)
def test_future_primaries_replicas_increase(looper, txnPoolNodeSet, sdk_pool_handle,
                                            sdk_wallet_stewards, tdir, tconf, allPluginsPath):
    # Don't delete NodeStates, so we could check them.
    global old_commit
    old_commit = txnPoolNodeSet[0].write_manager.future_primary_handler.commit_batch
    for node in txnPoolNodeSet:
        node.write_manager.future_primary_handler.commit_batch = lambda three_pc_batch, prev_handler_result=None: 0

    initial_primaries = copy.copy(txnPoolNodeSet[0].primaries)
    last_ordered = txnPoolNodeSet[0].master_replica.last_ordered_3pc
    starting_view_number = checkViewNoForNodes(txnPoolNodeSet)

    # Increase replicas count
    add_new_node(looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_stewards[0], tdir, tconf, allPluginsPath)

    new_view_no = checkViewNoForNodes(txnPoolNodeSet)
    assert new_view_no == starting_view_number + 1
    # "seq_no + 2" because 1 domain and 1 pool txn.

    node = txnPoolNodeSet[0]
    with delay_rules(node.nodeIbStasher, cDelay()):
        req = sdk_send_random_and_check(looper, txnPoolNodeSet,
                                        sdk_pool_handle,
                                        sdk_wallet_stewards[0], 1)[0][0]
        req = Request(**req)
        three_pc_batch = ThreePcBatch(DOMAIN_LEDGER_ID, 0, 0, 1, time.time(),
                                      randomString(),
                                      randomString(),
                                      ['a', 'b', 'c'], [req.digest], pp_digest='')
        primaries = node.write_manager.future_primary_handler.post_batch_applied(three_pc_batch)
        assert len(primaries) == len(initial_primaries) + 1
        assert len(primaries) == len(node.primaries)
 def _req_to_txn(self, req: Request):
     sigs = req.operation.pop(SIGS)
     txn = super()._req_to_txn(req)
     req.operation[SIGS] = sigs
     sigs = [(i["address"], s) for i, s in zip(req.operation[INPUTS], sigs)]
     add_sigs_to_txn(txn, sigs, sig_type=ED25519)
     return txn
def auth_rules_request(creator):
    return Request(identifier=creator,
                   reqId=5,
                   operation={
                       TXN_TYPE: AUTH_RULES,
                       RULES: [generate_auth_rule()]
                   })
Beispiel #31
0
 def isFinalised(self, f):
     if self.finalised is None:
         req = checkIfMoreThanFSameItems([v.__getstate__() for v in
                                          self.propagates.values()], f)
         if req:
             self.finalised = Request.fromState(req)
     return self.finalised
def node():
    n = FakeSomething()
    n.new_future_primaries_needed = False
    n.requests = {
        'a':
        ReqState(
            Request(
                operation={
                    TARGET_NYM: 'nym7',
                    TXN_TYPE: NODE,
                    DATA: {
                        SERVICES: ['VALIDATOR'],
                        ALIAS: 'n7'
                    }
                }))
    }
    n.nodeReg = {'n1': 1, 'n2': 1, 'n3': 1, 'n4': 1, 'n5': 1, 'n6': 1}
    n.nodeIds = {
        'nym1': 'n1',
        'nym2': 'n2',
        'nym3': 'n3',
        'nym4': 'n4',
        'nym5': 'n5',
        'nym6': 'n6'
    }
    n.primaries = {'n1', 'n2'}
    n.elector = FakeSomething()
    n.elector.process_selection = lambda a, b, c: ['n1', 'n2']
    return n
Beispiel #33
0
def test_static_validation_pass_context_w3c_example_15():
    context = {
        "@context": {
            "referenceNumber": "https://example.com/vocab#referenceNumber",
            "favoriteFood": "https://example.com/vocab#favoriteFood"
        }
    }
    operation = {
        META: {
            "name": "TestContext",
            "version": 1,
            "type": CONTEXT_TYPE
        },
        DATA: {
            CONTEXT_CONTEXT: context
        },
        RS_TYPE: "200"
    }
    req = Request(
        "test",
        1,
        operation,
        "sig",
    )
    ch = ContextHandler(None, None)
    ch.static_validation(req)
def test_future_primaries_replicas_decrease(looper, txnPoolNodeSet, sdk_pool_handle,
                                            sdk_wallet_stewards, tdir, tconf, allPluginsPath):
    assert len(txnPoolNodeSet) == 7

    initial_primaries = copy.copy(txnPoolNodeSet[0].primaries)
    last_ordered = txnPoolNodeSet[0].master_replica.last_ordered_3pc
    starting_view_number = checkViewNoForNodes(txnPoolNodeSet)

    # Decrease replicas count
    demote_node(looper, sdk_wallet_stewards[-1], sdk_pool_handle, txnPoolNodeSet[-2])
    txnPoolNodeSet.remove(txnPoolNodeSet[-2])
    ensureElectionsDone(looper=looper, nodes=txnPoolNodeSet)

    new_view_no = checkViewNoForNodes(txnPoolNodeSet)
    assert new_view_no == starting_view_number + 1
    node = txnPoolNodeSet[0]
    with delay_rules(node.nodeIbStasher, cDelay()):
        req = sdk_send_random_and_check(looper, txnPoolNodeSet,
                                        sdk_pool_handle,
                                        sdk_wallet_stewards[0], 1)[0][0]
        req = Request(**req)
        three_pc_batch = ThreePcBatch(DOMAIN_LEDGER_ID, 0, 0, 1, time.time(),
                                      randomString(),
                                      randomString(),
                                      ['a', 'b', 'c'], [req.digest], pp_digest='')
        primaries = node.write_manager.future_primary_handler.post_batch_applied(three_pc_batch)
        assert len(primaries) + 1 == len(initial_primaries)
        assert len(primaries) == len(txnPoolNodeSet[0].primaries)

    for node in txnPoolNodeSet:
        node.write_manager.future_primary_handler.commit_batch = old_commit
Beispiel #35
0
def get_reply_identifier(result):
    if f.IDENTIFIER.nm in result:
        return result[f.IDENTIFIER.nm]
    elif TXN_PAYLOAD in result and TXN_PAYLOAD_METADATA in result[TXN_PAYLOAD] and \
            TXN_PAYLOAD_METADATA_FROM in result[TXN_PAYLOAD][TXN_PAYLOAD_METADATA]:
        return result[TXN_PAYLOAD][TXN_PAYLOAD_METADATA][TXN_PAYLOAD_METADATA_FROM]
    else:
        return Request.gen_idr_from_sigs(result.get(f.SIGS.nm, {}))
Beispiel #36
0
 def set_finalised(self, req):
     # TODO: make it much explicitly and simpler
     # !side affect! if `req` is an instance of a child of `Request` class
     # here we construct the parent from child it is rather implicit that
     # `finalised` contains not the same type than `propagates` has
     self.finalised = Request.fromState(req.__getstate__())
     self.added_ts = None
     self.finalised_ts = time.perf_counter()
Beispiel #37
0
 def sign_using_multi_sig(self, op: Dict=None, request: Request=None,
                          identifier=None) -> Request:
     # One and only 1 of `op` and `request` must be provided.
     # If `request` is provided it must have `reqId`
     assert lxor(op, request)
     identifier = identifier or self.defaultId
     if op:
         request = Request(reqId=Request.gen_req_id(), operation=op,
                           protocolVersion=CURRENT_PROTOCOL_VERSION)
     self.do_multi_sig_on_req(request, identifier)
     return request
 def deserializeReq(serReq: str) -> Request:
     return Request.fromState(json.loads(serReq))
def req_and_expected(request, looper, sdk_wallet_client):
    op = {'type': '1',
          'something': 'nothing'}
    if request.param.endswith('_sdk'):
        req = sdk_sign_request_from_dict(looper, sdk_wallet_client,
                                         op, reqId=1513945121191691)
        request.param = request.param[:-4]
        # TODO: support multi-sig in SDK
        # if request.param == 'sig_only':
        #     req.pop('signatures')
        # if request.param == 'sigs_only':
        #     req.pop('signature')
        if request.param == 'no_protocol_vers':
            req.pop('protocolVersion')
        digest = Request(
            req.get(f.IDENTIFIER.nm, None),
            req.get(f.REQ_ID.nm, None),
            req.get(OPERATION, None),
            req.get(f.SIG.nm, None),
            req.get(f.SIGS.nm, None),
            req.get(f.PROTOCOL_VERSION.nm, None)
        ).digest
        sign = req.get(f.SIG.nm)
    else:
        req = Request(operation=op, reqId=1513945121191691,
                      protocolVersion=CURRENT_PROTOCOL_VERSION, identifier="6ouriXMZkLeHsuXrN1X1fd")
        sign = "2DaRm3nt6H5fJu2TP5vxqbaDCtABPYmUTSX4ocnY8fVGgyJMVNaeh2z6JZhcW1gbmGKJcZopZMKZJwADuXFFJobM"
        req.signature = sign
        req.add_signature("6ouriXMZkLeHsuXrN1X1fd",
                          sign)
        if request.param == 'sig_only':
            req.signatures = None
        if request.param == 'sigs_only':
            req.signature = None
        if request.param == 'no_protocol_vers':
            req.protocolVersion = None
        digest = req.digest

    new_expected = SortedDict({
        "reqSignature": {
            "type": "ED25519",
            "values": [{
                "from": "6ouriXMZkLeHsuXrN1X1fd",
                "value": sign
            }]
        },
        "txn": {
            "data": {
                "something": "nothing",
            },

            "metadata": {
                "from": "6ouriXMZkLeHsuXrN1X1fd",
                "reqId": 1513945121191691
            },

            "protocolVersion": CURRENT_PROTOCOL_VERSION,
            "type": "1",
        },
        "txnMetadata": {
            "txnTime": 1513945121,
        },
        "ver": "1"

    })

    if request.param == 'no_protocol_vers':
        new_expected["txn"].pop("protocolVersion", None)
    if digest is not None:
        new_expected["txn"]["metadata"]["digest"] = digest

    return req, new_expected
Beispiel #40
0
 def do_multi_sig_on_req(self, request: Request, identifier: str):
     idr = self.requiredIdr(idr=identifier)
     signature = self.signMsg(msg=request.signingState(identifier),
                              identifier=idr)
     request.add_signature(idr, signature)
 def serializeReq(req: Request) -> str:
     return json.dumps(req.__getstate__())
Beispiel #42
0
def idr_from_req_data(data):
    if data.get(f.IDENTIFIER.nm):
        return data[f.IDENTIFIER.nm]
    else:
        return Request.gen_idr_from_sigs(data.get(f.SIGS.nm, {}))
 def evilCreatePropagate(self,
                         request: Request, clientName: str) -> Propagate:
     logger.debug("EVIL: Creating propagate request for client request {}".
                  format(request))
     request.operation["amount"] += random.random()
     return Propagate(request.__getstate__(), clientName)
 def applyForced(self, req: Request):
     if not req.isForced():
         raise LogicError('requestHandler.applyForce method is called '
                          'for not forced request: {}'.format(req))