Merge pull request #2826 from lbryio/fix_not_channel_ids

`claim_search --not_channel_ids` excludes the channel itself and not just claims in the channel

lbry/testcase.py

@@ -549,7 +549,7 @@ class CommandTestCase(IntegrationTestCase):
         )
 
     async def resolve(self, uri):
-        return await self.out(self.daemon.jsonrpc_resolve(uri))
+        return (await self.out(self.daemon.jsonrpc_resolve(uri)))[uri]
 
     async def claim_search(self, **kwargs):
         return (await self.out(self.daemon.jsonrpc_claim_search(**kwargs)))['items']

lbry/wallet/server/db/reader.py

@@ -291,6 +291,7 @@ def claims_query(cols, for_count=False, **constraints) -> Tuple[str, Dict]:
             not_channel_ids_binary = {
                 unhexlify(ncid)[::-1] for ncid in not_channel_ids
             }
+            constraints['claim.claim_hash__not_in#not_channel_ids'] = not_channel_ids_binary
             if constraints.get('has_channel_signature', False):
                 constraints['claim.channel_hash__not_in'] = not_channel_ids_binary
             else:

tests/integration/blockchain/test_claim_commands.py

@@ -263,6 +263,7 @@ class ClaimSearchCommand(ClaimTestCase):
         chan1_id = self.get_claim_id(await self.channel_create('@chan1'))
         chan2_id = self.get_claim_id(await self.channel_create('@chan2'))
         chan3_id = self.get_claim_id(await self.channel_create('@chan3'))
+        chan4 = await self.channel_create('@chan4', '0.1')
 
         claim1 = await self.stream_create('claim1')
         claim2 = await self.stream_create('claim2', channel_id=chan1_id)
@@ -285,6 +286,7 @@ class ClaimSearchCommand(ClaimTestCase):
         await match([claim6, claim5, claim4, claim1],                 not_channel_ids=[chan1_id], claim_type='stream')
         await match([claim6, claim3, claim2, claim1],                 not_channel_ids=[chan2_id], claim_type='stream')
         await match([claim6, claim1],                       not_channel_ids=[chan1_id, chan2_id], claim_type='stream')
