fix: missing InactiveNameOwner record (#598)

Author: jyeshe

lib/ae_mdw/db/name.ex

@@ -119,17 +119,9 @@ defmodule AeMdw.Db.Name do
   @spec expire_name(transaction(), Blocks.height(), Names.plain_name()) :: :ok
   def expire_name(txn, height, plain_name) do
     m_name = cache_through_read!(txn, Model.ActiveName, plain_name)
-    m_exp = Model.expiration(index: {height, plain_name})
 
     if Model.name(m_name, :expire) == height do
-      owner = Model.name(m_name, :owner)
-      cache_through_write(txn, Model.InactiveName, m_name)
-      cache_through_write(txn, Model.InactiveNameOwner, Model.owner(index: {owner, plain_name}))
-      cache_through_write(txn, Model.InactiveNameExpiration, m_exp)
-      cache_through_delete(txn, Model.ActiveName, plain_name)
-      cache_through_delete(txn, Model.ActiveNameOwner, {owner, plain_name})
-      cache_through_delete(txn, Model.ActiveNameExpiration, {height, plain_name})
-
+      deactivate_name(txn, height, m_name)
       Ets.inc(:stat_sync_cache, :names_expired)
     else
       cache_through_delete(txn, Model.ActiveNameExpiration, {height, plain_name})
@@ -325,17 +317,10 @@ defmodule AeMdw.Db.Name do
     end
   end
 
-  @spec revoke_or_expire_height(nil | {Blocks.block_index(), AeMdw.Txs.txi()}, Blocks.height()) ::
-          Blocks.height()
-  def revoke_or_expire_height(nil = _revoke, expire),
-    do: expire
-
-  def revoke_or_expire_height({{height, _}, _}, _expire),
-    do: height
-
   @spec revoke_or_expire_height(Model.name()) :: Blocks.height()
-  def revoke_or_expire_height(m_name),
-    do: revoke_or_expire_height(Model.name(m_name, :revoke), Model.name(m_name, :expire))
+  def revoke_or_expire_height(m_name) do
+    revoke_or_expire_height(Model.name(m_name, :revoke), Model.name(m_name, :expire))
+  end
 
   @spec cache_through_read(table(), cache_key()) :: {:ok, name_record()} | nil
   def cache_through_read(table, key) do
@@ -435,9 +420,37 @@ defmodule AeMdw.Db.Name do
     :ok
   end
 
+  @spec deactivate_name(transaction(), Blocks.height(), Model.name()) :: :ok
+  def deactivate_name(
+        txn,
+        deactivate_height,
+        Model.name(index: plain_name, owner: owner_pk) = m_name
+      ) do
+    cache_through_delete_active(txn, m_name)
+
+    m_exp = Model.expiration(index: {deactivate_height, plain_name})
+    m_owner = Model.owner(index: {owner_pk, plain_name})
+
+    cache_through_write(txn, Model.InactiveName, m_name)
+    cache_through_write(txn, Model.InactiveNameExpiration, m_exp)
+    cache_through_write(txn, Model.InactiveNameOwner, m_owner)
+  end
+
   #
   # Private functions
   #
+  defp revoke_or_expire_height(nil = _revoke, expire), do: expire
+  defp revoke_or_expire_height({{revoke_height, _}, _}, _expire), do: revoke_height
+
+  defp cache_through_delete_active(
+         txn,
+         Model.name(index: plain_name, expire: expire, owner: owner_pk)
+       ) do
+    cache_through_delete(txn, Model.ActiveName, plain_name)
+    cache_through_delete(txn, Model.ActiveNameOwner, {owner_pk, plain_name})
+    cache_through_delete(txn, Model.ActiveNameExpiration, {expire, plain_name})
+  end
+
   defp pointer_kv_raw(ptr),
     do: {:aens_pointer.key(ptr), :aens_pointer.id(ptr)}
 

lib/ae_mdw/db/sync/name.ex

@@ -23,8 +23,8 @@ defmodule AeMdw.Db.Sync.Name do
       cache_through_read: 3,
       cache_through_write: 3,
       cache_through_delete: 3,
-      revoke_or_expire_height: 1,
-      revoke_or_expire_height: 2
+      deactivate_name: 3,
+      revoke_or_expire_height: 1
     ]
 
   import AeMdw.Db.Util
@@ -81,12 +81,7 @@ defmodule AeMdw.Db.Sync.Name do
         log_name_change(height, plain_name, "extend")
 
       delta_ttl == 0 and not internal? ->
-        owner = Model.name(m_name, :owner)
-        cache_through_delete(txn, Model.ActiveName, plain_name)
-        cache_through_delete(txn, Model.ActiveNameOwner, {owner, plain_name})
-        cache_through_delete(txn, Model.ActiveNameExpiration, {old_expire, plain_name})
-        cache_through_write(txn, Model.InactiveName, new_m_name)
-        cache_through_write(txn, Model.InactiveNameExpiration, new_m_name_exp)
+        deactivate_name(txn, height, new_m_name)
 
         inc(:stat_sync_cache, :names_expired)
 
@@ -123,16 +118,8 @@ defmodule AeMdw.Db.Sync.Name do
     plain_name = plain_name!(name_hash)
 
     m_name = cache_through_read!(txn, Model.ActiveName, plain_name)
-    expire = Model.name(m_name, :expire)
-    owner = Model.name(m_name, :owner)
-    cache_through_delete(txn, Model.ActiveNameExpiration, {expire, plain_name})
-    cache_through_delete(txn, Model.ActiveNameOwner, {owner, plain_name})
-    cache_through_delete(txn, Model.ActiveName, plain_name)
-
     m_name = Model.name(m_name, revoke: {bi, txi})
