wip: resolutions handler

(cherry picked from commit 0821694c105d3bfb71d04a19d7530ffe636b8dc6)

Author: bryanchriswhite

src/mappings/almanac/resolutions.ts

@@ -1,9 +1,17 @@
-import {AlmanacRecord, AlmanacResolution, Block, Event, Transaction} from "../../types";
+import {
+  AlmanacRecord,
+  AlmanacResolution,
+  Block,
+  Contract,
+  Event, EventAttribute,
+  InstantiateContractMessage,
+  Interface,
+} from "../../types";
 import {parseAttributes, WasmdEventAttributesI} from "../utils";
 
 export async function cacheAlmanacResolution(contractId: string, agentId: string, record: AlmanacRecord): Promise<void> {
   try {
-    logger.info(`[cacheAlmanacResolution] (recordId ${record.id}): caching record`);
+    logger.info(`[cacheAlmanacResolution] (recordId: ${record.id}): caching record`);
     const resolutionEntity = AlmanacResolution.create({
       id: record.id,
       agentId,
@@ -17,39 +25,59 @@ export async function cacheAlmanacResolution(contractId: string, agentId: string
 }
 
 export async function expireAlmanacResolutionsRelativeToHeight(height: bigint): Promise<void> {
-  /* for contract in almanac contracts {
-   *    expiryHeight = contract.expiryHeight
-   * }
-   */
-
-  const blocks = await Block.getByHeight(BigInt(height));
-  // const blocks = await Block.getByHeight(BigInt(expiryHeight));
-  if (!blocks || blocks.length !== 1) {
-    logger.error(`[expireAlmanacResolutionAtHeight] (height: ${height}): found ${blocks?.length ?? 0} blocks at that height`);
-  }
+  // TODO: optimize with custom `Store` methods exposing more sequelize functionality.
+  const almanacContracts = await store.getByField("Contract", "interface", Interface.MicroAgentAlmanac) as Contract[];
 
-  const events = await Event.getByBlockId(blocks[0].id);
-  if (!events || events.length !== 1) {
-    logger.error(`[expireAlmanacResolutionAtHeight] (height: ${height}): found ${events?.length ?? 0} events at that height`);
-  }
+  for (const contract of almanacContracts) {
+    const instantiateMsg = await InstantiateContractMessage.get(contract.instantiateMessageId);
+    try {
+      const {expiry_height} = JSON.parse(instantiateMsg.payload);
+      if (!expiry_height) {
+        logger.warn(`[expireAlmanacResolutionsRelativeToHeight] (height: ${height}): falsey expiry_height: ${expiry_height}`);
+        continue;
+      }
 
-  for (const event of events) {
-    const attributes = parseAttributes<WasmdEventAttributesI>(event.attributes);
-    if (!attributes.action || attributes.action !== "register") {
-      continue;
-    }
+      const blocks = await Block.getByHeight(BigInt(expiry_height));
+      if (!blocks || blocks.length !== 1) {
+        logger.error(`[expireAlmanacResolutionAtHeight] (height: ${height}): found ${blocks?.length ?? 0} blocks at that height`);
+        continue;
+      }
+
+      const events = await Event.getByBlockId(blocks[0].id);
+      if (!events || events.length !== 1) {
+        logger.error(`[expireAlmanacResolutionAtHeight] (height: ${height}): found ${events?.length ?? 0} events at that height`);
+        continue;
+      }
 
-    // NB: recordId is equivalent to ID of register event.
-    await expireAlmanacResolution(event.id);
+      // TODO: consider relating EventAttributes to Blocks to reduce # of serial lookups.
+      for (const event of events) {
+        const eventAttributes = await EventAttribute.getByEventId(event.id);
+        if (!events || events.length !== 1) {
+          logger.error(`[expireAlmanacResolutionAtHeight] (height: ${height}): found ${eventAttributes?.length ?? 0} event attributes with event ID: ${event.id}`);
+          continue;
+        }
+
+        const attributes = parseAttributes<WasmdEventAttributesI>(eventAttributes);
+        if (!attributes.action || attributes.action !== "register") {
+          logger.warn(`[expireAlmanacResolutionsRelativeToHeight] (height: ${height}): expected "register" action, got: ${attributes.action}`);
+          continue;
+        }
+
+        // NB: resolution ID is equivalent to register event ID.
+        await expireAlmanacResolution(event.id);
+      }
+    } catch (error) {
+      logger.warn(`[expireAlmanacResolutionsRelativeToHeight] (height: ${height}): unable to parse instantiate message payload`);
+    }
   }
 }
 
-export async function expireAlmanacResolution(recordId: string): Promise<void> {
+export async function expireAlmanacResolution(id: string): Promise<void> {
   try {
-    logger.info(`[expireAlmanacResolution] (recordId ${recordId}): expiring record`);
-    await AlmanacResolution.remove(recordId);
+    logger.info(`[expireAlmanacResolution] (recordId: ${id}): expiring record`);
+    await AlmanacResolution.remove(id);
   } catch (error) {
-    logger.warn(`[expireAlmanacResolution] (recordId: ${recordId}): ${error.stack}`);
+    logger.warn(`[expireAlmanacResolution] (recordId: ${id}): ${error.stack}`);
   }
 }
 

src/mappings/primitives.ts

@@ -10,7 +10,7 @@ import {
 } from "./utils";
 import {createHash} from "crypto";
 import {toBech32} from "@cosmjs/encoding";
-import {expireAlmanacResolutionsRelativeToHeight} from "./almanac/resolutions";
+// import {expireAlmanacResolutionsRelativeToHeight} from "./almanac/resolutions";
 
 export async function handleBlock(block: CosmosBlock): Promise<void> {
   await attemptHandling(block, _handleBlock, _handleBlockError);
@@ -42,7 +42,7 @@ async function _handleBlock(block: CosmosBlock): Promise<void> {
   });
 
   await blockEntity.save();
-  await expireAlmanacResolutionsAtHeight(height);
+  // await expireAlmanacResolutionsAtHeight(height);
 }
 
 async function _handleTransaction(tx: CosmosTransaction): Promise<void> {

src/mappings/utils.ts

@@ -5,6 +5,7 @@ import {Attribute} from "@cosmjs/stargate/build/logs";
 import {LegacyBridgeSwapStructure} from "./wasm/contracts/bridge";
 import {CW20Structure} from "./wasm/contracts/cw20";
 import {Structure} from "./wasm/contracts/types";
+import {MicroAgentAlmanacStructure} from "./wasm/contracts/almanac";
 
 export type Primitive = CosmosEvent | CosmosMessage | CosmosTransaction | CosmosBlock;
 
@@ -32,7 +33,8 @@ export async function checkBalancesAccount(address: string, chainId: string) {
 export function getJaccardResult(payload: object): Interface {
   let prediction = Structure, prediction_coefficient = 0.5;   // prediction coefficient can be set as a minimum threshold for the certainty of an output
   let diff = 0, match = 0, coefficient = 0;                   // where coefficient of 1 is a perfect property key match, 2 is a perfect match of property and type
-  const structs = [CW20Structure, LegacyBridgeSwapStructure];
+  // TODO: refactor
+  const structs = [CW20Structure, LegacyBridgeSwapStructure, MicroAgentAlmanacStructure];
   structs.forEach((struct) => {
     Object.keys(payload).forEach((payload_key) => {
       if (struct.listProperties().some((prop) => prop === payload_key)) { // If payload property exists as a property within current structure

tests/e2e/entities/test_almanac.py

@@ -1,13 +1,13 @@
 import time
 import unittest
 from dataclasses import dataclass
-from typing import Any, Dict, List, Tuple
+from typing import Dict, List, Tuple
 
 import graphql
 from cosmpy.aerial.tx_helpers import SubmittedTx
 from gql import gql
 
-from src.genesis.helpers.field_enums import Agents, AlmanacRecords, AlmanacRegistrations
+from src.genesis.helpers.field_enums import Agents, AlmanacRecords, AlmanacRegistrations, ContractFields
 from tests.helpers.contracts import AlmanacContract, DefaultAlmanacContractConfig
 from tests.helpers.entity_test import EntityTest
 from tests.helpers.graphql import filtered_test_query