+        await match([claim6, claim1, chan4],                not_channel_ids=[chan1_id, chan2_id])
 
         # not_channel_ids + valid_channel_signature
         await match([claim5, claim4, claim3, claim2, claim1],
@@ -858,25 +860,29 @@ class StreamCommands(ClaimTestCase):
         self.assertEqual(search['reposted_claim']['meta']['reposted'], 2)
         self.assertEqual(search['reposted_claim']['signing_channel']['name'], '@goodies')
 
-        resolved = await self.resolve(['@reposting-goodies/repost-on-channel', 'newstuff-again'])
+        resolved = await self.out(
+            self.daemon.jsonrpc_resolve(['@reposting-goodies/repost-on-channel', 'newstuff-again'])
+        )
         self.assertEqual(resolved['@reposting-goodies/repost-on-channel'], search)
         self.assertEqual(resolved['newstuff-again']['reposted_claim']['name'], 'newstuff')
 
     async def test_filtering_channels_for_removing_content(self):
-        await self.channel_create('@some_channel', '1.0')
+        await self.channel_create('@some_channel', '0.1')
-        await self.stream_create('good_content', '1.1', channel_name='@some_channel', tags=['good'])
+        await self.stream_create('good_content', '0.1', channel_name='@some_channel', tags=['good'])
         bad_content_id = self.get_claim_id(
-            await self.stream_create('bad_content', '1.1', channel_name='@some_channel', tags=['bad'])
+            await self.stream_create('bad_content', '0.1', channel_name='@some_channel', tags=['bad'])
         )
         filtering_channel_id = self.get_claim_id(
-            await self.channel_create('@filtering', '1.0')
+            await self.channel_create('@filtering', '0.1')
         )
         self.conductor.spv_node.server.db.sql.filtering_channel_hashes.add(
             unhexlify(filtering_channel_id)[::-1]
         )
-        await self.stream_repost(bad_content_id, 'filter1', '1.1', channel_name='@filtering')
+        self.assertEqual(0, len(self.conductor.spv_node.server.db.sql.filtered_streams))
+        await self.stream_repost(bad_content_id, 'filter1', '0.1', channel_name='@filtering')
+        self.assertEqual(1, len(self.conductor.spv_node.server.db.sql.filtered_streams))
 
-        # search for blocked content directly
+        # search for filtered content directly
         result = await self.out(self.daemon.jsonrpc_claim_search(name='bad_content'))
         blocked = result['blocked']
         self.assertEqual([], result['items'])
@@ -885,40 +891,84 @@ class StreamCommands(ClaimTestCase):
         self.assertEqual(1, blocked['channels'][0]['blocked'])
         self.assertTrue(blocked['channels'][0]['channel']['short_url'].startswith('lbry://@filtering#'))
 
-        # search channel containing blocked content
+        # search inside channel containing filtered content
         result = await self.out(self.daemon.jsonrpc_claim_search(channel='@some_channel'))
-        blocked = result['blocked']
+        filtered = result['blocked']
         self.assertEqual(1, len(result['items']))
-        self.assertEqual(1, blocked['total'])
+        self.assertEqual(1, filtered['total'])
-        self.assertEqual(1, len(blocked['channels']))
+        self.assertEqual(1, len(filtered['channels']))
-        self.assertEqual(1, blocked['channels'][0]['blocked'])
+        self.assertEqual(1, filtered['channels'][0]['blocked'])
-        self.assertTrue(blocked['channels'][0]['channel']['short_url'].startswith('lbry://@filtering#'))
+        self.assertTrue(filtered['channels'][0]['channel']['short_url'].startswith('lbry://@filtering#'))
 
         # content was filtered by not_tag before censoring
         result = await self.out(self.daemon.jsonrpc_claim_search(channel='@some_channel', not_tags=["good", "bad"]))
         self.assertEqual(0, len(result['items']))
         self.assertEqual({"channels": [], "total": 0}, result['blocked'])
 
+        # filtered content can still be resolved
+        result = await self.resolve('lbry://@some_channel/bad_content')
+        self.assertEqual(bad_content_id, result['claim_id'])
+
         blocking_channel_id = self.get_claim_id(
-            await self.channel_create('@blocking', '1.0')
+            await self.channel_create('@blocking', '0.1')
         )
         self.conductor.spv_node.server.db.sql.blocking_channel_hashes.add(
             unhexlify(blocking_channel_id)[::-1]
         )
-
+        self.assertEqual(0, len(self.conductor.spv_node.server.db.sql.blocked_streams))
-        # filtered content can still be resolved
+        await self.stream_repost(bad_content_id, 'block1', '0.1', channel_name='@blocking')
-        result = await self.out(self.daemon.jsonrpc_resolve('lbry://@some_channel/bad_content'))
+        self.assertEqual(1, len(self.conductor.spv_node.server.db.sql.blocked_streams))
-        self.assertEqual(bad_content_id, result['lbry://@some_channel/bad_content']['claim_id'])
-
-        await self.stream_repost(bad_content_id, 'block1', '1.1', channel_name='@blocking')
 
         # blocked content is not resolveable
-        result = await self.out(self.daemon.jsonrpc_resolve('lbry://@some_channel/bad_content'))
+        error = (await self.resolve('lbry://@some_channel/bad_content'))['error']
-        error = result['lbry://@some_channel/bad_content']['error']
         self.assertEqual(error['name'], 'BLOCKED')
         self.assertTrue(error['text'].startswith("Resolve of 'lbry://@some_channel/bad_content' was censored"))
         self.assertTrue(error['censor']['short_url'].startswith('lbry://@blocking#'))
 
+        # a filtered/blocked channel impacts all content inside it
+        bad_channel_id = self.get_claim_id(
+            await self.channel_create('@bad_channel', '0.1', tags=['bad-stuff'])
+        )
+        worse_content_id = self.get_claim_id(
+            await self.stream_create('worse_content', '0.1', channel_name='@bad_channel', tags=['bad-stuff'])
+        )
+
+        # check search before filtering channel
+        result = await self.out(self.daemon.jsonrpc_claim_search(any_tags=['bad-stuff'], order_by=['height']))
+        self.assertEqual(2, result['total_items'])
+        self.assertEqual('worse_content', result['items'][0]['name'])
+        self.assertEqual('@bad_channel', result['items'][1]['name'])
+
+        # filter channel out
+        self.assertEqual(0, len(self.conductor.spv_node.server.db.sql.filtered_channels))
+        await self.stream_repost(bad_channel_id, 'filter2', '0.1', channel_name='@filtering')
+        self.assertEqual(1, len(self.conductor.spv_node.server.db.sql.filtered_channels))
+
+        # same claim search as previous now returns 0 results
+        result = await self.out(self.daemon.jsonrpc_claim_search(any_tags=['bad-stuff'], order_by=['height']))
+        filtered = result['blocked']
+        self.assertEqual(0, len(result['items']))
+        self.assertEqual(2, filtered['total'])
+        self.assertEqual(1, len(filtered['channels']))
+        self.assertEqual(2, filtered['channels'][0]['blocked'])
+        self.assertTrue(filtered['channels'][0]['channel']['short_url'].startswith('lbry://@filtering#'))
+
+        # filtered channel should still resolve
+        result = await self.resolve('lbry://@bad_channel')
+        self.assertEqual(bad_channel_id, result['claim_id'])
+        result = await self.resolve('lbry://@bad_channel/worse_content')
+        self.assertEqual(worse_content_id, result['claim_id'])
+
+        # block channel
+        self.assertEqual(0, len(self.conductor.spv_node.server.db.sql.blocked_channels))
+        await self.stream_repost(bad_channel_id, 'block2', '0.1', channel_name='@blocking')
+        self.assertEqual(1, len(self.conductor.spv_node.server.db.sql.blocked_channels))
+
+        # channel, claim in channel or claim individually no longer resolve
+        self.assertEqual((await self.resolve('lbry://@bad_channel'))['error']['name'], 'BLOCKED')
+        self.assertEqual((await self.resolve('lbry://worse_content'))['error']['name'], 'BLOCKED')
+        self.assertEqual((await self.resolve('lbry://@bad_channel/worse_content'))['error']['name'], 'BLOCKED')
+
     async def test_publish_updates_file_list(self):
         tx = await self.stream_create(title='created')
         txo = tx['outputs'][0]
@@ -1374,15 +1424,14 @@ class StreamCommands(ClaimTestCase):
         self.assertItemCount(await self.daemon.jsonrpc_file_list(), 2)
         r = await self.resolve('lbry://@abc/foo')
         self.assertEqual(
-            r['lbry://@abc/foo']['claim_id'],
+            r['claim_id'],
             self.get_claim_id(tx3)
         )
 
         # publishing again clears channel
         tx4 = await self.publish('foo', languages='uk-UA', tags=['Anime', 'anime '])
         self.assertItemCount(await self.daemon.jsonrpc_file_list(), 2)
-        r = await self.resolve('lbry://foo')
+        claim = await self.resolve('lbry://foo')
-        claim = r['lbry://foo']
         self.assertEqual(claim['txid'], tx4['outputs'][0]['txid'])
         self.assertNotIn('signing_channel', claim)
         self.assertEqual(claim['value']['languages'], ['uk-UA'])

tests/integration/blockchain/test_purchase_command.py

@@ -148,7 +148,7 @@ class PurchaseCommandTests(CommandTestCase):
 
         url = result[0]['canonical_url']
         resolve = await self.resolve(url)
-        self.assertEqual(result[0]['claim_id'], resolve[url]['purchase_receipt']['claim_id'])
+        self.assertEqual(result[0]['claim_id'], resolve['purchase_receipt']['claim_id'])
 
         self.assertItemCount(await self.daemon.jsonrpc_file_list(), 0)
         await self.daemon.jsonrpc_get('lbry://a')

tests/integration/blockchain/test_resolve_command.py

@@ -12,7 +12,7 @@ from lbry.crypto.base58 import Base58
 class BaseResolveTestCase(CommandTestCase):
 
     async def assertResolvesToClaimId(self, name, claim_id):
-        other = (await self.resolve(name))[name]
+        other = await self.resolve(name)
         if claim_id is None:
             self.assertIn('error', other)
             self.assertEqual(other['error']['name'], 'NOT_FOUND')
@@ -29,23 +29,20 @@ class ResolveCommand(BaseResolveTestCase):
 
         # resolving a channel @abc
         response = await self.resolve('lbry://@abc')
-        self.assertSetEqual({'lbry://@abc'}, set(response))
+        self.assertEqual(response['name'], '@abc')
-        self.assertEqual(response['lbry://@abc']['name'], '@abc')
+        self.assertEqual(response['value_type'], 'channel')
-        self.assertEqual(response['lbry://@abc']['value_type'], 'channel')
+        self.assertEqual(response['meta']['claims_in_channel'], 0)
-        self.assertEqual(response['lbry://@abc']['meta']['claims_in_channel'], 0)
 
         await self.stream_create('foo', '0.01', channel_id=channel_id)
         await self.stream_create('foo2', '0.01', channel_id=channel_id)
 
         # resolving a channel @abc with some claims in it
-        response['lbry://@abc']['confirmations'] += 2
+        response['confirmations'] += 2
-        response['lbry://@abc']['meta']['claims_in_channel'] = 2
+        response['meta']['claims_in_channel'] = 2
         self.assertEqual(response, await self.resolve('lbry://@abc'))
 
         # resolving claim foo within channel @abc
-        response = await self.resolve('lbry://@abc/foo')
+        claim = await self.resolve('lbry://@abc/foo')
-        self.assertSetEqual({'lbry://@abc/foo'}, set(response))
-        claim = response['lbry://@abc/foo']
         self.assertEqual(claim['name'], 'foo')
         self.assertEqual(claim['value_type'], 'stream')
         self.assertEqual(claim['signing_channel']['name'], '@abc')
@@ -60,13 +57,12 @@ class ResolveCommand(BaseResolveTestCase):
         )
 
         # resolving claim foo by itself
