fix: detect name transfers and renewals in special circumstances (#1303)

* fix: take new owner from nft event

* fix: remove check on nft_custody view as it is no longer required

* fix: name-renewal with no zonefile hash

* fix: import v1 data during replay

* fix: headers already sent in redirect

* fix: import names first, subdomains last

Author: rafaelcr

src/api/routes/bns/names.ts

@@ -98,7 +98,6 @@ export function createBnsNamesRouter(db: DataStore, chainId: ChainID): express.R
               return;
             }
             res.redirect(`${resolverResult.result}/v1/names${req.url}`);
-            next();
             return;
           }
           res.status(404).json({ error: `cannot find subdomain ${name}` });

src/datastore/postgres-store.ts

@@ -1491,12 +1491,12 @@ export class PgDataStore
           for (const smartContract of entry.smartContracts) {
             await this.updateSmartContract(client, entry.tx, smartContract);
           }
-          for (const bnsName of entry.names) {
-            await this.updateNames(client, entry.tx, bnsName);
-          }
           for (const namespace of entry.namespaces) {
             await this.updateNamespaces(client, entry.tx, namespace);
           }
+          for (const bnsName of entry.names) {
+            await this.updateNames(client, entry.tx, bnsName);
+          }
         }
         await this.refreshNftCustody(client, batchedTxData);
         await this.refreshMaterializedView(client, 'chain_tip');
@@ -1701,12 +1701,12 @@ export class PgDataStore
       for (const smartContract of entry.smartContracts) {
         await this.updateSmartContract(client, entry.tx, smartContract);
       }
-      for (const bnsName of entry.names) {
-        await this.updateNames(client, entry.tx, bnsName);
-      }
       for (const namespace of entry.namespaces) {
         await this.updateNamespaces(client, entry.tx, namespace);
       }
+      for (const bnsName of entry.names) {
+        await this.updateNames(client, entry.tx, bnsName);
+      }
     }
   }
 
@@ -6896,8 +6896,59 @@ export class PgDataStore
       status,
       canonical,
     } = bnsName;
-    // inserting remaining names information in names table
-    const validZonefileHash = this.validateZonefileHash(zonefile_hash);
+    // Try to figure out the name's expiration block based on its namespace's lifetime. However, if
+    // the name was only transferred, keep the expiration from the last register/renewal we had.
+    let expireBlock = expire_block;
+    if (status === 'name-transfer') {
+      const prevExpiration = await client.query<{ expire_block: number }>(
+        `SELECT expire_block
+        FROM names
+        WHERE name = $1
+          AND canonical = TRUE AND microblock_canonical = TRUE
+        ORDER BY registered_at DESC, microblock_sequence DESC, tx_index DESC
+        LIMIT 1`,
+        [name]
+      );
+      if (prevExpiration.rowCount > 0) {
+        expireBlock = prevExpiration.rows[0].expire_block;
+      }
+    } else {
+      const namespaceLifetime = await client.query<{ lifetime: number }>(
+        `SELECT lifetime
+        FROM namespaces
+        WHERE namespace_id = $1
+        AND canonical = true AND microblock_canonical = true
+        ORDER BY namespace_id, ready_block DESC, microblock_sequence DESC, tx_index DESC
+        LIMIT 1`,
+        [namespace_id]
+      );
+      if (namespaceLifetime.rowCount > 0) {
+        expireBlock = registered_at + namespaceLifetime.rows[0].lifetime;
+      }
+    }
+    // If we didn't receive a zonefile, keep the last valid one.
+    let finalZonefile = zonefile;
+    let finalZonefileHash = zonefile_hash;
+    if (finalZonefileHash === '') {
+      const lastZonefile = await client.query<{ zonefile: string; zonefile_hash: string }>(
+        `
+        SELECT z.zonefile, z.zonefile_hash
+        FROM zonefiles AS z
+        INNER JOIN names AS n USING (name, tx_id, index_block_hash)
+        WHERE z.name = $1
+          AND n.canonical = TRUE
+          AND n.microblock_canonical = TRUE
+        ORDER BY n.registered_at DESC, n.microblock_sequence DESC, n.tx_index DESC
+        LIMIT 1
+        `,
+        [name]
+      );
+      if (lastZonefile.rowCount > 0) {
+        finalZonefile = lastZonefile.rows[0].zonefile;
+        finalZonefileHash = lastZonefile.rows[0].zonefile_hash;
+      }
+    }
+    const validZonefileHash = this.validateZonefileHash(finalZonefileHash);
     await client.query(
       `
         INSERT INTO zonefiles (name, zonefile, zonefile_hash, tx_id, index_block_hash)
@@ -6907,26 +6958,12 @@ export class PgDataStore
       `,
       [
         name,
-        zonefile,
+        finalZonefile,
         validZonefileHash,
         hexToBuffer(tx_id),
         hexToBuffer(blockData.index_block_hash),
       ]
     );
