forked from LBRYCommunity/lbry-sdk
1829 lines
92 KiB
Python
1829 lines
92 KiB
Python
import asyncio
|
||
import json
|
||
import hashlib
|
||
import sys
|
||
from bisect import bisect_right
|
||
from binascii import hexlify, unhexlify
|
||
from collections import defaultdict
|
||
from typing import NamedTuple, List
|
||
from lbry.testcase import CommandTestCase
|
||
from lbry.wallet.transaction import Transaction, Output
|
||
from lbry.schema.compat import OldClaimMessage
|
||
from lbry.crypto.hash import sha256
|
||
from lbry.crypto.base58 import Base58
|
||
|
||
|
||
class ClaimStateValue(NamedTuple):
|
||
claim_id: str
|
||
activation_height: int
|
||
active_in_lbrycrd: bool
|
||
|
||
|
||
class BaseResolveTestCase(CommandTestCase):
|
||
|
||
def assertMatchESClaim(self, claim_from_es, claim_from_db):
|
||
self.assertEqual(claim_from_es['claim_hash'][::-1].hex(), claim_from_db.claim_hash.hex())
|
||
self.assertEqual(claim_from_es['claim_id'], claim_from_db.claim_hash.hex())
|
||
self.assertEqual(claim_from_es['activation_height'], claim_from_db.activation_height, f"es height: {claim_from_es['activation_height']}, rocksdb height: {claim_from_db.activation_height}")
|
||
self.assertEqual(claim_from_es['last_take_over_height'], claim_from_db.last_takeover_height)
|
||
self.assertEqual(claim_from_es['tx_id'], claim_from_db.tx_hash[::-1].hex())
|
||
self.assertEqual(claim_from_es['tx_nout'], claim_from_db.position)
|
||
self.assertEqual(claim_from_es['amount'], claim_from_db.amount)
|
||
self.assertEqual(claim_from_es['effective_amount'], claim_from_db.effective_amount)
|
||
|
||
def assertMatchDBClaim(self, expected, claim):
|
||
self.assertEqual(expected['claimid'], claim.claim_hash.hex())
|
||
self.assertEqual(expected['validatheight'], claim.activation_height)
|
||
self.assertEqual(expected['lasttakeoverheight'], claim.last_takeover_height)
|
||
self.assertEqual(expected['txid'], claim.tx_hash[::-1].hex())
|
||
self.assertEqual(expected['n'], claim.position)
|
||
self.assertEqual(expected['amount'], claim.amount)
|
||
self.assertEqual(expected['effectiveamount'], claim.effective_amount)
|
||
|
||
async def assertResolvesToClaimId(self, name, claim_id):
|
||
other = await self.resolve(name)
|
||
if claim_id is None:
|
||
self.assertIn('error', other)
|
||
self.assertEqual(other['error']['name'], 'NOT_FOUND')
|
||
claims_from_es = (await self.conductor.spv_node.server.session_manager.search_index.search(name=name))[0]
|
||
claims_from_es = [c['claim_hash'][::-1].hex() for c in claims_from_es]
|
||
self.assertNotIn(claim_id, claims_from_es)
|
||
else:
|
||
claim_from_es = await self.conductor.spv_node.server.session_manager.search_index.search(claim_id=claim_id)
|
||
self.assertEqual(claim_id, other['claim_id'])
|
||
self.assertEqual(claim_id, claim_from_es[0][0]['claim_hash'][::-1].hex())
|
||
|
||
async def assertNoClaimForName(self, name: str):
|
||
lbrycrd_winning = json.loads(await self.blockchain._cli_cmnd('getclaimsforname', name))
|
||
stream, channel, _, _ = await self.conductor.spv_node.server.db.resolve(name)
|
||
if 'claims' in lbrycrd_winning and lbrycrd_winning['claims'] is not None:
|
||
self.assertEqual(len(lbrycrd_winning['claims']), 0)
|
||
if stream is not None:
|
||
self.assertIsInstance(stream, LookupError)
|
||
else:
|
||
self.assertIsInstance(channel, LookupError)
|
||
claim_from_es = await self.conductor.spv_node.server.session_manager.search_index.search(name=name)
|
||
self.assertListEqual([], claim_from_es[0])
|
||
|
||
async def assertNoClaim(self, name: str, claim_id: str):
|
||
expected = json.loads(await self.blockchain._cli_cmnd('getclaimsfornamebyid', name, '["' + claim_id + '"]'))
|
||
if 'claims' in expected and expected['claims'] is not None:
|
||
# ensure that if we do have the matching claim that it is not active
|
||
self.assertEqual(expected['claims'][0]['effectiveamount'], 0)
|
||
|
||
claim_from_es = await self.conductor.spv_node.server.session_manager.search_index.search(claim_id=claim_id)
|
||
self.assertListEqual([], claim_from_es[0])
|
||
claim = await self.conductor.spv_node.server.db.fs_getclaimbyid(claim_id)
|
||
self.assertIsNone(claim)
|
||
|
||
async def assertMatchWinningClaim(self, name):
|
||
expected = json.loads(await self.blockchain._cli_cmnd('getclaimsfornamebybid', name, "[0]"))
|
||
stream, channel, _, _ = await self.conductor.spv_node.server.db.resolve(name)
|
||
claim = stream if stream else channel
|
||
expected['claims'][0]['lasttakeoverheight'] = expected['lasttakeoverheight']
|
||
await self._assertMatchClaim(expected['claims'][0], claim)
|
||
return claim
|
||
|
||
async def _assertMatchClaim(self, expected, claim):
|
||
self.assertMatchDBClaim(expected, claim)
|
||
claim_from_es = await self.conductor.spv_node.server.session_manager.search_index.search(
|
||
claim_id=claim.claim_hash.hex()
|
||
)
|
||
self.assertEqual(len(claim_from_es[0]), 1)
|
||
self.assertMatchESClaim(claim_from_es[0][0], claim)
|
||
self._check_supports(claim.claim_hash.hex(), expected.get('supports', []),
|
||
claim_from_es[0][0]['support_amount'])
|
||
|
||
async def assertMatchClaim(self, name, claim_id, is_active_in_lbrycrd=True):
|
||
claim = await self.conductor.spv_node.server.db.fs_getclaimbyid(claim_id)
|
||
claim_from_es = await self.conductor.spv_node.server.session_manager.search_index.search(
|
||
claim_id=claim.claim_hash.hex()
|
||
)
|
||
self.assertEqual(len(claim_from_es[0]), 1)
|
||
self.assertEqual(claim_from_es[0][0]['claim_hash'][::-1].hex(), claim.claim_hash.hex())
|
||
self.assertMatchESClaim(claim_from_es[0][0], claim)
|
||
|
||
expected = json.loads(await self.blockchain._cli_cmnd('getclaimsfornamebyid', name, '["' + claim_id + '"]'))
|
||
if is_active_in_lbrycrd:
|
||
if not expected:
|
||
self.assertIsNone(claim)
|
||
return
|
||
expected['claims'][0]['lasttakeoverheight'] = expected['lasttakeoverheight']
|
||
self.assertMatchDBClaim(expected['claims'][0], claim)
|
||
self._check_supports(claim.claim_hash.hex(), expected['claims'][0].get('supports', []),
|
||
claim_from_es[0][0]['support_amount'])
|
||
else:
|
||
if 'claims' in expected and expected['claims'] is not None:
|
||
# ensure that if we do have the matching claim that it is not active
|
||
self.assertEqual(expected['claims'][0]['effectiveamount'], 0)
|
||
return claim
|
||
|
||
async def assertMatchClaimIsWinning(self, name, claim_id):
|
||
self.assertEqual(claim_id, (await self.assertMatchWinningClaim(name)).claim_hash.hex())
|
||
await self.assertMatchClaimsForName(name)
|
||
|
||
def _check_supports(self, claim_id, lbrycrd_supports, es_support_amount):
|
||
total_lbrycrd_amount = 0.0
|
||
total_es_amount = 0.0
|
||
active_es_amount = 0.0
|
||
db = self.conductor.spv_node.server.db
|
||
es_supports = db.get_supports(bytes.fromhex(claim_id))
|
||
|
||
# we're only concerned about active supports here, and they should match
|
||
self.assertTrue(len(es_supports) >= len(lbrycrd_supports))
|
||
|
||
for i, (tx_num, position, amount) in enumerate(es_supports):
|
||
total_es_amount += amount
|
||
valid_height = db.get_activation(tx_num, position, is_support=True)
|
||
if valid_height > db.db_height:
|
||
continue
|
||
active_es_amount += amount
|
||
txid = db.prefix_db.tx_hash.get(tx_num, deserialize_value=False)[::-1].hex()
|
||
support = next(filter(lambda s: s['txid'] == txid and s['n'] == position, lbrycrd_supports))
|
||
total_lbrycrd_amount += support['amount']
|
||
self.assertEqual(support['height'], bisect_right(db.tx_counts, tx_num))
|
||
self.assertEqual(support['validatheight'], valid_height)
|
||
|
||
self.assertEqual(total_es_amount, es_support_amount)
|
||
self.assertEqual(active_es_amount, total_lbrycrd_amount)
|
||
|
||
async def assertMatchClaimsForName(self, name):
|
||
expected = json.loads(await self.blockchain._cli_cmnd('getclaimsforname', name, "", "true"))
|
||
db = self.conductor.spv_node.server.db
|
||
|
||
for c in expected['claims']:
|
||
c['lasttakeoverheight'] = expected['lasttakeoverheight']
|
||
claim_id = c['claimid']
|
||
claim_hash = bytes.fromhex(claim_id)
|
||
claim = db._fs_get_claim_by_hash(claim_hash)
|
||
self.assertMatchDBClaim(c, claim)
|
||
|
||
claim_from_es = await self.conductor.spv_node.server.session_manager.search_index.search(
|
||
claim_id=claim_id
|
||
)
|
||
self.assertEqual(len(claim_from_es[0]), 1)
|
||
self.assertEqual(claim_from_es[0][0]['claim_hash'][::-1].hex(), claim_id)
|
||
self.assertMatchESClaim(claim_from_es[0][0], claim)
|
||
self._check_supports(claim_id, c.get('supports', []),
|
||
claim_from_es[0][0]['support_amount'])
|
||
|
||
async def assertNameState(self, height: int, name: str, winning_claim_id: str, last_takeover_height: int,
|
||
non_winning_claims: List[ClaimStateValue]):
|
||
self.assertEqual(height, self.conductor.spv_node.server.db.db_height)
|
||
await self.assertMatchClaimIsWinning(name, winning_claim_id)
|
||
for non_winning in non_winning_claims:
|
||
claim = await self.assertMatchClaim(
|
||
name, non_winning.claim_id, is_active_in_lbrycrd=non_winning.active_in_lbrycrd
|
||
)
|
||
self.assertEqual(non_winning.activation_height, claim.activation_height)
|
||
self.assertEqual(last_takeover_height, claim.last_takeover_height)
|
||
|
||
|
||
class ResolveCommand(BaseResolveTestCase):
|
||
async def test_colliding_short_id(self):
|
||
prefixes = defaultdict(list)
|
||
|
||
colliding_claim_ids = []
|
||
first_claims_one_char_shortid = {}
|
||
|
||
while True:
|
||
chan = self.get_claim_id(
|
||
await self.channel_create('@abc', '0.01', allow_duplicate_name=True)
|
||
)
|
||
if chan[:1] not in first_claims_one_char_shortid:
|
||
first_claims_one_char_shortid[chan[:1]] = chan
|
||
prefixes[chan[:2]].append(chan)
|
||
if len(prefixes[chan[:2]]) > 1:
|
||
colliding_claim_ids.extend(prefixes[chan[:2]])
|
||
break
|
||
first_claim = first_claims_one_char_shortid[colliding_claim_ids[0][:1]]
|
||
await self.assertResolvesToClaimId(
|
||
f'@abc#{colliding_claim_ids[0][:1]}', first_claim
|
||
)
|
||
collision_depth = 0
|
||
for c1, c2 in zip(colliding_claim_ids[0], colliding_claim_ids[1]):
|
||
if c1 == c2:
|
||
collision_depth += 1
|
||
else:
|
||
break
|
||
await self.assertResolvesToClaimId(f'@abc#{colliding_claim_ids[0][:2]}', colliding_claim_ids[0])
|
||
await self.assertResolvesToClaimId(f'@abc#{colliding_claim_ids[0][:7]}', colliding_claim_ids[0])
|
||
await self.assertResolvesToClaimId(f'@abc#{colliding_claim_ids[0][:17]}', colliding_claim_ids[0])
|
||
await self.assertResolvesToClaimId(f'@abc#{colliding_claim_ids[0]}', colliding_claim_ids[0])
|
||
await self.assertResolvesToClaimId(f'@abc#{colliding_claim_ids[1][:collision_depth + 1]}', colliding_claim_ids[1])
|
||
await self.assertResolvesToClaimId(f'@abc#{colliding_claim_ids[1][:7]}', colliding_claim_ids[1])
|
||
await self.assertResolvesToClaimId(f'@abc#{colliding_claim_ids[1][:17]}', colliding_claim_ids[1])
|
||
await self.assertResolvesToClaimId(f'@abc#{colliding_claim_ids[1]}', colliding_claim_ids[1])
|
||
|
||
async def test_abandon_channel_and_claims_in_same_tx(self):
|
||
channel_id = self.get_claim_id(
|
||
await self.channel_create('@abc', '0.01')
|
||
)
|
||
await self.stream_create('foo', '0.01', channel_id=channel_id)
|
||
await self.channel_update(channel_id, bid='0.001')
|
||
foo2_id = self.get_claim_id(await self.stream_create('foo2', '0.01', channel_id=channel_id))
|
||
await self.stream_update(foo2_id, bid='0.0001', channel_id=channel_id, confirm=False)
|
||
tx = await self.stream_create('foo3', '0.01', channel_id=channel_id, confirm=False, return_tx=True)
|
||
await self.ledger.wait(tx)
|
||
|
||
# db = self.conductor.spv_node.server.bp.db
|
||
# claims = list(db.all_claims_producer())
|
||
# print("claims", claims)
|
||
await self.daemon.jsonrpc_txo_spend(blocking=True)
|
||
await self.generate(1)
|
||
await self.assertNoClaimForName('@abc')
|
||
await self.assertNoClaimForName('foo')
|
||
await self.assertNoClaimForName('foo2')
|
||
await self.assertNoClaimForName('foo3')
|
||
|
||
async def test_resolve_response(self):
|
||
channel_id = self.get_claim_id(
|
||
await self.channel_create('@abc', '0.01')
|
||
)
|
||
|
||
# resolving a channel @abc
|
||
response = await self.resolve('lbry://@abc')
|
||
self.assertEqual(response['name'], '@abc')
|
||
self.assertEqual(response['value_type'], 'channel')
|
||
self.assertEqual(response['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['confirmations'] += 2
|
||
response['meta']['claims_in_channel'] = 2
|
||
self.assertEqual(response, await self.resolve('lbry://@abc'))
|
||
|
||
# resolving claim foo within channel @abc
|
||
claim = await self.resolve('lbry://@abc/foo')
|
||
self.assertEqual(claim['name'], 'foo')
|
||
self.assertEqual(claim['value_type'], 'stream')
|
||
self.assertEqual(claim['signing_channel']['name'], '@abc')
|
||
self.assertTrue(claim['is_channel_signature_valid'])
|
||
self.assertEqual(
|
||
claim['timestamp'],
|
||
self.ledger.headers.estimated_timestamp(claim['height'])
|
||
)
|
||
self.assertEqual(
|
||
claim['signing_channel']['timestamp'],
|
||
self.ledger.headers.estimated_timestamp(claim['signing_channel']['height'])
|
||
)
|
||
|
||
# resolving claim foo by itself
|
||
self.assertEqual(claim, await self.resolve('lbry://foo'))
|
||
# resolving from the given permanent url
|
||
self.assertEqual(claim, await self.resolve(claim['permanent_url']))
|
||
|
||
# resolving multiple at once
|
||
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')
|
||
self.assertEqual(claim['value_type'], 'stream')
|
||
self.assertEqual(claim['signing_channel']['name'], '@abc')
|
||
self.assertTrue(claim['is_channel_signature_valid'])
|
||
|
||
# resolve has correct confirmations
|
||
tx_details = await self.blockchain.get_raw_transaction(claim['txid'])
|
||
self.assertEqual(claim['confirmations'], json.loads(tx_details)['confirmations'])
|
||
|
||
# FIXME : claimname/updateclaim is gone. #3480 wip, unblock #3479"
|
||
# resolve handles invalid data
|
||
# await self.blockchain_claim_name("gibberish", hexlify(b"{'invalid':'json'}").decode(), "0.1")
|
||
# await self.generate(1)
|
||
# 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')
|
||
# self.assertNotIn('value', claim)
|
||
|
||
# resolve retries
|
||
await self.conductor.spv_node.stop()
|
||
resolve_task = asyncio.create_task(self.resolve('foo'))
|
||
await self.conductor.spv_node.start(self.conductor.lbcwallet_node)
|
||
self.assertIsNotNone((await resolve_task)['claim_id'])
|
||
|
||
async def test_winning_by_effective_amount(self):
|
||
# first one remains winner unless something else changes
|
||
claim_id1 = self.get_claim_id(
|
||
await self.channel_create('@foo', allow_duplicate_name=True))
|
||
await self.assertResolvesToClaimId('@foo', claim_id1)
|
||
claim_id2 = self.get_claim_id(
|
||
await self.channel_create('@foo', allow_duplicate_name=True))
|
||
await self.assertResolvesToClaimId('@foo', claim_id1)
|
||
claim_id3 = self.get_claim_id(
|
||
await self.channel_create('@foo', allow_duplicate_name=True))
|
||
await self.assertResolvesToClaimId('@foo', claim_id1)
|
||
# supports change the winner
|
||
await self.support_create(claim_id3, '0.09')
|
||
await self.assertResolvesToClaimId('@foo', claim_id3)
|
||
await self.support_create(claim_id2, '0.19')
|
||
await self.assertResolvesToClaimId('@foo', claim_id2)
|
||
await self.support_create(claim_id1, '0.29')
|
||
await self.assertResolvesToClaimId('@foo', claim_id1)
|
||
|
||
await self.support_abandon(claim_id1)
|
||
await self.assertResolvesToClaimId('@foo', claim_id2)
|
||
|
||
async def test_resolve_duplicate_name_in_channel(self):
|
||
db_resolve = self.conductor.spv_node.server.db.resolve
|
||
# first one remains winner unless something else changes
|
||
channel_id = self.get_claim_id(await self.channel_create('@foo'))
|
||
|
||
file_path = self.create_upload_file(data=b'hi!')
|
||
tx = await self.daemon.jsonrpc_stream_create('duplicate', '0.1', file_path=file_path, allow_duplicate_name=True, channel_id=channel_id)
|
||
await self.ledger.wait(tx)
|
||
|
||
first_claim = tx.outputs[0].claim_id
|
||
|
||
file_path = self.create_upload_file(data=b'hi!')
|
||
tx = await self.daemon.jsonrpc_stream_create('duplicate', '0.1', file_path=file_path, allow_duplicate_name=True, channel_id=channel_id)
|
||
await self.ledger.wait(tx)
|
||
duplicate_claim = tx.outputs[0].claim_id
|
||
await self.generate(1)
|
||
|
||
stream, channel, _, _ = await db_resolve(f"@foo:{channel_id}/duplicate:{first_claim}")
|
||
self.assertEqual(stream.claim_hash.hex(), first_claim)
|
||
self.assertEqual(channel.claim_hash.hex(), channel_id)
|
||
stream, channel, _, _ = await db_resolve(f"@foo:{channel_id}/duplicate:{duplicate_claim}")
|
||
self.assertEqual(stream.claim_hash.hex(), duplicate_claim)
|
||
self.assertEqual(channel.claim_hash.hex(), channel_id)
|
||
|
||
async def test_advanced_resolve(self):
|
||
claim_id1 = self.get_claim_id(
|
||
await self.stream_create('foo', '0.7', allow_duplicate_name=True))
|
||
await self.assertResolvesToClaimId('foo$1', claim_id1)
|
||
claim_id2 = self.get_claim_id(
|
||
await self.stream_create('foo', '0.8', allow_duplicate_name=True))
|
||
await self.assertResolvesToClaimId('foo$1', claim_id2)
|
||
await self.assertResolvesToClaimId('foo$2', claim_id1)
|
||
claim_id3 = self.get_claim_id(
|
||
await self.stream_create('foo', '0.9', allow_duplicate_name=True))
|
||
# plain winning claim
|
||
await self.assertResolvesToClaimId('foo', claim_id3)
|
||
|
||
# amount order resolution
|
||
await self.assertResolvesToClaimId('foo$1', claim_id3)
|
||
await self.assertResolvesToClaimId('foo$2', claim_id2)
|
||
await self.assertResolvesToClaimId('foo$3', claim_id1)
|
||
await self.assertResolvesToClaimId('foo$4', None)
|
||
|
||
# async def test_partial_claim_id_resolve(self):
|
||
# # add some noise
|
||
# await self.channel_create('@abc', '0.1', allow_duplicate_name=True)
|
||
# await self.channel_create('@abc', '0.2', allow_duplicate_name=True)
|
||
# await self.channel_create('@abc', '1.0', allow_duplicate_name=True)
|
||
#
|
||
# channel_id = self.get_claim_id(await self.channel_create('@abc', '1.1', allow_duplicate_name=True))
|
||
# await self.assertResolvesToClaimId(f'@abc', channel_id)
|
||
# await self.assertResolvesToClaimId(f'@abc#{channel_id[:10]}', channel_id)
|
||
# await self.assertResolvesToClaimId(f'@abc#{channel_id}', channel_id)
|
||
#
|
||
# channel = await self.claim_get(channel_id)
|
||
# await self.assertResolvesToClaimId(channel['short_url'], channel_id)
|
||
# await self.assertResolvesToClaimId(channel['canonical_url'], channel_id)
|
||
# await self.assertResolvesToClaimId(channel['permanent_url'], channel_id)
|
||
#
|
||
# # add some noise
|
||
# await self.stream_create('foo', '0.1', allow_duplicate_name=True, channel_id=channel['claim_id'])
|
||
# await self.stream_create('foo', '0.2', allow_duplicate_name=True, channel_id=channel['claim_id'])
|
||
# await self.stream_create('foo', '0.3', allow_duplicate_name=True, channel_id=channel['claim_id'])
|
||
#
|
||
# claim_id1 = self.get_claim_id(
|
||
# await self.stream_create('foo', '0.7', allow_duplicate_name=True, channel_id=channel['claim_id']))
|
||
# claim1 = await self.claim_get(claim_id=claim_id1)
|
||
#
|
||
# await self.assertResolvesToClaimId('foo', claim_id1)
|
||
# await self.assertResolvesToClaimId('@abc/foo', claim_id1)
|
||
# await self.assertResolvesToClaimId(claim1['short_url'], claim_id1)
|
||
# await self.assertResolvesToClaimId(claim1['canonical_url'], claim_id1)
|
||
# await self.assertResolvesToClaimId(claim1['permanent_url'], claim_id1)
|
||
#
|
||
# claim_id2 = self.get_claim_id(
|
||
# await self.stream_create('foo', '0.8', allow_duplicate_name=True, channel_id=channel['claim_id']))
|
||
# claim2 = await self.claim_get(claim_id=claim_id2)
|
||
# await self.assertResolvesToClaimId('foo', claim_id2)
|
||
# await self.assertResolvesToClaimId('@abc/foo', claim_id2)
|
||
# await self.assertResolvesToClaimId(claim2['short_url'], claim_id2)
|
||
# await self.assertResolvesToClaimId(claim2['canonical_url'], claim_id2)
|
||
# await self.assertResolvesToClaimId(claim2['permanent_url'], claim_id2)
|
||
|
||
async def test_abandoned_channel_with_signed_claims(self):
|
||
channel = (await self.channel_create('@abc', '1.0'))['outputs'][0]
|
||
orphan_claim = await self.stream_create('on-channel-claim', '0.0001', channel_id=channel['claim_id'])
|
||
abandoned_channel_id = channel['claim_id']
|
||
await self.channel_abandon(txid=channel['txid'], nout=0)
|
||
channel = (await self.channel_create('@abc', '1.0'))['outputs'][0]
|
||
orphan_claim_id = self.get_claim_id(orphan_claim)
|
||
|
||
# Original channel doesn't exists anymore, so the signature is invalid. For invalid signatures, resolution is
|
||
# only possible outside a channel
|
||
self.assertEqual(
|
||
{'error': {
|
||
'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')
|
||
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)
|
||
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)
|
||
|
||
uri = 'lbry://@abc/on-channel-claim'
|
||
# now, claim something on this channel (it will update the invalid claim, but we save and forcefully restore)
|
||
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['is_channel_signature_valid'])
|
||
|
||
# ooops! claimed a valid conflict! (this happens on the wild, mostly by accident or race condition)
|
||
await self.stream_create(
|
||
'on-channel-claim', '0.00000001', channel_id=channel['claim_id'], allow_duplicate_name=True
|
||
)
|
||
|
||
# it still resolves! but to the older claim
|
||
response = await self.resolve(uri)
|
||
self.assertTrue(response['is_channel_signature_valid'])
|
||
self.assertEqual(response['txid'], valid_claim['txid'])
|
||
claims = [await self.resolve('on-channel-claim'), await self.resolve('on-channel-claim$2')]
|
||
self.assertEqual(2, len(claims))
|
||
self.assertEqual(
|
||
{channel['claim_id']}, {claim['signing_channel']['claim_id'] for claim in claims}
|
||
)
|
||
|
||
async def test_normalization_resolution(self):
|
||
|
||
one = 'ΣίσυφοςfiÆ'
|
||
two = 'ΣΊΣΥΦΟσFIæ'
|
||
|
||
c1 = await self.stream_create(one, '0.1')
|
||
c2 = await self.stream_create(two, '0.2')
|
||
|
||
loser_id = self.get_claim_id(c1)
|
||
winner_id = self.get_claim_id(c2)
|
||
|
||
# winning_one = await self.check_lbrycrd_winning(one)
|
||
await self.assertMatchClaimIsWinning(two, winner_id)
|
||
|
||
claim1 = await self.resolve(f'lbry://{one}')
|
||
claim2 = await self.resolve(f'lbry://{two}')
|
||
claim3 = await self.resolve(f'lbry://{one}:{winner_id[:5]}')
|
||
claim4 = await self.resolve(f'lbry://{two}:{winner_id[:5]}')
|
||
|
||
claim5 = await self.resolve(f'lbry://{one}:{loser_id[:5]}')
|
||
claim6 = await self.resolve(f'lbry://{two}:{loser_id[:5]}')
|
||
|
||
self.assertEqual(winner_id, claim1['claim_id'])
|
||
self.assertEqual(winner_id, claim2['claim_id'])
|
||
self.assertEqual(winner_id, claim3['claim_id'])
|
||
self.assertEqual(winner_id, claim4['claim_id'])
|
||
|
||
self.assertEqual(two, claim1['name'])
|
||
self.assertEqual(two, claim2['name'])
|
||
self.assertEqual(two, claim3['name'])
|
||
self.assertEqual(two, claim4['name'])
|
||
|
||
self.assertEqual(loser_id, claim5['claim_id'])
|
||
self.assertEqual(loser_id, claim6['claim_id'])
|
||
self.assertEqual(one, claim5['name'])
|
||
self.assertEqual(one, claim6['name'])
|
||
|
||
async def test_resolve_old_claim(self):
|
||
channel = await self.daemon.jsonrpc_channel_create('@olds', '1.0', blocking=True)
|
||
await self.confirm_tx(channel.id)
|
||
address = channel.outputs[0].get_address(self.account.ledger)
|
||
claim = generate_signed_legacy(address, channel.outputs[0])
|
||
tx = await Transaction.claim_create('example', claim.SerializeToString(), 1, address, [self.account], self.account)
|
||
await tx.sign([self.account])
|
||
await self.broadcast_and_confirm(tx)
|
||
|
||
response = await self.resolve('@olds/example')
|
||
self.assertTrue('is_channel_signature_valid' in response, str(response))
|
||
self.assertTrue(response['is_channel_signature_valid'])
|
||
|
||
claim.publisherSignature.signature = bytes(reversed(claim.publisherSignature.signature))
|
||
tx = await Transaction.claim_create(
|
||
'bad_example', claim.SerializeToString(), 1, address, [self.account], self.account
|
||
)
|
||
await tx.sign([self.account])
|
||
await self.broadcast_and_confirm(tx)
|
||
|
||
response = await self.resolve('bad_example')
|
||
self.assertFalse(response['is_channel_signature_valid'])
|
||
self.assertEqual(
|
||
{'error': {
|
||
'name': 'NOT_FOUND',
|
||
'text': 'Could not find claim at "@olds/bad_example".',
|
||
}},
|
||
await self.resolve('@olds/bad_example')
|
||
)
|
||
|
||
async def test_resolve_with_includes(self):
|
||
wallet2 = await self.daemon.jsonrpc_wallet_create('wallet2', create_account=True)
|
||
address2 = await self.daemon.jsonrpc_address_unused(wallet_id=wallet2.id)
|
||
|
||
await self.wallet_send('1.0', address2)
|
||
|
||
stream = await self.stream_create(
|
||
'priced', '0.1', wallet_id=wallet2.id,
|
||
fee_amount='0.5', fee_currency='LBC', fee_address=address2
|
||
)
|
||
stream_id = self.get_claim_id(stream)
|
||
|
||
resolve = await self.resolve('priced')
|
||
self.assertNotIn('is_my_output', resolve)
|
||
self.assertNotIn('purchase_receipt', resolve)
|
||
self.assertNotIn('sent_supports', resolve)
|
||
self.assertNotIn('sent_tips', resolve)
|
||
self.assertNotIn('received_tips', resolve)
|
||
|
||
# is_my_output
|
||
resolve = await self.resolve('priced', include_is_my_output=True)
|
||
self.assertFalse(resolve['is_my_output'])
|
||
resolve = await self.resolve('priced', wallet_id=wallet2.id, include_is_my_output=True)
|
||
self.assertTrue(resolve['is_my_output'])
|
||
|
||
# purchase receipt
|
||
resolve = await self.resolve('priced', include_purchase_receipt=True)
|
||
self.assertNotIn('purchase_receipt', resolve)
|
||
await self.purchase_create(stream_id)
|
||
resolve = await self.resolve('priced', include_purchase_receipt=True)
|
||
self.assertEqual('0.5', resolve['purchase_receipt']['amount'])
|
||
|
||
# my supports and my tips
|
||
resolve = await self.resolve(
|
||
'priced', include_sent_supports=True, include_sent_tips=True, include_received_tips=True
|
||
)
|
||
self.assertEqual('0.0', resolve['sent_supports'])
|
||
self.assertEqual('0.0', resolve['sent_tips'])
|
||
self.assertEqual('0.0', resolve['received_tips'])
|
||
await self.support_create(stream_id, '0.3')
|
||
await self.support_create(stream_id, '0.2')
|
||
await self.support_create(stream_id, '0.4', tip=True)
|
||
await self.support_create(stream_id, '0.5', tip=True)
|
||
resolve = await self.resolve(
|
||
'priced', include_sent_supports=True, include_sent_tips=True, include_received_tips=True
|
||
)
|
||
self.assertEqual('0.5', resolve['sent_supports'])
|
||
self.assertEqual('0.9', resolve['sent_tips'])
|
||
self.assertEqual('0.0', resolve['received_tips'])
|
||
|
||
resolve = await self.resolve(
|
||
'priced', include_sent_supports=True, include_sent_tips=True, include_received_tips=True,
|
||
wallet_id=wallet2.id
|
||
)
|
||
self.assertEqual('0.0', resolve['sent_supports'])
|
||
self.assertEqual('0.0', resolve['sent_tips'])
|
||
self.assertEqual('0.9', resolve['received_tips'])
|
||
self.assertEqual('1.4', resolve['meta']['support_amount'])
|
||
|
||
# make sure nothing is leaked between wallets through cached tx/txos
|
||
resolve = await self.resolve('priced')
|
||
self.assertNotIn('is_my_output', resolve)
|
||
self.assertNotIn('purchase_receipt', resolve)
|
||
self.assertNotIn('sent_supports', resolve)
|
||
self.assertNotIn('sent_tips', resolve)
|
||
self.assertNotIn('received_tips', resolve)
|
||
|
||
|
||
class ResolveClaimTakeovers(BaseResolveTestCase):
|
||
async def test_channel_invalidation(self):
|
||
channel_id = (await self.channel_create('@test', '0.1'))['outputs'][0]['claim_id']
|
||
channel_id2 = (await self.channel_create('@other', '0.1'))['outputs'][0]['claim_id']
|
||
|
||
async def make_claim(name, amount, channel_id=None):
|
||
return (
|
||
await self.stream_create(name, amount, channel_id=channel_id)
|
||
)['outputs'][0]['claim_id']
|
||
|
||
unsigned_then_signed = await make_claim('unsigned_then_signed', '0.1')
|
||
unsigned_then_updated_then_signed = await make_claim('unsigned_then_updated_then_signed', '0.1')
|
||
signed_then_unsigned = await make_claim(
|
||
'signed_then_unsigned', '0.01', channel_id=channel_id
|
||
)
|
||
signed_then_signed_different_chan = await make_claim(
|
||
'signed_then_signed_different_chan', '0.01', channel_id=channel_id
|
||
)
|
||
|
||
self.assertIn("error", await self.resolve('@test/unsigned_then_signed'))
|
||
await self.assertMatchClaimIsWinning('unsigned_then_signed', unsigned_then_signed)
|
||
self.assertIn("error", await self.resolve('@test/unsigned_then_updated_then_signed'))
|
||
await self.assertMatchClaimIsWinning('unsigned_then_updated_then_signed', unsigned_then_updated_then_signed)
|
||
self.assertDictEqual(
|
||
await self.resolve('@test/signed_then_unsigned'), await self.resolve('signed_then_unsigned')
|
||
)
|
||
await self.assertMatchClaimIsWinning('signed_then_unsigned', signed_then_unsigned)
|
||
# sign 'unsigned_then_signed' and update it
|
||
await self.ledger.wait(await self.daemon.jsonrpc_stream_update(
|
||
unsigned_then_signed, '0.09', channel_id=channel_id))
|
||
|
||
await self.ledger.wait(await self.daemon.jsonrpc_stream_update(unsigned_then_updated_then_signed, '0.09'))
|
||
await self.ledger.wait(await self.daemon.jsonrpc_stream_update(
|
||
unsigned_then_updated_then_signed, '0.09', channel_id=channel_id))
|
||
|
||
await self.ledger.wait(await self.daemon.jsonrpc_stream_update(
|
||
signed_then_unsigned, '0.09', clear_channel=True))
|
||
|
||
await self.ledger.wait(await self.daemon.jsonrpc_stream_update(
|
||
signed_then_signed_different_chan, '0.09', channel_id=channel_id2))
|
||
|
||
await self.daemon.jsonrpc_txo_spend(type='channel', claim_id=channel_id)
|
||
|
||
signed3 = await make_claim('signed3', '0.01', channel_id=channel_id)
|
||
signed4 = await make_claim('signed4', '0.01', channel_id=channel_id2)
|
||
|
||
self.assertIn("error", await self.resolve('@test'))
|
||
self.assertIn("error", await self.resolve('@test/signed1'))
|
||
self.assertIn("error", await self.resolve('@test/unsigned_then_updated_then_signed'))
|
||
self.assertIn("error", await self.resolve('@test/unsigned_then_signed'))
|
||
self.assertIn("error", await self.resolve('@test/signed3'))
|
||
self.assertIn("error", await self.resolve('@test/signed4'))
|
||
|
||
await self.assertMatchClaimIsWinning('signed_then_unsigned', signed_then_unsigned)
|
||
await self.assertMatchClaimIsWinning('unsigned_then_signed', unsigned_then_signed)
|
||
await self.assertMatchClaimIsWinning('unsigned_then_updated_then_signed', unsigned_then_updated_then_signed)
|
||
await self.assertMatchClaimIsWinning('signed_then_signed_different_chan', signed_then_signed_different_chan)
|
||
await self.assertMatchClaimIsWinning('signed3', signed3)
|
||
await self.assertMatchClaimIsWinning('signed4', signed4)
|
||
|
||
self.assertDictEqual(await self.resolve('@other/signed_then_signed_different_chan'),
|
||
await self.resolve('signed_then_signed_different_chan'))
|
||
self.assertDictEqual(await self.resolve('@other/signed4'),
|
||
await self.resolve('signed4'))
|
||
|
||
self.assertEqual(2, len(await self.claim_search(channel_ids=[channel_id2])))
|
||
|
||
await self.channel_update(channel_id2)
|
||
await make_claim('third_signed', '0.01', channel_id=channel_id2)
|
||
self.assertEqual(3, len(await self.claim_search(channel_ids=[channel_id2])))
|
||
|
||
async def _test_activation_delay(self):
|
||
name = 'derp'
|
||
# initially claim the name
|
||
first_claim_id = (await self.stream_create(name, '0.1', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(320)
|
||
# a claim of higher amount made now will have a takeover delay of 10
|
||
second_claim_id = (await self.stream_create(name, '0.2', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
# sanity check
|
||
self.assertNotEqual(first_claim_id, second_claim_id)
|
||
# takeover should not have happened yet
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(9)
|
||
# not yet
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(1)
|
||
# the new claim should have activated
|
||
await self.assertMatchClaimIsWinning(name, second_claim_id)
|
||
return first_claim_id, second_claim_id
|
||
|
||
async def test_activation_delay(self):
|
||
await self._test_activation_delay()
|
||
|
||
async def test_activation_delay_then_abandon_then_reclaim(self):
|
||
name = 'derp'
|
||
first_claim_id, second_claim_id = await self._test_activation_delay()
|
||
await self.daemon.jsonrpc_txo_spend(type='stream', claim_id=first_claim_id)
|
||
await self.daemon.jsonrpc_txo_spend(type='stream', claim_id=second_claim_id)
|
||
await self.generate(1)
|
||
await self.assertNoClaimForName(name)
|
||
await self._test_activation_delay()
|
||
|
||
async def create_stream_claim(self, amount: str, name='derp') -> str:
|
||
return (await self.stream_create(name, amount, allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
|
||
async def assertNameState(self, height: int, name: str, winning_claim_id: str, last_takeover_height: int,
|
||
non_winning_claims: List[ClaimStateValue]):
|
||
self.assertEqual(height, self.conductor.spv_node.server.db.db_height)
|
||
await self.assertMatchClaimIsWinning(name, winning_claim_id)
|
||
for non_winning in non_winning_claims:
|
||
claim = await self.assertMatchClaim(name,
|
||
non_winning.claim_id, is_active_in_lbrycrd=non_winning.active_in_lbrycrd
|
||
)
|
||
self.assertEqual(non_winning.activation_height, claim.activation_height)
|
||
self.assertEqual(last_takeover_height, claim.last_takeover_height)
|
||
|
||
async def test_delay_takeover_with_update(self):
|
||
name = 'derp'
|
||
first_claim_id = await self.create_stream_claim('0.2', name)
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(320)
|
||
second_claim_id = await self.create_stream_claim('0.1', name)
|
||
third_claim_id = await self.create_stream_claim('0.1', name)
|
||
await self.generate(8)
|
||
await self.assertNameState(
|
||
height=537, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=False),
|
||
ClaimStateValue(third_claim_id, activation_height=539, active_in_lbrycrd=False)
|
||
]
|
||
)
|
||
|
||
await self.generate(1)
|
||
await self.assertNameState(
|
||
height=538, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=539, active_in_lbrycrd=False)
|
||
]
|
||
)
|
||
|
||
await self.generate(1)
|
||
await self.assertNameState(
|
||
height=539, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=539, active_in_lbrycrd=True)
|
||
]
|
||
)
|
||
|
||
await self.daemon.jsonrpc_stream_update(third_claim_id, '0.21')
|
||
await self.generate(1)
|
||
await self.assertNameState(
|
||
height=540, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=550, active_in_lbrycrd=False)
|
||
]
|
||
)
|
||
|
||
await self.generate(9)
|
||
await self.assertNameState(
|
||
height=549, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=550, active_in_lbrycrd=False)
|
||
]
|
||
)
|
||
|
||
await self.generate(1)
|
||
await self.assertNameState(
|
||
height=550, name=name, winning_claim_id=third_claim_id, last_takeover_height=550,
|
||
non_winning_claims=[
|
||
ClaimStateValue(first_claim_id, activation_height=207, active_in_lbrycrd=True),
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True)
|
||
]
|
||
)
|
||
|
||
async def test_delay_takeover_with_update_then_update_to_lower_before_takeover(self):
|
||
name = 'derp'
|
||
first_claim_id = await self.create_stream_claim('0.2', name)
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(320)
|
||
second_claim_id = await self.create_stream_claim('0.1', name)
|
||
third_claim_id = await self.create_stream_claim('0.1', name)
|
||
await self.generate(8)
|
||
await self.assertNameState(
|
||
height=537, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=False),
|
||
ClaimStateValue(third_claim_id, activation_height=539, active_in_lbrycrd=False)
|
||
]
|
||
)
|
||
|
||
await self.generate(1)
|
||
await self.assertNameState(
|
||
height=538, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=539, active_in_lbrycrd=False)
|
||
]
|
||
)
|
||
|
||
await self.generate(1)
|
||
await self.assertNameState(
|
||
height=539, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=539, active_in_lbrycrd=True)
|
||
]
|
||
)
|
||
|
||
await self.daemon.jsonrpc_stream_update(third_claim_id, '0.21')
|
||
await self.generate(1)
|
||
await self.assertNameState(
|
||
height=540, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=550, active_in_lbrycrd=False)
|
||
]
|
||
)
|
||
|
||
await self.generate(8)
|
||
await self.assertNameState(
|
||
height=548, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=550, active_in_lbrycrd=False)
|
||
]
|
||
)
|
||
|
||
await self.daemon.jsonrpc_stream_update(third_claim_id, '0.09')
|
||
|
||
await self.generate(1)
|
||
await self.assertNameState(
|
||
height=549, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=559, active_in_lbrycrd=False)
|
||
]
|
||
)
|
||
await self.generate(10)
|
||
await self.assertNameState(
|
||
height=559, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=559, active_in_lbrycrd=True)
|
||
]
|
||
)
|
||
|
||
async def test_delay_takeover_with_update_then_update_to_lower_on_takeover(self):
|
||
name = 'derp'
|
||
first_claim_id = await self.create_stream_claim('0.2', name)
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(320)
|
||
second_claim_id = await self.create_stream_claim('0.1', name)
|
||
third_claim_id = await self.create_stream_claim('0.1', name)
|
||
await self.generate(8)
|
||
await self.assertNameState(
|
||
height=537, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=False),
|
||
ClaimStateValue(third_claim_id, activation_height=539, active_in_lbrycrd=False)
|
||
]
|
||
)
|
||
|
||
await self.generate(1)
|
||
await self.assertNameState(
|
||
height=538, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=539, active_in_lbrycrd=False)
|
||
]
|
||
)
|
||
|
||
await self.generate(1)
|
||
await self.assertNameState(
|
||
height=539, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=539, active_in_lbrycrd=True)
|
||
]
|
||
)
|
||
|
||
await self.daemon.jsonrpc_stream_update(third_claim_id, '0.21')
|
||
await self.generate(1)
|
||
await self.assertNameState(
|
||
height=540, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=550, active_in_lbrycrd=False)
|
||
]
|
||
)
|
||
|
||
await self.generate(8)
|
||
await self.assertNameState(
|
||
height=548, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=550, active_in_lbrycrd=False)
|
||
]
|
||
)
|
||
|
||
await self.generate(1)
|
||
await self.assertNameState(
|
||
height=549, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=550, active_in_lbrycrd=False)
|
||
]
|
||
)
|
||
|
||
await self.daemon.jsonrpc_stream_update(third_claim_id, '0.09')
|
||
await self.generate(1)
|
||
await self.assertNameState(
|
||
height=550, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=560, active_in_lbrycrd=False)
|
||
]
|
||
)
|
||
await self.generate(10)
|
||
await self.assertNameState(
|
||
height=560, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=560, active_in_lbrycrd=True)
|
||
]
|
||
)
|
||
|
||
async def test_delay_takeover_with_update_then_update_to_lower_after_takeover(self):
|
||
name = 'derp'
|
||
first_claim_id = await self.create_stream_claim('0.2', name)
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(320)
|
||
second_claim_id = await self.create_stream_claim('0.1', name)
|
||
third_claim_id = await self.create_stream_claim('0.1', name)
|
||
await self.generate(8)
|
||
await self.assertNameState(
|
||
height=537, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=False),
|
||
ClaimStateValue(third_claim_id, activation_height=539, active_in_lbrycrd=False)
|
||
]
|
||
)
|
||
await self.generate(1)
|
||
await self.assertNameState(
|
||
height=538, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=539, active_in_lbrycrd=False)
|
||
]
|
||
)
|
||
|
||
await self.generate(1)
|
||
await self.assertNameState(
|
||
height=539, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=539, active_in_lbrycrd=True)
|
||
]
|
||
)
|
||
|
||
await self.daemon.jsonrpc_stream_update(third_claim_id, '0.21')
|
||
await self.generate(1)
|
||
await self.assertNameState(
|
||
height=540, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=550, active_in_lbrycrd=False)
|
||
]
|
||
)
|
||
|
||
await self.generate(8)
|
||
await self.assertNameState(
|
||
height=548, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=550, active_in_lbrycrd=False)
|
||
]
|
||
)
|
||
|
||
await self.generate(1)
|
||
await self.assertNameState(
|
||
height=549, name=name, winning_claim_id=first_claim_id, last_takeover_height=207,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=550, active_in_lbrycrd=False)
|
||
]
|
||
)
|
||
|
||
await self.generate(1)
|
||
await self.assertNameState(
|
||
height=550, name=name, winning_claim_id=third_claim_id, last_takeover_height=550,
|
||
non_winning_claims=[
|
||
ClaimStateValue(first_claim_id, activation_height=207, active_in_lbrycrd=True),
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True)
|
||
]
|
||
)
|
||
|
||
await self.daemon.jsonrpc_stream_update(third_claim_id, '0.09')
|
||
await self.generate(1)
|
||
await self.assertNameState(
|
||
height=551, name=name, winning_claim_id=first_claim_id, last_takeover_height=551,
|
||
non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True),
|
||
ClaimStateValue(third_claim_id, activation_height=551, active_in_lbrycrd=True)
|
||
]
|
||
)
|
||
|
||
async def test_resolve_signed_claims_with_fees(self):
|
||
channel_name = '@abc'
|
||
channel_id = self.get_claim_id(
|
||
await self.channel_create(channel_name, '0.01')
|
||
)
|
||
self.assertEqual(channel_id, (await self.assertMatchWinningClaim(channel_name)).claim_hash.hex())
|
||
stream_name = 'foo'
|
||
stream_with_no_fee = self.get_claim_id(
|
||
await self.stream_create(stream_name, '0.01', channel_id=channel_id)
|
||
)
|
||
stream_with_fee = self.get_claim_id(
|
||
await self.stream_create('with_a_fee', '0.01', channel_id=channel_id, fee_amount='1', fee_currency='LBC')
|
||
)
|
||
greater_than_or_equal_to_zero = [
|
||
claim['claim_id'] for claim in (
|
||
await self.conductor.spv_node.server.session_manager.search_index.search(
|
||
channel_id=channel_id, fee_amount=">=0"
|
||
))[0]
|
||
]
|
||
self.assertEqual(2, len(greater_than_or_equal_to_zero))
|
||
self.assertSetEqual(set(greater_than_or_equal_to_zero), {stream_with_no_fee, stream_with_fee})
|
||
greater_than_zero = [
|
||
claim['claim_id'] for claim in (
|
||
await self.conductor.spv_node.server.session_manager.search_index.search(
|
||
channel_id=channel_id, fee_amount=">0"
|
||
))[0]
|
||
]
|
||
self.assertEqual(1, len(greater_than_zero))
|
||
self.assertSetEqual(set(greater_than_zero), {stream_with_fee})
|
||
equal_to_zero = [
|
||
claim['claim_id'] for claim in (
|
||
await self.conductor.spv_node.server.session_manager.search_index.search(
|
||
channel_id=channel_id, fee_amount="<=0"
|
||
))[0]
|
||
]
|
||
self.assertEqual(1, len(equal_to_zero))
|
||
self.assertSetEqual(set(equal_to_zero), {stream_with_no_fee})
|
||
|
||
async def test_spec_example(self):
|
||
# https://spec.lbry.com/#claim-activation-example
|
||
# this test has adjusted block heights from the example because it uses the regtest chain instead of mainnet
|
||
# on regtest, claims expire much faster, so we can't do the ~1000 block delay in the spec example exactly
|
||
|
||
name = 'test'
|
||
await self.generate(494)
|
||
address = (await self.account.receiving.get_addresses(True))[0]
|
||
await self.send_to_address_and_wait(address, 400.0)
|
||
await self.account.ledger.on_address.first
|
||
await self.generate(100)
|
||
self.assertEqual(800, self.conductor.spv_node.server.db.db_height)
|
||
|
||
# Block 801: Claim A for 10 LBC is accepted.
|
||
# It is the first claim, so it immediately becomes active and controlling.
|
||
# State: A(10) is controlling
|
||
claim_id_A = (await self.stream_create(name, '10.0', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
await self.assertMatchClaimIsWinning(name, claim_id_A)
|
||
|
||
# Block 1121: Claim B for 20 LBC is accepted.
|
||
# Its activation height is 1121 + min(4032, floor((1121-801) / 32)) = 1121 + 10 = 1131.
|
||
# State: A(10) is controlling, B(20) is accepted.
|
||
await self.generate(32 * 10 - 1)
|
||
self.assertEqual(1120, self.conductor.spv_node.server.db.db_height)
|
||
claim_id_B = (await self.stream_create(name, '20.0', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
claim_B, _, _, _ = await self.conductor.spv_node.server.db.resolve(f"{name}:{claim_id_B}")
|
||
self.assertEqual(1121, self.conductor.spv_node.server.db.db_height)
|
||
self.assertEqual(1131, claim_B.activation_height)
|
||
await self.assertMatchClaimIsWinning(name, claim_id_A)
|
||
|
||
# Block 1122: Support X for 14 LBC for claim A is accepted.
|
||
# Since it is a support for the controlling claim, it activates immediately.
|
||
# State: A(10+14) is controlling, B(20) is accepted.
|
||
await self.support_create(claim_id_A, bid='14.0')
|
||
self.assertEqual(1122, self.conductor.spv_node.server.db.db_height)
|
||
await self.assertMatchClaimIsWinning(name, claim_id_A)
|
||
|
||
# Block 1123: Claim C for 50 LBC is accepted.
|
||
# The activation height is 1123 + min(4032, floor((1123-801) / 32)) = 1123 + 10 = 1133.
|
||
# State: A(10+14) is controlling, B(20) is accepted, C(50) is accepted.
|
||
claim_id_C = (await self.stream_create(name, '50.0', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
self.assertEqual(1123, self.conductor.spv_node.server.db.db_height)
|
||
claim_C, _, _, _ = await self.conductor.spv_node.server.db.resolve(f"{name}:{claim_id_C}")
|
||
self.assertEqual(1133, claim_C.activation_height)
|
||
await self.assertMatchClaimIsWinning(name, claim_id_A)
|
||
|
||
await self.generate(7)
|
||
self.assertEqual(1130, self.conductor.spv_node.server.db.db_height)
|
||
await self.assertMatchClaimIsWinning(name, claim_id_A)
|
||
await self.generate(1)
|
||
|
||
# Block 1131: Claim B activates. It has 20 LBC, while claim A has 24 LBC (10 original + 14 from support X). There is no takeover, and claim A remains controlling.
|
||
# State: A(10+14) is controlling, B(20) is active, C(50) is accepted.
|
||
self.assertEqual(1131, self.conductor.spv_node.server.db.db_height)
|
||
await self.assertMatchClaimIsWinning(name, claim_id_A)
|
||
|
||
# Block 1132: Claim D for 300 LBC is accepted. The activation height is 1132 + min(4032, floor((1132-801) / 32)) = 1132 + 10 = 1142.
|
||
# State: A(10+14) is controlling, B(20) is active, C(50) is accepted, D(300) is accepted.
|
||
claim_id_D = (await self.stream_create(name, '300.0', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
self.assertEqual(1132, self.conductor.spv_node.server.db.db_height)
|
||
claim_D, _, _, _ = await self.conductor.spv_node.server.db.resolve(f"{name}:{claim_id_D}")
|
||
self.assertEqual(False, claim_D.is_controlling)
|
||
self.assertEqual(801, claim_D.last_takeover_height)
|
||
self.assertEqual(1142, claim_D.activation_height)
|
||
await self.assertMatchClaimIsWinning(name, claim_id_A)
|
||
|
||
# Block 1133: Claim C activates. It has 50 LBC, while claim A has 24 LBC, so a takeover is initiated. The takeover height for this name is set to 1133, and therefore the activation delay for all the claims becomes min(4032, floor((1133-1133) / 32)) = 0. All the claims become active. The totals for each claim are recalculated, and claim D becomes controlling because it has the highest total.
|
||
# State: A(10+14) is active, B(20) is active, C(50) is active, D(300) is controlling
|
||
await self.generate(1)
|
||
self.assertEqual(1133, self.conductor.spv_node.server.db.db_height)
|
||
claim_D, _, _, _ = await self.conductor.spv_node.server.db.resolve(f"{name}:{claim_id_D}")
|
||
self.assertEqual(True, claim_D.is_controlling)
|
||
self.assertEqual(1133, claim_D.last_takeover_height)
|
||
self.assertEqual(1133, claim_D.activation_height)
|
||
await self.assertMatchClaimIsWinning(name, claim_id_D)
|
||
|
||
async def test_early_takeover(self):
|
||
name = 'derp'
|
||
# block 207
|
||
first_claim_id = (await self.stream_create(name, '0.1', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
|
||
await self.generate(96)
|
||
# block 304, activates at 307
|
||
second_claim_id = (await self.stream_create(name, '0.2', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
# block 305, activates at 308 (but gets triggered early by the takeover by the second claim)
|
||
third_claim_id = (await self.stream_create(name, '0.3', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
self.assertNotEqual(first_claim_id, second_claim_id)
|
||
# takeover should not have happened yet
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, third_claim_id)
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, third_claim_id)
|
||
|
||
async def test_early_takeover_zero_delay(self):
|
||
name = 'derp'
|
||
# block 207
|
||
first_claim_id = (await self.stream_create(name, '0.1', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
|
||
await self.generate(96)
|
||
# block 304, activates at 307
|
||
second_claim_id = (await self.stream_create(name, '0.2', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
# on block 307 make a third claim with a yet higher amount, it takes over with no delay because the
|
||
# second claim activates and begins the takeover on this block
|
||
third_claim_id = (await self.stream_create(name, '0.3', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
await self.assertMatchClaimIsWinning(name, third_claim_id)
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, third_claim_id)
|
||
|
||
async def test_early_takeover_from_support_zero_delay(self):
|
||
name = 'derp'
|
||
# block 207
|
||
first_claim_id = (await self.stream_create(name, '0.1', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
|
||
await self.generate(96)
|
||
# block 304, activates at 307
|
||
second_claim_id = (await self.stream_create(name, '0.2', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
third_claim_id = (await self.stream_create(name, '0.19', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
tx = await self.daemon.jsonrpc_support_create(third_claim_id, '0.1')
|
||
await self.ledger.wait(tx)
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, third_claim_id)
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, third_claim_id)
|
||
|
||
async def test_early_takeover_from_support_and_claim_zero_delay(self):
|
||
name = 'derp'
|
||
# block 207
|
||
first_claim_id = (await self.stream_create(name, '0.1', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
|
||
await self.generate(96)
|
||
# block 304, activates at 307
|
||
second_claim_id = (await self.stream_create(name, '0.2', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(1)
|
||
|
||
file_path = self.create_upload_file(data=b'hi!')
|
||
tx = await self.daemon.jsonrpc_stream_create(name, '0.19', file_path=file_path, allow_duplicate_name=True)
|
||
await self.ledger.wait(tx)
|
||
third_claim_id = tx.outputs[0].claim_id
|
||
|
||
wallet = self.daemon.wallet_manager.get_wallet_or_default(None)
|
||
funding_accounts = wallet.get_accounts_or_all(None)
|
||
amount = self.daemon.get_dewies_or_error("amount", '0.1')
|
||
account = wallet.get_account_or_default(None)
|
||
claim_address = await account.receiving.get_or_create_usable_address()
|
||
tx = await Transaction.support(
|
||
'derp', third_claim_id, amount, claim_address, funding_accounts, funding_accounts[0], None
|
||
)
|
||
await tx.sign(funding_accounts)
|
||
await self.daemon.broadcast_or_release(tx, True)
|
||
await self.ledger.wait(tx)
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, third_claim_id)
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, third_claim_id)
|
||
|
||
async def test_early_takeover_abandoned_controlling_support(self):
|
||
name = 'derp'
|
||
# block 207
|
||
first_claim_id = (await self.stream_create(name, '0.1', allow_duplicate_name=True))['outputs'][0][
|
||
'claim_id']
|
||
tx = await self.daemon.jsonrpc_support_create(first_claim_id, '0.2')
|
||
await self.ledger.wait(tx)
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(96)
|
||
# block 304, activates at 307
|
||
second_claim_id = (await self.stream_create(name, '0.2', allow_duplicate_name=True))['outputs'][0][
|
||
'claim_id']
|
||
# block 305, activates at 308 (but gets triggered early by the takeover by the second claim)
|
||
third_claim_id = (await self.stream_create(name, '0.3', allow_duplicate_name=True))['outputs'][0][
|
||
'claim_id']
|
||
self.assertNotEqual(first_claim_id, second_claim_id)
|
||
# takeover should not have happened yet
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.daemon.jsonrpc_txo_spend(type='support', txid=tx.id)
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, third_claim_id)
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, third_claim_id)
|
||
|
||
async def test_block_takeover_with_delay_1_support(self):
|
||
name = 'derp'
|
||
# initially claim the name
|
||
first_claim_id = (await self.stream_create(name, '0.1'))['outputs'][0]['claim_id']
|
||
self.assertEqual(first_claim_id, (await self.assertMatchWinningClaim(name)).claim_hash.hex())
|
||
await self.generate(320)
|
||
# a claim of higher amount made now will have a takeover delay of 10
|
||
second_claim_id = (await self.stream_create(name, '0.2', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
# sanity check
|
||
self.assertNotEqual(first_claim_id, second_claim_id)
|
||
# takeover should not have happened yet
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
for _ in range(8):
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
# prevent the takeover by adding a support one block before the takeover happens
|
||
await self.support_create(first_claim_id, bid='1.0')
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
# one more block until activation
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
|
||
async def test_block_takeover_with_delay_0_support(self):
|
||
name = 'derp'
|
||
# initially claim the name
|
||
first_claim_id = (await self.stream_create(name, '0.1'))['outputs'][0]['claim_id']
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(320)
|
||
# a claim of higher amount made now will have a takeover delay of 10
|
||
second_claim_id = (await self.stream_create(name, '0.2', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
# sanity check
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
# takeover should not have happened yet
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(9)
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
# prevent the takeover by adding a support on the same block the takeover would happen
|
||
await self.support_create(first_claim_id, bid='1.0')
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
|
||
async def _test_almost_prevent_takeover(self, name: str, blocks: int = 9):
|
||
# initially claim the name
|
||
first_claim_id = (await self.stream_create(name, '0.1'))['outputs'][0]['claim_id']
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(320)
|
||
# a claim of higher amount made now will have a takeover delay of 10
|
||
second_claim_id = (await self.stream_create(name, '0.2', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
# sanity check
|
||
self.assertNotEqual(first_claim_id, second_claim_id)
|
||
# takeover should not have happened yet
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(blocks)
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
# prevent the takeover by adding a support on the same block the takeover would happen
|
||
tx = await self.daemon.jsonrpc_support_create(first_claim_id, '1.0')
|
||
await self.ledger.wait(tx)
|
||
return first_claim_id, second_claim_id, tx
|
||
|
||
async def test_almost_prevent_takeover_remove_support_same_block_supported(self):
|
||
name = 'derp'
|
||
first_claim_id, second_claim_id, tx = await self._test_almost_prevent_takeover(name, 9)
|
||
await self.daemon.jsonrpc_txo_spend(type='support', txid=tx.id)
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, second_claim_id)
|
||
|
||
async def test_almost_prevent_takeover_remove_support_one_block_after_supported(self):
|
||
name = 'derp'
|
||
first_claim_id, second_claim_id, tx = await self._test_almost_prevent_takeover(name, 8)
|
||
await self.generate(1)
|
||
await self.daemon.jsonrpc_txo_spend(type='support', txid=tx.id)
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, second_claim_id)
|
||
|
||
async def test_abandon_before_takeover(self):
|
||
name = 'derp'
|
||
# initially claim the name
|
||
first_claim_id = (await self.stream_create(name, '0.1'))['outputs'][0]['claim_id']
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(320)
|
||
# a claim of higher amount made now will have a takeover delay of 10
|
||
second_claim_id = (await self.stream_create(name, '0.2', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
# sanity check
|
||
self.assertNotEqual(first_claim_id, second_claim_id)
|
||
# takeover should not have happened yet
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(8)
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
# abandon the winning claim
|
||
await self.daemon.jsonrpc_txo_spend(type='stream', claim_id=first_claim_id)
|
||
await self.generate(1)
|
||
# the takeover and activation should happen a block earlier than they would have absent the abandon
|
||
await self.assertMatchClaimIsWinning(name, second_claim_id)
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, second_claim_id)
|
||
|
||
async def test_abandon_before_takeover_no_delay_update(self): # TODO: fix race condition line 506
|
||
name = 'derp'
|
||
# initially claim the name
|
||
first_claim_id = (await self.stream_create(name, '0.1'))['outputs'][0]['claim_id']
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(320)
|
||
# block 527
|
||
# a claim of higher amount made now will have a takeover delay of 10
|
||
second_claim_id = (await self.stream_create(name, '0.2', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
# block 528
|
||
# sanity check
|
||
self.assertNotEqual(first_claim_id, second_claim_id)
|
||
# takeover should not have happened yet
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.assertMatchClaimsForName(name)
|
||
await self.generate(8)
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.assertMatchClaimsForName(name)
|
||
# abandon the winning claim
|
||
await self.daemon.jsonrpc_txo_spend(type='stream', claim_id=first_claim_id)
|
||
await self.daemon.jsonrpc_stream_update(second_claim_id, '0.1')
|
||
await self.generate(1)
|
||
|
||
# the takeover and activation should happen a block earlier than they would have absent the abandon
|
||
await self.assertMatchClaimIsWinning(name, second_claim_id)
|
||
await self.assertMatchClaimsForName(name)
|
||
await self.generate(1)
|
||
# await self.ledger.on_header.where(lambda e: e.height == 537)
|
||
await self.assertMatchClaimIsWinning(name, second_claim_id)
|
||
await self.assertMatchClaimsForName(name)
|
||
|
||
async def test_abandon_controlling_support_before_pending_takeover(self):
|
||
name = 'derp'
|
||
# initially claim the name
|
||
first_claim_id = (await self.stream_create(name, '0.1'))['outputs'][0]['claim_id']
|
||
controlling_support_tx = await self.daemon.jsonrpc_support_create(first_claim_id, '0.9')
|
||
await self.ledger.wait(controlling_support_tx)
|
||
self.assertEqual(first_claim_id, (await self.assertMatchWinningClaim(name)).claim_hash.hex())
|
||
await self.generate(321)
|
||
|
||
second_claim_id = (await self.stream_create(name, '0.9', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
|
||
self.assertNotEqual(first_claim_id, second_claim_id)
|
||
# takeover should not have happened yet
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(8)
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
# abandon the support that causes the winning claim to have the highest staked
|
||
tx = await self.daemon.jsonrpc_txo_spend(type='support', txid=controlling_support_tx.id, blocking=True)
|
||
await self.generate(1)
|
||
await self.assertNameState(538, name, first_claim_id, last_takeover_height=207, non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=539, active_in_lbrycrd=False)
|
||
])
|
||
await self.generate(1)
|
||
await self.assertNameState(539, name, second_claim_id, last_takeover_height=539, non_winning_claims=[
|
||
ClaimStateValue(first_claim_id, activation_height=207, active_in_lbrycrd=True)
|
||
])
|
||
|
||
async def test_remove_controlling_support(self):
|
||
name = 'derp'
|
||
# initially claim the name
|
||
first_claim_id = (await self.stream_create(name, '0.2'))['outputs'][0]['claim_id']
|
||
first_support_tx = await self.daemon.jsonrpc_support_create(first_claim_id, '0.9')
|
||
await self.ledger.wait(first_support_tx)
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(320) # give the first claim long enough for a 10 block takeover delay
|
||
await self.assertNameState(527, name, first_claim_id, last_takeover_height=207, non_winning_claims=[])
|
||
|
||
# make a second claim which will take over the name
|
||
second_claim_id = (await self.stream_create(name, '0.1', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
await self.assertNameState(528, name, first_claim_id, last_takeover_height=207, non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=False)
|
||
])
|
||
|
||
second_claim_support_tx = await self.daemon.jsonrpc_support_create(second_claim_id, '1.5')
|
||
await self.ledger.wait(second_claim_support_tx)
|
||
await self.generate(1) # neither the second claim or its support have activated yet
|
||
await self.assertNameState(529, name, first_claim_id, last_takeover_height=207, non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=False)
|
||
])
|
||
await self.generate(9) # claim activates, but is not yet winning
|
||
await self.assertNameState(538, name, first_claim_id, last_takeover_height=207, non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True)
|
||
])
|
||
await self.generate(1) # support activates, takeover happens
|
||
await self.assertNameState(539, name, second_claim_id, last_takeover_height=539, non_winning_claims=[
|
||
ClaimStateValue(first_claim_id, activation_height=207, active_in_lbrycrd=True)
|
||
])
|
||
|
||
await self.daemon.jsonrpc_txo_spend(type='support', claim_id=second_claim_id, blocking=True)
|
||
await self.generate(1) # support activates, takeover happens
|
||
await self.assertNameState(540, name, first_claim_id, last_takeover_height=540, non_winning_claims=[
|
||
ClaimStateValue(second_claim_id, activation_height=538, active_in_lbrycrd=True)
|
||
])
|
||
|
||
async def test_claim_expiration(self):
|
||
name = 'derp'
|
||
# starts at height 206
|
||
vanishing_claim = (await self.stream_create('vanish', '0.1'))['outputs'][0]['claim_id']
|
||
|
||
await self.generate(493)
|
||
# in block 701 and 702
|
||
first_claim_id = (await self.stream_create(name, '0.3'))['outputs'][0]['claim_id']
|
||
await self.assertMatchClaimIsWinning('vanish', vanishing_claim)
|
||
await self.generate(100) # block 801, expiration fork happened
|
||
await self.assertNoClaimForName('vanish')
|
||
# second claim is in block 802
|
||
second_claim_id = (await self.stream_create(name, '0.2', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(498)
|
||
await self.assertMatchClaimIsWinning(name, first_claim_id)
|
||
await self.generate(1)
|
||
await self.assertMatchClaimIsWinning(name, second_claim_id)
|
||
await self.generate(100)
|
||
await self.assertMatchClaimIsWinning(name, second_claim_id)
|
||
await self.generate(1)
|
||
await self.assertNoClaimForName(name)
|
||
|
||
async def _test_add_non_winning_already_claimed(self):
|
||
name = 'derp'
|
||
# initially claim the name
|
||
first_claim_id = (await self.stream_create(name, '0.1'))['outputs'][0]['claim_id']
|
||
self.assertEqual(first_claim_id, (await self.assertMatchWinningClaim(name)).claim_hash.hex())
|
||
await self.generate(32)
|
||
|
||
second_claim_id = (await self.stream_create(name, '0.01', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
await self.assertNoClaim(name, second_claim_id)
|
||
self.assertEqual(
|
||
len((await self.conductor.spv_node.server.session_manager.search_index.search(claim_name=name))[0]), 1
|
||
)
|
||
await self.generate(1)
|
||
await self.assertMatchClaim(name, second_claim_id)
|
||
self.assertEqual(
|
||
len((await self.conductor.spv_node.server.session_manager.search_index.search(claim_name=name))[0]), 2
|
||
)
|
||
|
||
async def test_abandon_controlling_same_block_as_new_claim(self):
|
||
name = 'derp'
|
||
|
||
first_claim_id = (await self.stream_create(name, '0.1'))['outputs'][0]['claim_id']
|
||
await self.generate(64)
|
||
await self.assertNameState(271, name, first_claim_id, last_takeover_height=207, non_winning_claims=[])
|
||
|
||
await self.daemon.jsonrpc_txo_spend(type='stream', claim_id=first_claim_id)
|
||
second_claim_id = (await self.stream_create(name, '0.1', allow_duplicate_name=True))['outputs'][0]['claim_id']
|
||
await self.assertNameState(272, name, second_claim_id, last_takeover_height=272, non_winning_claims=[])
|
||
|
||
async def test_trending(self):
|
||
async def get_trending_score(claim_id):
|
||
return (await self.conductor.spv_node.server.session_manager.search_index.search(
|
||
claim_id=claim_id
|
||
))[0][0]['trending_score']
|
||
|
||
claim_id1 = (await self.stream_create('derp', '1.0'))['outputs'][0]['claim_id']
|
||
COIN = int(1E8)
|
||
|
||
self.assertEqual(self.conductor.spv_node.writer.height, 207)
|
||
self.conductor.spv_node.writer.db.prefix_db.trending_notification.stage_put(
|
||
(208, bytes.fromhex(claim_id1)), (0, 10 * COIN)
|
||
)
|
||
await self.generate(1)
|
||
self.assertEqual(self.conductor.spv_node.writer.height, 208)
|
||
|
||
self.assertEqual(1.7090807854206793, await get_trending_score(claim_id1))
|
||
self.conductor.spv_node.writer.db.prefix_db.trending_notification.stage_put(
|
||
(209, bytes.fromhex(claim_id1)), (10 * COIN, 100 * COIN)
|
||
)
|
||
await self.generate(1)
|
||
self.assertEqual(self.conductor.spv_node.writer.height, 209)
|
||
self.assertEqual(2.2437974397778886, await get_trending_score(claim_id1))
|
||
self.conductor.spv_node.writer.db.prefix_db.trending_notification.stage_put(
|
||
(309, bytes.fromhex(claim_id1)), (100 * COIN, 1000000 * COIN)
|
||
)
|
||
await self.generate(100)
|
||
self.assertEqual(self.conductor.spv_node.writer.height, 309)
|
||
self.assertEqual(5.157053472135866, await get_trending_score(claim_id1))
|
||
|
||
self.conductor.spv_node.writer.db.prefix_db.trending_notification.stage_put(
|
||
(409, bytes.fromhex(claim_id1)), (1000000 * COIN, 1 * COIN)
|
||
)
|
||
|
||
await self.generate(99)
|
||
self.assertEqual(self.conductor.spv_node.writer.height, 408)
|
||
self.assertEqual(5.157053472135866, await get_trending_score(claim_id1))
|
||
|
||
await self.generate(1)
|
||
self.assertEqual(self.conductor.spv_node.writer.height, 409)
|
||
|
||
self.assertEqual(-3.4256156592205627, await get_trending_score(claim_id1))
|
||
search_results = (await self.conductor.spv_node.server.session_manager.search_index.search(claim_name="derp"))[0]
|
||
self.assertEqual(1, len(search_results))
|
||
self.assertListEqual([claim_id1], [c['claim_id'] for c in search_results])
|
||
|
||
|
||
class ResolveAfterReorg(BaseResolveTestCase):
|
||
async def reorg(self, start):
|
||
blocks = self.ledger.headers.height - start
|
||
self.blockchain.block_expected = start - 1
|
||
|
||
|
||
prepare = self.ledger.on_header.where(self.blockchain.is_expected_block)
|
||
self.conductor.spv_node.server.synchronized.clear()
|
||
|
||
# go back to start
|
||
await self.blockchain.invalidate_block((await self.ledger.headers.hash(start)).decode())
|
||
# go to previous + 1
|
||
await self.blockchain.generate(blocks + 2)
|
||
|
||
await prepare # no guarantee that it didn't happen already, so start waiting from before calling generate
|
||
await self.conductor.spv_node.server.synchronized.wait()
|
||
# await asyncio.wait_for(self.on_header(self.blockchain.block_expected), 30.0)
|
||
|
||
async def assertBlockHash(self, height):
|
||
reader_db = self.conductor.spv_node.server.db
|
||
block_hash = await self.blockchain.get_block_hash(height)
|
||
|
||
self.assertEqual(block_hash, (await self.ledger.headers.hash(height)).decode())
|
||
self.assertEqual(block_hash, (await reader_db.fs_block_hashes(height, 1))[0][::-1].hex())
|
||
txids = [
|
||
tx_hash[::-1].hex() for tx_hash in reader_db.get_block_txs(height)
|
||
]
|
||
txs = await reader_db.get_transactions_and_merkles(txids)
|
||
block_txs = (await self.conductor.spv_node.server.daemon.deserialised_block(block_hash))['tx']
|
||
self.assertSetEqual(set(block_txs), set(txs.keys()), msg='leveldb/lbrycrd is missing transactions')
|
||
self.assertListEqual(block_txs, list(txs.keys()), msg='leveldb/lbrycrd transactions are of order')
|
||
|
||
async def test_reorg(self):
|
||
self.assertEqual(self.ledger.headers.height, 206)
|
||
|
||
channel_name = '@abc'
|
||
channel_id = self.get_claim_id(
|
||
await self.channel_create(channel_name, '0.01')
|
||
)
|
||
|
||
await self.assertNameState(
|
||
height=207, name='@abc', winning_claim_id=channel_id, last_takeover_height=207,
|
||
non_winning_claims=[]
|
||
)
|
||
|
||
await self.reorg(206)
|
||
|
||
await self.assertNameState(
|
||
height=208, name='@abc', winning_claim_id=channel_id, last_takeover_height=207,
|
||
non_winning_claims=[]
|
||
)
|
||
|
||
# await self.assertNoClaimForName(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)
|
||
)
|
||
|
||
await self.assertNameState(
|
||
height=209, name=stream_name, winning_claim_id=stream_id, last_takeover_height=209,
|
||
non_winning_claims=[]
|
||
)
|
||
await self.reorg(206)
|
||
await self.assertNameState(
|
||
height=210, name=stream_name, winning_claim_id=stream_id, last_takeover_height=209,
|
||
non_winning_claims=[]
|
||
)
|
||
|
||
await self.support_create(stream_id, '0.01')
|
||
|
||
await self.assertNameState(
|
||
height=211, name=stream_name, winning_claim_id=stream_id, last_takeover_height=209,
|
||
non_winning_claims=[]
|
||
)
|
||
await self.reorg(206)
|
||
# self.assertNotIn('error', await self.resolve(stream_name))
|
||
await self.assertNameState(
|
||
height=212, name=stream_name, winning_claim_id=stream_id, last_takeover_height=209,
|
||
non_winning_claims=[]
|
||
)
|
||
|
||
await self.stream_abandon(stream_id)
|
||
self.assertNotIn('error', await self.resolve(channel_name))
|
||
self.assertIn('error', await self.resolve(stream_name))
|
||
self.assertEqual(channel_id, (await self.assertMatchWinningClaim(channel_name)).claim_hash.hex())
|
||
await self.assertNoClaimForName(stream_name)
|
||
# TODO: check @abc/foo too
|
||
|
||
await self.reorg(206)
|
||
self.assertNotIn('error', await self.resolve(channel_name))
|
||
self.assertIn('error', await self.resolve(stream_name))
|
||
self.assertEqual(channel_id, (await self.assertMatchWinningClaim(channel_name)).claim_hash.hex())
|
||
await self.assertNoClaimForName(stream_name)
|
||
|
||
await self.channel_abandon(channel_id)
|
||
self.assertIn('error', await self.resolve(channel_name))
|
||
self.assertIn('error', await self.resolve(stream_name))
|
||
await self.reorg(206)
|
||
self.assertIn('error', await self.resolve(channel_name))
|
||
self.assertIn('error', await self.resolve(stream_name))
|
||
|
||
async def test_reorg_change_claim_height(self):
|
||
# sanity check
|
||
result = await self.resolve('hovercraft') # TODO: do these for claim_search and resolve both
|
||
self.assertIn('error', result)
|
||
|
||
still_valid = await self.daemon.jsonrpc_stream_create(
|
||
'still-valid', '1.0', file_path=self.create_upload_file(data=b'hi!')
|
||
)
|
||
await self.ledger.wait(still_valid)
|
||
await self.generate(1)
|
||
# create a claim and verify it's returned by claim_search
|
||
self.assertEqual(self.ledger.headers.height, 207)
|
||
await self.assertBlockHash(207)
|
||
|
||
broadcast_tx = await self.daemon.jsonrpc_stream_create(
|
||
'hovercraft', '1.0', file_path=self.create_upload_file(data=b'hi!')
|
||
)
|
||
await self.ledger.wait(broadcast_tx)
|
||
await self.support_create(still_valid.outputs[0].claim_id, '0.01')
|
||
|
||
await self.ledger.wait(broadcast_tx, self.blockchain.block_expected)
|
||
self.assertEqual(self.ledger.headers.height, 208)
|
||
await self.assertBlockHash(208)
|
||
|
||
claim = await self.resolve('hovercraft')
|
||
self.assertEqual(claim['txid'], broadcast_tx.id)
|
||
self.assertEqual(claim['height'], 208)
|
||
|
||
# check that our tx is in block 208 as returned by lbrycrdd
|
||
invalidated_block_hash = (await self.ledger.headers.hash(208)).decode()
|
||
block_207 = await self.blockchain.get_block(invalidated_block_hash)
|
||
self.assertIn(claim['txid'], block_207['tx'])
|
||
self.assertEqual(208, claim['height'])
|
||
|
||
# reorg the last block dropping our claim tx
|
||
await self.blockchain.invalidate_block(invalidated_block_hash)
|
||
await self.conductor.clear_mempool()
|
||
await self.blockchain.generate(2)
|
||
|
||
# wait for the client to catch up and verify the reorg
|
||
await asyncio.wait_for(self.on_header(209), 3.0)
|
||
await self.assertBlockHash(207)
|
||
await self.assertBlockHash(208)
|
||
await self.assertBlockHash(209)
|
||
|
||
# verify the claim was dropped from block 208 as returned by lbrycrdd
|
||
reorg_block_hash = await self.blockchain.get_block_hash(208)
|
||
self.assertNotEqual(invalidated_block_hash, reorg_block_hash)
|
||
block_207 = await self.blockchain.get_block(reorg_block_hash)
|
||
self.assertNotIn(claim['txid'], block_207['tx'])
|
||
|
||
client_reorg_block_hash = (await self.ledger.headers.hash(208)).decode()
|
||
self.assertEqual(client_reorg_block_hash, reorg_block_hash)
|
||
|
||
# verify the dropped claim is no longer returned by claim search
|
||
self.assertDictEqual(
|
||
{'error': {'name': 'NOT_FOUND', 'text': 'Could not find claim at "hovercraft".'}},
|
||
await self.resolve('hovercraft')
|
||
)
|
||
|
||
# verify the claim published a block earlier wasn't also reverted
|
||
self.assertEqual(207, (await self.resolve('still-valid'))['height'])
|
||
|
||
# broadcast the claim in a different block
|
||
new_txid = await self.blockchain.sendrawtransaction(hexlify(broadcast_tx.raw).decode())
|
||
self.assertEqual(broadcast_tx.id, new_txid)
|
||
await self.blockchain.generate(1)
|
||
|
||
# wait for the client to catch up
|
||
await asyncio.wait_for(self.on_header(210), 3.0)
|
||
|
||
# verify the claim is in the new block and that it is returned by claim_search
|
||
republished = await self.resolve('hovercraft')
|
||
self.assertEqual(210, republished['height'])
|
||
self.assertEqual(claim['claim_id'], republished['claim_id'])
|
||
|
||
# this should still be unchanged
|
||
self.assertEqual(207, (await self.resolve('still-valid'))['height'])
|
||
|
||
async def test_reorg_drop_claim(self):
|
||
# sanity check
|
||
result = await self.resolve('hovercraft') # TODO: do these for claim_search and resolve both
|
||
self.assertIn('error', result)
|
||
|
||
still_valid = await self.daemon.jsonrpc_stream_create(
|
||
'still-valid', '1.0', file_path=self.create_upload_file(data=b'hi!')
|
||
)
|
||
await self.ledger.wait(still_valid)
|
||
await self.generate(1)
|
||
|
||
# create a claim and verify it's returned by claim_search
|
||
self.assertEqual(self.ledger.headers.height, 207)
|
||
await self.assertBlockHash(207)
|
||
|
||
broadcast_tx = await self.daemon.jsonrpc_stream_create(
|
||
'hovercraft', '1.0', file_path=self.create_upload_file(data=b'hi!')
|
||
)
|
||
await self.ledger.wait(broadcast_tx)
|
||
await self.generate(1)
|
||
await self.ledger.wait(broadcast_tx, self.blockchain.block_expected)
|
||
self.assertEqual(self.ledger.headers.height, 208)
|
||
await self.assertBlockHash(208)
|
||
|
||
claim = await self.resolve('hovercraft')
|
||
self.assertEqual(claim['txid'], broadcast_tx.id)
|
||
self.assertEqual(claim['height'], 208)
|
||
|
||
# check that our tx is in block 208 as returned by lbrycrdd
|
||
invalidated_block_hash = (await self.ledger.headers.hash(208)).decode()
|
||
block_207 = await self.blockchain.get_block(invalidated_block_hash)
|
||
self.assertIn(claim['txid'], block_207['tx'])
|
||
self.assertEqual(208, claim['height'])
|
||
|
||
# reorg the last block dropping our claim tx
|
||
await self.blockchain.invalidate_block(invalidated_block_hash)
|
||
await self.conductor.clear_mempool()
|
||
await self.blockchain.generate(2)
|
||
|
||
# wait for the client to catch up and verify the reorg
|
||
await asyncio.wait_for(self.on_header(209), 30.0)
|
||
await self.assertBlockHash(207)
|
||
await self.assertBlockHash(208)
|
||
await self.assertBlockHash(209)
|
||
|
||
# verify the claim was dropped from block 208 as returned by lbrycrdd
|
||
reorg_block_hash = await self.blockchain.get_block_hash(208)
|
||
self.assertNotEqual(invalidated_block_hash, reorg_block_hash)
|
||
block_207 = await self.blockchain.get_block(reorg_block_hash)
|
||
self.assertNotIn(claim['txid'], block_207['tx'])
|
||
|
||
client_reorg_block_hash = (await self.ledger.headers.hash(208)).decode()
|
||
self.assertEqual(client_reorg_block_hash, reorg_block_hash)
|
||
|
||
# verify the dropped claim is no longer returned by claim search
|
||
self.assertDictEqual(
|
||
{'error': {'name': 'NOT_FOUND', 'text': 'Could not find claim at "hovercraft".'}},
|
||
await self.resolve('hovercraft')
|
||
)
|
||
|
||
# verify the claim published a block earlier wasn't also reverted
|
||
self.assertEqual(207, (await self.resolve('still-valid'))['height'])
|
||
|
||
# broadcast the claim in a different block
|
||
new_txid = await self.blockchain.sendrawtransaction(hexlify(broadcast_tx.raw).decode())
|
||
self.assertEqual(broadcast_tx.id, new_txid)
|
||
await self.blockchain.generate(1)
|
||
|
||
# wait for the client to catch up
|
||
await asyncio.wait_for(self.on_header(210), 1.0)
|
||
|
||
# verify the claim is in the new block and that it is returned by claim_search
|
||
republished = await self.resolve('hovercraft')
|
||
self.assertEqual(210, republished['height'])
|
||
self.assertEqual(claim['claim_id'], republished['claim_id'])
|
||
|
||
# this should still be unchanged
|
||
self.assertEqual(207, (await self.resolve('still-valid'))['height'])
|
||
|
||
|
||
def generate_signed_legacy(address: bytes, output: Output):
|
||
decoded_address = Base58.decode(address)
|
||
claim = OldClaimMessage()
|
||
claim.ParseFromString(unhexlify(
|
||
'080110011aee04080112a604080410011a2b4865726520617265203520526561736f6e73204920e29da4e'
|
||
'fb88f204e657874636c6f7564207c20544c4722920346696e64206f7574206d6f72652061626f7574204e'
|
||
'657874636c6f75643a2068747470733a2f2f6e657874636c6f75642e636f6d2f0a0a596f752063616e206'
|
||
'6696e64206d65206f6e20746865736520736f6369616c733a0a202a20466f72756d733a2068747470733a'
|
||
'2f2f666f72756d2e6865617679656c656d656e742e696f2f0a202a20506f64636173743a2068747470733'
|
||
'a2f2f6f6666746f706963616c2e6e65740a202a2050617472656f6e3a2068747470733a2f2f7061747265'
|
||
'6f6e2e636f6d2f7468656c696e757867616d65720a202a204d657263683a2068747470733a2f2f7465657'
|
||
'37072696e672e636f6d2f73746f7265732f6f6666696369616c2d6c696e75782d67616d65720a202a2054'
|
||
'77697463683a2068747470733a2f2f7477697463682e74762f786f6e64616b0a202a20547769747465723'
|
||
'a2068747470733a2f2f747769747465722e636f6d2f7468656c696e757867616d65720a0a2e2e2e0a6874'
|
||
'7470733a2f2f7777772e796f75747562652e636f6d2f77617463683f763d4672546442434f535f66632a0'
|
||
'f546865204c696e75782047616d6572321c436f7079726967687465642028636f6e746163742061757468'
|
||
'6f722938004a2968747470733a2f2f6265726b2e6e696e6a612f7468756d626e61696c732f46725464424'
|
||
'34f535f666352005a001a41080110011a30040e8ac6e89c061f982528c23ad33829fd7146435bf7a4cc22'
|
||
'f0bff70c4fe0b91fd36da9a375e3e1c171db825bf5d1f32209766964656f2f6d70342a5c080110031a406'
|
||
'2b2dd4c45e364030fbfad1a6fefff695ebf20ea33a5381b947753e2a0ca359989a5cc7d15e5392a0d354c'
|
||
'0b68498382b2701b22c03beb8dcb91089031b871e72214feb61536c007cdf4faeeaab4876cb397feaf6b51'
|
||
))
|
||
claim.ClearField("publisherSignature")
|
||
digest = sha256(b''.join([
|
||
decoded_address,
|
||
claim.SerializeToString(),
|
||
output.claim_hash[::-1]
|
||
]))
|
||
signature = output.private_key.sign_compact(digest)
|
||
claim.publisherSignature.version = 1
|
||
claim.publisherSignature.signatureType = 1
|
||
claim.publisherSignature.signature = signature
|
||
claim.publisherSignature.certificateId = output.claim_hash[::-1]
|
||
return claim
|