-        self.assertEqual(claim, (await self.resolve('lbry://foo'))['lbry://foo'])
+        self.assertEqual(claim, await self.resolve('lbry://foo'))
         # resolving from the given permanent url
-        permanent_url = response['lbry://@abc/foo']['permanent_url']
+        self.assertEqual(claim, await self.resolve(claim['permanent_url']))
-        self.assertEqual(claim, (await self.resolve(permanent_url))[permanent_url])
 
         # resolving multiple at once
-        response = await self.resolve(['lbry://foo', 'lbry://foo2'])
+        response = await self.out(self.daemon.jsonrpc_resolve(['lbry://foo', 'lbry://foo2']))
         self.assertSetEqual({'lbry://foo', 'lbry://foo2'}, set(response))
         claim = response['lbry://foo2']
         self.assertEqual(claim['name'], 'foo2')
@@ -81,7 +77,7 @@ class ResolveCommand(BaseResolveTestCase):
         # resolve handles invalid data
         await self.blockchain_claim_name("gibberish", hexlify(b"{'invalid':'json'}").decode(), "0.1")
         await self.generate(1)
-        response = await self.resolve("lbry://gibberish")
+        response = await self.out(self.daemon.jsonrpc_resolve("lbry://gibberish"))
         self.assertSetEqual({'lbry://gibberish'}, set(response))
         claim = response['lbry://gibberish']
         self.assertEqual(claim['name'], 'gibberish')