-    m_exp = Model.expiration(index: {height, plain_name})
-    cache_through_write(txn, Model.InactiveName, m_name)
-    cache_through_write(txn, Model.InactiveNameExpiration, m_exp)
+    deactivate_name(txn, height, m_name)
 
     inc(:stat_sync_cache, :names_revoked)
 
@@ -302,7 +289,7 @@ defmodule AeMdw.Db.Sync.Name do
 
     cond do
       new_height >= active ->
-        expire = revoke_or_expire_height(Model.name(m_name, :revoke), Model.name(m_name, :expire))
+        expire = revoke_or_expire_height(m_name)
         lfcycle = (new_height < expire && :active) || :inactive
         updates = drop_bi_txi(Model.name(m_name, :updates), new_height)
         transfers = drop_bi_txi(Model.name(m_name, :transfers), new_height)

test/ae_mdw/db/name_claim_mutation_test.exs

@@ -0,0 +1,78 @@
+defmodule AeMdw.Db.NameClaimMutationTest do
+  use ExUnit.Case
+
+  alias AeMdw.Database
+  alias AeMdw.Db.Model
+  alias AeMdw.Db.Sync
+
+  import Mock
+
+  require Model
+
+  test "claim an inactive name with timeout 0" do
+    plain_name = "claim.test"
+
+    new_owner_pk =
+      <<11, 180, 237, 121, 39, 249, 123, 81, 225, 188, 181, 225, 52, 13, 18, 51, 91, 42, 43, 18,
+        200, 188, 82, 33, 214, 60, 75, 203, 57, 212, 30, 97>>
+
+    tx =
+      {:ns_claim_tx, {:id, :account, new_owner_pk}, 11_251, plain_name, 7, :prelima,
+       1_000_000_000_000_000, 0}
+
+    tx_hash =
+      <<159, 240, 103, 205, 63, 165, 186, 153, 226, 186, 128, 241, 61, 192, 66, 89, 156, 217, 200,
+        247, 31, 137, 16, 129, 250, 190, 199, 100, 137, 179, 112, 165>>
+
+    claim_height = 200
+    old_claim_height = 100
+    old_claims = [{{old_claim_height, 1}, 123}]
+    owner_pk = <<8435::256>>
+    block_index = {claim_height, 0}
+    txi = 223
+
+    inactive_name =
+      Model.name(
+        index: plain_name,
+        active: old_claim_height,
+        expire: 199,
+        claims: old_claims,
+        updates: [{{150, 0}, 173}],
+        owner: owner_pk,
+        previous: nil
+      )
+
+    Database.dirty_write(Model.InactiveName, inactive_name)
+
+    Database.dirty_write(
+      Model.InactiveNameExpiration,
+      Model.expiration(index: {199, plain_name})
+    )
+
+    Database.dirty_write(
+      Model.InactiveNameOwner,
+      Model.owner(index: {owner_pk, plain_name})
+    )
+
+    with_mocks [
+      {AeMdw.Db.Util, [], [proto_vsn: fn _height -> 3 end]}
+    ] do
+      tx
+      |> Sync.Name.name_claim_mutations(tx_hash, block_index, txi)
+      |> Database.commit()
+    end
+
+    assert {:ok,
+            Model.name(
+              index: ^plain_name,
+              active: ^claim_height,
+              claims: [{block_index, txi} | old_claims],
+              expire: expire,
+              owner: ^new_owner_pk,
+              updates: []
+            )} = Database.fetch(Model.ActiveName, plain_name)
+
+    assert Database.exists?(Model.ActiveNameExpiration, {expire, plain_name})
+    assert Database.exists?(Model.ActiveNameOwner, {new_owner_pk, plain_name})
+  end
+end

test/ae_mdw/db/name_revoke_mutation_test.exs

@@ -0,0 +1,62 @@
+defmodule AeMdw.Db.NameRevokeMutationTest do
+  use ExUnit.Case
+
+  alias AeMdw.Database
+  alias AeMdw.Db.Model
+  alias AeMdw.Db.NameRevokeMutation
+
+  require Model
+
+  test "revoke a active name" do
+    plain_name = "revoke.test"
+
+    name_hash =
+      case :aens.get_name_hash(plain_name) do
+        {:ok, name_id_bin} -> :aeser_api_encoder.encode(:name, name_id_bin)
+        _error -> nil
+      end
+
+    revoke_height = 3
+    revoke_block_index = {revoke_height, 0}
+    revoke_txi = 124
+
+    expire = 100
+    owner_pk = <<538_053::256>>
+
+    active_name =
+      Model.name(
+        index: plain_name,
+        active: 1,
+        expire: expire,
+        claims: [{{1, 0}, 123}],
+        updates: [],
+        transfers: [],
+        revoke: nil,
+        owner: owner_pk,
+        previous: nil
+      )
+
+    Database.dirty_write(Model.PlainName, Model.plain_name(index: name_hash, value: plain_name))
+    Database.dirty_write(Model.ActiveName, active_name)
+
+    Database.dirty_write(
+      Model.ActiveNameExpiration,
+      Model.expiration(index: {expire, plain_name})
+    )
+
+    Database.dirty_write(Model.ActiveNameOwner, Model.owner(index: {owner_pk, plain_name}))
+
+    Database.commit([NameRevokeMutation.new(name_hash, revoke_txi, revoke_block_index)])
+
+    assert {:ok,
+            Model.name(
+              index: ^plain_name,
+              expire: ^expire,
+              owner: ^owner_pk,
+              revoke: {^revoke_block_index, ^revoke_txi}
+            )} = Database.fetch(Model.InactiveName, plain_name)
+
+    assert Database.exists?(Model.InactiveNameExpiration, {revoke_height, plain_name})
+    assert Database.exists?(Model.InactiveNameOwner, {owner_pk, plain_name})
+  end
+end