-    // Try to figure out the name's expiration block based on its namespace's lifetime.
-    const namespaceLifetime = await client.query<{ lifetime: number }>(
-      `SELECT lifetime
-      FROM namespaces
-      WHERE namespace_id = $1
-      AND canonical = true AND microblock_canonical = true
-      ORDER BY namespace_id, ready_block DESC, microblock_sequence DESC, tx_index DESC
-      LIMIT 1`,
-      [namespace_id]
-    );
-    const expireBlock =
-      namespaceLifetime.rowCount > 0
-        ? registered_at + namespaceLifetime.rows[0].lifetime
-        : expire_block;
     await client.query(
       `
         INSERT INTO names(
@@ -7221,32 +7258,6 @@ export class PgDataStore
       if (nameZonefile.rowCount === 0) {
         return;
       }
-      // The `names` and `zonefiles` tables only track latest zonefile changes. We need to check
-      // `nft_custody` for the latest name owner, but only for names that were NOT imported from v1
-      // since they did not generate an NFT event for us to track.
-      if (nameZonefile.rows[0].registered_at !== 1) {
-        let value: Buffer;
-        try {
-          value = bnsNameCV(name);
-        } catch (error) {
-          return;
-        }
-        const nameCustody = await client.query<{ recipient: string }>(
-          `
-          SELECT recipient
-          FROM ${includeUnanchored ? 'nft_custody_unanchored' : 'nft_custody'}
-          WHERE asset_identifier = $1 AND value = $2
-          `,
-          [getBnsSmartContractId(chainId), value]
-        );
-        if (nameCustody.rowCount === 0) {
-          return;
-        }
-        return {
-          ...nameZonefile.rows[0],
-          address: nameCustody.rows[0].recipient,
-        };
-      }
       return nameZonefile.rows[0];
     });
     if (queryResult) {

src/event-stream/bns/bns-helpers.ts

@@ -1,6 +1,11 @@
-import { ChainID, ClarityType, hexToCV } from '@stacks/transactions';
+import { BufferCV, ChainID, ClarityType, hexToCV, StringAsciiCV } from '@stacks/transactions';
 import { hexToBuffer, hexToUtf8String } from '../../helpers';
-import { CoreNodeParsedTxMessage } from '../../event-stream/core-node-message';
+import {
+  CoreNodeEvent,
+  CoreNodeEventType,
+  CoreNodeParsedTxMessage,
+  NftTransferEvent,
+} from '../../event-stream/core-node-message';
 import { getCoreNodeEndpoint } from '../../core-rpc/client';
 import { StacksMainnet, StacksTestnet } from '@stacks/network';
 import { URIType } from 'zone-file/dist/zoneFile';
@@ -244,10 +249,48 @@ function isEventFromBnsContract(event: SmartContractEvent): boolean {
   );
 }
 
+export function parseNameRenewalWithNoZonefileHashFromContractCall(
+  tx: CoreNodeParsedTxMessage,
+  chainId: ChainID
+): DbBnsName | undefined {
+  const payload = tx.parsed_tx.payload;
+  if (
+    payload.type_id === TxPayloadTypeID.ContractCall &&
+    payload.function_name === 'name-renewal' &&
+    getBnsContractID(chainId) === `${payload.address}.${payload.contract_name}` &&
+    payload.function_args.length === 5 &&
+    hexToCV(payload.function_args[4].hex).type === ClarityType.OptionalNone
+  ) {
+    const namespace = (hexToCV(payload.function_args[0].hex) as BufferCV).buffer.toString('utf8');
+    const name = (hexToCV(payload.function_args[1].hex) as BufferCV).buffer.toString('utf8');
+    return {
+      name: `${name}.${namespace}`,
+      namespace_id: namespace,
+      // NOTE: We're not using the `new_owner` argument here because there's a bug in the BNS
+      // contract that doesn't actually transfer the name to the given principal:
+      // https://github.com/stacks-network/stacks-blockchain/issues/2680, maybe this will be fixed
+      // in Stacks 2.1
+      address: tx.sender_address,
+      // expire_block will be calculated upon DB insert based on the namespace's lifetime.
+      expire_block: 0,
+      registered_at: tx.block_height,
+      // Since we received no zonefile_hash, the previous one will be reused when writing to DB.
+      zonefile_hash: '',
+      zonefile: '',
+      tx_id: tx.parsed_tx.tx_id,
+      tx_index: tx.core_tx.tx_index,
+      status: 'name-renewal',
+      canonical: true,
+    };
+  }
+}
+
 export function parseNameFromContractEvent(
   event: SmartContractEvent,
   tx: CoreNodeParsedTxMessage,
-  blockHeight: number
+  txEvents: CoreNodeEvent[],
+  blockHeight: number,
+  chainId: ChainID
 ): DbBnsName | undefined {
   if (!isEventFromBnsContract(event)) {
     return;
@@ -259,19 +302,21 @@ export function parseNameFromContractEvent(
     return;
   }
   let name_address = attachment.attachment.metadata.tx_sender.address;
-  // Is this a `name-transfer` contract call? If so, record the new owner.
-  if (
-    attachment.attachment.metadata.op === 'name-transfer' &&
-    tx.parsed_tx.payload.type_id === TxPayloadTypeID.ContractCall &&
-    tx.parsed_tx.payload.function_args.length >= 3 &&
-    tx.parsed_tx.payload.function_args[2].type_id === ClarityTypeID.PrincipalStandard
-  ) {
-    const decoded = decodeClarityValue(tx.parsed_tx.payload.function_args[2].hex);
-    const principal = decoded as ClarityValuePrincipalStandard;
-    name_address = principal.address;
+  // Is this a `name-transfer`? If so, look for the new owner in an `nft_transfer` event bundled in
+  // the same transaction.
+  if (attachment.attachment.metadata.op === 'name-transfer') {
+    for (const txEvent of txEvents) {
+      if (
+        txEvent.type === CoreNodeEventType.NftTransferEvent &&
+        txEvent.nft_transfer_event.asset_identifier === `${getBnsContractID(chainId)}::names`
+      ) {
+        name_address = txEvent.nft_transfer_event.recipient;
+        break;
+      }
+    }
   }
   const name: DbBnsName = {
-    name: attachment.attachment.metadata.name.concat('.', attachment.attachment.metadata.namespace),
+    name: `${attachment.attachment.metadata.name}.${attachment.attachment.metadata.namespace}`,
     namespace_id: attachment.attachment.metadata.namespace,
     address: name_address,
     // expire_block will be calculated upon DB insert based on the namespace's lifetime.

src/event-stream/core-node-message.ts

@@ -76,7 +76,7 @@ export interface StxLockEvent extends CoreNodeEventBase {
   };
 }
 
-interface NftTransferEvent extends CoreNodeEventBase {
+export interface NftTransferEvent extends CoreNodeEventBase {
   type: CoreNodeEventType.NftTransferEvent;
   nft_transfer_event: {
     /** Fully qualified asset ID, e.g. "ST2ZRX0K27GW0SP3GJCEMHD95TQGJMKB7G9Y0X1MH.contract-name.asset-name" */

src/event-stream/event-server.ts

@@ -63,7 +63,11 @@ import {
 } from 'stacks-encoding-native-js';
 import { ChainID } from '@stacks/transactions';
 import { BnsContractIdentifier } from './bns/bns-constants';
-import { parseNameFromContractEvent, parseNamespaceFromContractEvent } from './bns/bns-helpers';
+import {
+  parseNameFromContractEvent,
+  parseNameRenewalWithNoZonefileHashFromContractCall,
+  parseNamespaceFromContractEvent,
+} from './bns/bns-helpers';
 
 async function handleRawEventRequest(
   eventPath: string,
@@ -199,10 +203,15 @@ async function handleMicroblockMessage(
   });
   const updateData: DataStoreMicroblockUpdateData = {
     microblocks: dbMicroblocks,
-    txs: parseDataStoreTxEventData(parsedTxs, msg.events, {
-      block_height: -1, // TODO: fill during initial db insert
-      index_block_hash: '',
-    }),
+    txs: parseDataStoreTxEventData(
+      parsedTxs,
+      msg.events,
+      {
+        block_height: -1, // TODO: fill during initial db insert
+        index_block_hash: '',
+      },
+      chainId
+    ),
   };
   await db.updateMicroblocks(updateData);
 }
@@ -299,7 +308,7 @@ async function handleBlockMessage(
     block: dbBlock,
     microblocks: dbMicroblocks,
     minerRewards: dbMinerRewards,
-    txs: parseDataStoreTxEventData(parsedTxs, msg.events, msg),
+    txs: parseDataStoreTxEventData(parsedTxs, msg.events, msg, chainId),
   };
 
   await db.update(dbData);
@@ -311,7 +320,8 @@ function parseDataStoreTxEventData(
   blockData: {
     block_height: number;
     index_block_hash: string;
-  }
+  },
+  chainId: ChainID
 ): DataStoreTxEventData[] {
   const dbData: DataStoreTxEventData[] = parsedTxs.map(tx => {
     const dbTx: DataStoreBlockUpdateData['txs'][number] = {
@@ -325,16 +335,29 @@ function parseDataStoreTxEventData(
       names: [],
       namespaces: [],
     };
-    if (tx.parsed_tx.payload.type_id === TxPayloadTypeID.SmartContract) {
-      const contractId = `${tx.sender_address}.${tx.parsed_tx.payload.contract_name}`;
-      dbTx.smartContracts.push({
-        tx_id: tx.core_tx.txid,
-        contract_id: contractId,
-        block_height: blockData.block_height,
-        source_code: tx.parsed_tx.payload.code_body,
-        abi: JSON.stringify(tx.core_tx.contract_abi),
-        canonical: true,
-      });
+    switch (tx.parsed_tx.payload.type_id) {
+      case TxPayloadTypeID.SmartContract:
+        const contractId = `${tx.sender_address}.${tx.parsed_tx.payload.contract_name}`;
+        dbTx.smartContracts.push({
+          tx_id: tx.core_tx.txid,
+          contract_id: contractId,
+          block_height: blockData.block_height,
+          source_code: tx.parsed_tx.payload.code_body,
+          abi: JSON.stringify(tx.core_tx.contract_abi),
+          canonical: true,
+        });
+        break;
+      case TxPayloadTypeID.ContractCall:
+        // Name renewals can happen without a zonefile_hash. In that case, the BNS contract does NOT
+        // emit a `name-renewal` contract log, causing us to miss this event. This function catches
+        // those cases.
+        const name = parseNameRenewalWithNoZonefileHashFromContractCall(tx, chainId);
+        if (name) {
+          dbTx.names.push(name);
+        }
+        break;
+      default:
+        break;
     }
     return dbTx;
   });
@@ -372,7 +395,13 @@ function parseDataStoreTxEventData(
         if (!parsedTx) {
           throw new Error(`Unexpected missing tx during BNS parsing by tx_id ${event.txid}`);
         }
-        const name = parseNameFromContractEvent(event, parsedTx, blockData.block_height);
+        const name = parseNameFromContractEvent(
+          event,
+          parsedTx,
+          events,
+          blockData.block_height,
+          chainId
+        );
         if (name) {
           dbTx.names.push(name);
         }