@@ -89,10 +85,10 @@ class ResolveCommand(BaseResolveTestCase):
 
         # resolve retries
         await self.conductor.spv_node.stop()
-        resolving_future = asyncio.ensure_future(self.resolve('foo'))
+        resolve_task = asyncio.create_task(self.resolve('foo'))
         await self.conductor.spv_node.start(self.conductor.blockchain_node)
         await self.ledger.on_ready.first
-        self.assertIsNotNone((await resolving_future)['foo']['claim_id'])
+        self.assertIsNotNone((await resolve_task)['claim_id'])
 
     async def test_winning_by_effective_amount(self):
         # first one remains winner unless something else changes
@@ -182,20 +178,18 @@ class ResolveCommand(BaseResolveTestCase):
 
         # Original channel doesn't exists anymore, so the signature is invalid. For invalid signatures, resolution is
         # only possible outside a channel
-        response = await self.resolve('lbry://@abc/on-channel-claim')
+        self.assertEqual(
-        self.assertEqual(response, {
+            {'error': {
-            'lbry://@abc/on-channel-claim': {
+                'name': 'NOT_FOUND',
-                'error': {
+                'text': 'Could not find claim at "lbry://@abc/on-channel-claim".',
-                    'name': 'NOT_FOUND',
+            }},
-                    'text': 'Could not find claim at "lbry://@abc/on-channel-claim".',
+            await self.resolve('lbry://@abc/on-channel-claim')
-                }
+        )
-            }
+        response = await self.resolve('lbry://on-channel-claim')
-        })
-        response = (await self.resolve('lbry://on-channel-claim'))['lbry://on-channel-claim']
         self.assertFalse(response['is_channel_signature_valid'])
         self.assertEqual({'channel_id': abandoned_channel_id}, response['signing_channel'])
         direct_uri = 'lbry://on-channel-claim#' + orphan_claim_id
