feat: cache / expire uAgent almanac resolutions

schema.graphql

@@ -192,6 +192,13 @@ type AlmanacRecord @entity {
   block: Block!
 }
 
+type AlmanacResolution @entity {
+  id: ID!
+  agent: Agent!
+  contract: Contract!
+  record: AlmanacRecord!
+}
+
 type AlmanacRegistration @entity {
   id: ID!
   expiryHeight: BigInt! @index

src/genesis/helpers/field_enums.py

@@ -324,23 +324,35 @@ class AlmanacRegistrations(NamedFields):
     signature = 2
     sequence = 3
     agent_id = 4
-    record_id = 5
-    transaction_id = 6
-    block_id = 7
-    #     event_id = 8
-    #     record_id = 9
+    contract_id = 5
+    record_id = 6
+    transaction_id = 7
+    block_id = 8
+    # event_id = 9
+    # record_id = 10
 
     @classmethod
     def get_table(self):
         return "almanac_registrations"
 
 
+class AlmanacResolutions(NamedFields):
+    id = 0
+    agent_id = 1
+    contract_id = 2
+    record_id = 3
+
+    @classmethod
+    def get_table(self):
+        return "almanac_resolutions"
+
+
 class AlmanacRecords(NamedFields):
     id = 0
     service = 1
     transaction_id = 2
     block_id = 3
-    #     event_id = 4
+    # event_id = 4
 
     @classmethod
     def get_table(self):

src/mappings/almanac/registrations.ts

@@ -7,6 +7,7 @@ import {
 } from "../utils";
 import {CosmosEvent} from "@subql/types-cosmos";
 import {Agent, AlmanacRecord, AlmanacRegistration, Contract} from "../../types";
+import {cacheAlmanacResolution} from "./resolutions";
 
 export async function handleAlmanacRegistration(event: CosmosEvent): Promise<void> {
   await attemptHandling(event, _handleAlmanacRegistration, unprocessedEventHandler);
@@ -107,4 +108,5 @@ async function _handleAlmanacRegistration(event: CosmosEvent): Promise<void> {
     blockId: event.block.block.id,
   });
   await registrationEntity.save();
+  await cacheAlmanacResolution(_contract_address, agent_address, recordEntity);
 }

src/mappings/almanac/resolutions.ts

@@ -0,0 +1,40 @@
+import {AlmanacRecord, AlmanacResolution, Contract, Interface,} from "../../types";
+
+export async function cacheAlmanacResolution(contractId: string, agentId: string, record: AlmanacRecord): Promise<void> {
+  try {
+    logger.info(`[cacheAlmanacResolution] (recordId: ${record.id}): caching record`);
+    const resolutionEntity = AlmanacResolution.create({
+      id: record.id,
+      agentId,
+      contractId,
+      recordId: record.id,
+    });
+    await resolutionEntity.save();
+  } catch (error) {
+    logger.error(`[cacheAlmanacResolution] (recordId: ${record.id}): ${error.stack}`);
+  }
+}
+
+export async function expireAlmanacResolutionsRelativeToHeight(height: bigint): Promise<void> {
+  // NB: resolution, record, and registration ID are the same across related entities.
+  const expiringResolutionIdsSql = `SELECT res.id
+                              FROM app.almanac_resolutions res
+                              JOIN app.almanac_registrations reg
+                                ON res.id = reg.id
+                              WHERE reg.expiry_height <= ${height}
+  `;
+  const expiringResolutionIds = await store.selectRaw(expiringResolutionIdsSql);
+
+  // NB: will throw an error if any promise rejects.
+  await Promise.all(expiringResolutionIds.map(r => expireAlmanacResolution(String(r.id))));
+}
+
+export async function expireAlmanacResolution(id: string): Promise<void> {
+  try {
+    logger.info(`[expireAlmanacResolution] (recordId: ${id}): expiring record`);
+    await AlmanacResolution.remove(id);
+  } catch (error) {
+    logger.warn(`[expireAlmanacResolution] (recordId: ${id}): ${error.stack}`);
+  }
+}
+

src/mappings/primitives.ts

@@ -10,6 +10,7 @@ import {
 } from "./utils";
 import {createHash} from "crypto";
 import {toBech32} from "@cosmjs/encoding";
+import {expireAlmanacResolutionsRelativeToHeight} from "./almanac/resolutions";
 
 export async function handleBlock(block: CosmosBlock): Promise<void> {
   await attemptHandling(block, _handleBlock, _handleBlockError);
@@ -30,16 +31,18 @@ export async function handleEvent(event: CosmosEvent): Promise<void> {
 async function _handleBlock(block: CosmosBlock): Promise<void> {
   logger.info(`[handleBlock] (block.header.height): indexing block ${block.block.header.height}`);
 
-  const {id, header: {chainId, height, time}} = block.block;
+  const {id, header: {chainId, height: _height, time}} = block.block;
   const timestamp = new Date(time);
+  const height = BigInt(_height);
   const blockEntity = Block.create({
     id,
     chainId,
-    height: BigInt(height),
+    height,
     timestamp
   });
 
   await blockEntity.save();
+  await expireAlmanacResolutionsRelativeToHeight(height);
 }
 
 async function _handleTransaction(tx: CosmosTransaction): Promise<void> {

src/mappings/utils.ts

@@ -2,6 +2,10 @@ import {CosmosBlock, CosmosEvent, CosmosMessage, CosmosTransaction} from "@subql
 import {Account, Interface, UnprocessedEntity} from "../types";
 import {createHash} from "crypto";
 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;
 
@@ -29,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
@@ -116,60 +121,6 @@ export async function trackUnprocessed(error: Error, primitives: Primitives): Pr
   }
 }
 
-class Structure {
-  static getInterface() {
-    return Interface.Uncertain;
-  }
-}
-
-class CW20Structure extends Structure {
-  private name = "";
-  private symbol = "";
-  private decimals = 0;
-  private initial_balances: [{ amount: bigint, address: string }] = [{amount: BigInt(0), address: ""}];
-  private mint: { minter: string } = {minter: ""};
-
-  static listProperties() {
-    const a = new CW20Structure();
-    return Object.getOwnPropertyNames(a);
-  }
-
-  static getPropertyType(prop: string) {
-    const a = new CW20Structure();
-    return typeof (a[prop]);
-  }
-
-  static getInterface() {
-    return Interface.CW20;
-  }
-}
-
-class LegacyBridgeSwapStructure extends Structure {
-  private cap = BigInt(0);
-  private reverse_aggregated_allowance = BigInt(0);
-  private reverse_aggregated_allowance_approver_cap = BigInt(0);
-  private lower_swap_limit = BigInt(0);
-  private upper_swap_limit = BigInt(0);
-  private swap_fee = BigInt(0);
-  private paused_since_block = BigInt(0);
-  private denom = "";
-  private next_swap_id = "";
-
-  static listProperties() {
-    const a = new LegacyBridgeSwapStructure();
-    return Object.getOwnPropertyNames(a);
-  }
-
-  static getPropertyType(prop: string) {
-    const a = new LegacyBridgeSwapStructure();
-    return typeof (a[prop]);
-  }
-
-  static getInterface() {
-    return Interface.LegacyBridgeSwap;
-  }
-}
-
 export interface BaseEventAttributesI {
   action: string;
 }