diff --git a/tests/integration/blockchain/test_resolve_command.py b/tests/integration/blockchain/test_resolve_command.py
index f91c44940..089628f69 100644
--- a/tests/integration/blockchain/test_resolve_command.py
+++ b/tests/integration/blockchain/test_resolve_command.py
@@ -632,6 +632,82 @@ class ResolveClaimTakeovers(BaseResolveTestCase):
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.blockchain.send_to_address(address, 400.0)
+ await self.account.ledger.on_address.first
+ await self.generate(100)
+ self.assertEqual(800, self.conductor.spv_node.server.bp.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.bp.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.bp.db.fs_resolve(f"{name}:{claim_id_B}")
+ self.assertEqual(1121, self.conductor.spv_node.server.bp.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.bp.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.bp.db.db_height)
+ claim_C, _ = await self.conductor.spv_node.server.bp.db.fs_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.bp.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.bp.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.bp.db.db_height)
+ claim_D, _ = await self.conductor.spv_node.server.bp.db.fs_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.bp.db.db_height)
+ claim_D, _ = await self.conductor.spv_node.server.bp.db.fs_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