-        response = (await self.resolve(direct_uri))[direct_uri]
+        response = await self.resolve(direct_uri)
         self.assertFalse(response['is_channel_signature_valid'])
         self.assertEqual({'channel_id': abandoned_channel_id}, response['signing_channel'])
         await self.stream_abandon(claim_id=orphan_claim_id)
@@ -205,7 +199,7 @@ class ResolveCommand(BaseResolveTestCase):
         valid_claim = await self.stream_create('on-channel-claim', '0.00000001', channel_id=channel['claim_id'])
         # resolves normally
         response = await self.resolve(uri)
-        self.assertTrue(response[uri]['is_channel_signature_valid'])
+        self.assertTrue(response['is_channel_signature_valid'])
 
         # ooops! claimed a valid conflict! (this happens on the wild, mostly by accident or race condition)
         await self.stream_create(
@@ -214,8 +208,8 @@ class ResolveCommand(BaseResolveTestCase):
 
         # it still resolves! but to the older claim
         response = await self.resolve(uri)
-        self.assertTrue(response[uri]['is_channel_signature_valid'])
+        self.assertTrue(response['is_channel_signature_valid'])
-        self.assertEqual(response[uri]['txid'], valid_claim['txid'])
+        self.assertEqual(response['txid'], valid_claim['txid'])
         claims = await self.claim_search(name='on-channel-claim')
         self.assertEqual(2, len(claims))
         self.assertEqual(
@@ -235,8 +229,8 @@ class ResolveCommand(BaseResolveTestCase):
         r1 = await self.resolve(f'lbry://{one}')
         r2 = await self.resolve(f'lbry://{two}')
 
-        self.assertEqual(winner_id, r1[f'lbry://{one}']['claim_id'])
+        self.assertEqual(winner_id, r1['claim_id'])
-        self.assertEqual(winner_id, r2[f'lbry://{two}']['claim_id'])
+        self.assertEqual(winner_id, r2['claim_id'])
 
     async def test_resolve_old_claim(self):
         channel = await self.daemon.jsonrpc_channel_create('@olds', '1.0')
@@ -249,7 +243,7 @@ class ResolveCommand(BaseResolveTestCase):
         await self.confirm_tx(tx.id)
 
         response = await self.resolve('@olds/example')
-        self.assertTrue(response['@olds/example']['is_channel_signature_valid'])
+        self.assertTrue(response['is_channel_signature_valid'])
 
         claim.publisherSignature.signature = bytes(reversed(claim.publisherSignature.signature))
         tx = await Transaction.claim_create(
@@ -260,16 +254,14 @@ class ResolveCommand(BaseResolveTestCase):
         await self.confirm_tx(tx.id)
 
         response = await self.resolve('bad_example')
-        self.assertFalse(response['bad_example']['is_channel_signature_valid'])
+        self.assertFalse(response['is_channel_signature_valid'])
-        response = await self.resolve('@olds/bad_example')
+        self.assertEqual(
-        self.assertEqual(response, {
+            {'error': {
-            '@olds/bad_example': {
+                'name': 'NOT_FOUND',
-                'error': {
+                'text': 'Could not find claim at "@olds/bad_example".',
-                    'name': 'NOT_FOUND',
+            }},
-                    'text': 'Could not find claim at "@olds/bad_example".',
+            await self.resolve('@olds/bad_example')
-                }
+        )
-            }
-        })
 
 
 class ResolveAfterReorg(BaseResolveTestCase):
@@ -289,36 +281,36 @@ class ResolveAfterReorg(BaseResolveTestCase):
         channel_id = self.get_claim_id(
             await self.channel_create(channel_name, '0.01')
         )
-        self.assertNotIn('error', (await self.resolve(channel_name))[channel_name])
+        self.assertNotIn('error', await self.resolve(channel_name))
         await self.reorg(206)
-        self.assertNotIn('error', (await self.resolve(channel_name))[channel_name])
+        self.assertNotIn('error', await self.resolve(channel_name))
 
         stream_name = 'foo'
         stream_id = self.get_claim_id(
             await self.stream_create(stream_name, '0.01', channel_id=channel_id)
         )
-        self.assertNotIn('error', (await self.resolve(stream_name))[stream_name])
+        self.assertNotIn('error', await self.resolve(stream_name))
         await self.reorg(206)
-        self.assertNotIn('error', (await self.resolve(stream_name))[stream_name])
+        self.assertNotIn('error', await self.resolve(stream_name))
 
         await self.support_create(stream_id, '0.01')
-        self.assertNotIn('error', (await self.resolve(stream_name))[stream_name])
+        self.assertNotIn('error', await self.resolve(stream_name))
         await self.reorg(206)
-        self.assertNotIn('error', (await self.resolve(stream_name))[stream_name])
+        self.assertNotIn('error', await self.resolve(stream_name))
 
         await self.stream_abandon(stream_id)
-        self.assertNotIn('error', (await self.resolve(channel_name))[channel_name])
+        self.assertNotIn('error', await self.resolve(channel_name))
-        self.assertIn('error', (await self.resolve(stream_name))[stream_name])
+        self.assertIn('error', await self.resolve(stream_name))
         await self.reorg(206)
-        self.assertNotIn('error', (await self.resolve(channel_name))[channel_name])
+        self.assertNotIn('error', await self.resolve(channel_name))
-        self.assertIn('error', (await self.resolve(stream_name))[stream_name])
+        self.assertIn('error', await self.resolve(stream_name))
 
         await self.channel_abandon(channel_id)
-        self.assertIn('error', (await self.resolve(channel_name))[channel_name])
+        self.assertIn('error', await self.resolve(channel_name))
-        self.assertIn('error', (await self.resolve(stream_name))[stream_name])
+        self.assertIn('error', await self.resolve(stream_name))
         await self.reorg(206)
-        self.assertIn('error', (await self.resolve(channel_name))[channel_name])
+        self.assertIn('error', await self.resolve(channel_name))
-        self.assertIn('error', (await self.resolve(stream_name))[stream_name])
+        self.assertIn('error', await self.resolve(stream_name))
 
 
 def generate_signed_legacy(address: bytes, output: Output):

tests/integration/other/test_chris45.py

@@ -40,7 +40,7 @@ class EpicAdventuresOfChris45(CommandTestCase):
 
         # And is the channel resolvable and empty?
         response = await self.resolve('lbry://@spam')
-        self.assertEqual(response['lbry://@spam']['value_type'], 'channel')
+        self.assertEqual(response['value_type'], 'channel')
 
         # "What goes well with spam?" ponders Chris...
         # "A hovercraft with eels!" he exclaims.
@@ -64,7 +64,7 @@ class EpicAdventuresOfChris45(CommandTestCase):
         # Also checks that his new story can be found on the blockchain before
         # giving the link to all his friends.
         response = await self.resolve('lbry://@spam/hovercraft')
-        self.assertEqual(response['lbry://@spam/hovercraft']['value_type'], 'stream')
+        self.assertEqual(response['value_type'], 'stream')
 
         # He goes to tell everyone about it and in the meantime 5 blocks are confirmed.
         await self.generate(5)
@@ -84,13 +84,12 @@ class EpicAdventuresOfChris45(CommandTestCase):
         await self.confirm_tx(abandon['txid'])
 
         # And now checks that the claim doesn't resolve anymore.
-        response = await self.resolve('lbry://@spam/hovercraft')
         self.assertEqual(
-            response['lbry://@spam/hovercraft'],
             {'error': {
                 'name': 'NOT_FOUND',
                 'text': 'Could not find claim at "lbry://@spam/hovercraft".'
-            }}
+            }},
+            await self.resolve('lbry://@spam/hovercraft')
         )
 
         # After abandoning he just waits for his LBCs to be returned to his account
@@ -140,8 +139,8 @@ class EpicAdventuresOfChris45(CommandTestCase):
         # And check if his support showed up
         resolve_result = await self.resolve(uri)
         # It obviously did! Because, blockchain baby \O/
-        self.assertEqual(resolve_result[uri]['amount'], '1.0')
+        self.assertEqual(resolve_result['amount'], '1.0')
-        self.assertEqual(resolve_result[uri]['meta']['effective_amount'], '1.2')
+        self.assertEqual(resolve_result['meta']['effective_amount'], '1.2')
         await self.generate(5)
 
         # Now he also wanted to support the original creator of the Award Winning Novel
@@ -154,7 +153,7 @@ class EpicAdventuresOfChris45(CommandTestCase):
         # And again checks if it went to the just right place
         resolve_result = await self.resolve(uri)
         # Which it obviously did. Because....?????
-        self.assertEqual(resolve_result[uri]['meta']['effective_amount'], '1.5')
+        self.assertEqual(resolve_result['meta']['effective_amount'], '1.5')
         await self.generate(5)
 
         # Seeing the ravishing success of his novel Chris adds support to his claim too
@@ -188,11 +187,10 @@ class EpicAdventuresOfChris45(CommandTestCase):
         await self.confirm_tx(abandon['txid'])
 
         # He them checks that the claim doesn't resolve anymore.
-        response = await self.resolve(uri)
         self.assertEqual(
-            response[uri],
             {'error': {
                 'name': 'NOT_FOUND',
                 'text': f'Could not find claim at "{uri}".'
-            }}
+            }},
+            await self.resolve(uri)
         )