refactor: mapping handlers as ES6 modules (#137)

Author: bryanchriswhite

src/mappings/bank/balanceChange.ts

@@ -0,0 +1,79 @@
+import {CosmosEvent} from "@subql/types-cosmos";
+import {NativeBalanceChange} from "../../types";
+import {checkBalancesAccount, messageId, parseCoins} from "../utils";
+
+export async function saveNativeBalanceEvent(id: string, address: string, amount: BigInt, denom: string, event: CosmosEvent) {
+  await checkBalancesAccount(address, event.block.block.header.chainId);
+  const nativeBalanceChangeEntity = NativeBalanceChange.create({
+    id,
+    balanceOffset: amount.valueOf(),
+    denom,
+    accountId: address,
+    eventId: `${messageId(event)}-${event.idx}`,
+    blockId: event.block.block.id,
+    transactionId: event.tx.hash,
+  });
+  await nativeBalanceChangeEntity.save()
+}
+
+export async function handleNativeBalanceDecrement(event: CosmosEvent): Promise<void> {
+  logger.info(`[handleNativeBalanceDecrement] (tx ${event.tx.hash}): indexing event ${event.idx + 1} / ${event.tx.tx.events.length}`)
+  logger.debug(`[handleNativeBalanceDecrement] (event.event): ${JSON.stringify(event.event, null, 2)}`)
+  logger.debug(`[handleNativeBalanceDecrement] (event.log): ${JSON.stringify(event.log, null, 2)}`)
+
+  // sample event.event.attributes:
+  // [
+  //   {"key":"spender","value":"fetch1jv65s3grqf6v6jl3dp4t6c9t9rk99cd85zdctg"},
+  //   {"key":"amount","value":"75462013217046121atestfet"},
+  //   {"key":"spender","value":"fetch1wurz7uwmvchhc8x0yztc7220hxs9jxdjdsrqmn"},
+  //   {"key":"amount","value":"100atestfet"}
+  // ]
+  let spendEvents = [];
+  for (const [i, e] of Object.entries(event.event.attributes)) {
+    if (e.key !== "spender") {
+      continue
+    }
+    const spender = e.value;
+    const amountStr = event.event.attributes[parseInt(i) + 1].value;
+
+    const coin = parseCoins(amountStr)[0];
+    const amount = BigInt(0) - BigInt(coin.amount); // save a negative amount for a "spend" event
+    spendEvents.push({spender: spender, amount: amount, denom: coin.denom})
+  }
+  ;
+
+  for (const [i, spendEvent] of Object.entries(spendEvents)) {
+    await saveNativeBalanceEvent(`${messageId(event)}-spend-${i}`, spendEvent.spender, spendEvent.amount, spendEvent.denom, event);
+  }
+}
+
+export async function handleNativeBalanceIncrement(event: CosmosEvent): Promise<void> {
+  logger.info(`[handleNativeBalanceIncrement] (tx ${event.tx.hash}): indexing event ${event.idx + 1} / ${event.tx.tx.events.length}`)
+  logger.debug(`[handleNativeBalanceIncrement] (event.event): ${JSON.stringify(event.event, null, 2)}`)
+  logger.debug(`[handleNativeBalanceIncrement] (event.log): ${JSON.stringify(event.log, null, 2)}`)
+
+  // sample event.event.attributes:
+  // [
+  //   {"key":"receiver","value":"fetch1jv65s3grqf6v6jl3dp4t6c9t9rk99cd85zdctg"},
+  //   {"key":"amount","value":"75462013217046121atestfet"},
+  //   {"key":"receiver","value":"fetch1wurz7uwmvchhc8x0yztc7220hxs9jxdjdsrqmn"},
+  //   {"key":"amount","value":"100atestfet"}
+  // ]
+  let receiveEvents = [];
+  for (const [i, e] of Object.entries(event.event.attributes)) {
+    if (e.key !== "receiver") {
+      continue
+    }
+    const receiver = e.value;
+    const amountStr = event.event.attributes[parseInt(i) + 1].value;
+
+    const coin = parseCoins(amountStr)[0];
+    const amount = BigInt(coin.amount);
+    receiveEvents.push({receiver: receiver, amount: amount, denom: coin.denom})
+  }
+  ;
+
+  for (const [i, receiveEvent] of Object.entries(receiveEvents)) {
+    await saveNativeBalanceEvent(`${messageId(event)}-receive-${i}`, receiveEvent.receiver, receiveEvent.amount, receiveEvent.denom, event);
+  }
+}

src/mappings/bank/index.ts

@@ -0,0 +1,2 @@
+export * from "./transfer"
+export * from "./balanceChange"

src/mappings/bank/transfer.ts

@@ -0,0 +1,35 @@
+import {CosmosEvent, CosmosMessage} from "@subql/types-cosmos";
+import {NativeTransferMsg} from "../types";
+import {messageId} from "../utils";
+import {NativeTransfer} from "../../types";
+
+export async function handleNativeTransfer(event: CosmosEvent): Promise<void> {
+  const msg: CosmosMessage<NativeTransferMsg> = event.msg
+  logger.info(`[handleNativeTransfer] (tx ${msg.tx.hash}): indexing message ${msg.idx + 1} / ${msg.tx.decodedTx.body.messages.length}`)
+  logger.debug(`[handleNativeTransfer] (msg.msg): ${JSON.stringify(msg.msg, null, 2)}`)
+
+  const fromAddress = msg.msg?.decodedMsg?.fromAddress;
+  const toAddress = msg.msg?.decodedMsg?.toAddress
+  const amounts = msg.msg?.decodedMsg?.amount;
+
+  if (!fromAddress || !amounts || !toAddress) {
+    logger.warn(`[handleNativeTransfer] (tx ${event.tx.hash}): cannot index event (event.event): ${JSON.stringify(event.event, null, 2)}`)
+    return
+  }
+
+  // workaround: assuming one denomination per transfer message
+  const denom = amounts[0].denom;
+  const id = messageId(msg);
+  const transferEntity = NativeTransfer.create({
+    id,
+    toAddress,
+    fromAddress,
+    amounts,
+    denom,
+    messageId: id,
+    transactionId: msg.tx.hash,
+    blockId: msg.block.block.id
+  });
+
+  await transferEntity.save();
+}

src/mappings/dist/index.ts

@@ -0,0 +1 @@
+export * from "./rewards";

src/mappings/dist/rewards.ts

@@ -0,0 +1,73 @@
+import {CosmosEvent, CosmosMessage} from "@subql/types-cosmos";
+import {DistDelegatorClaimMsg} from "../types";
+import {messageId, parseCoins} from "../utils";
+import {DistDelegatorClaim} from "../../types";
+
+export async function handleDistDelegatorClaim(event: CosmosEvent): Promise<void> {
+  const msg: CosmosMessage<DistDelegatorClaimMsg> = event.msg;
+  logger.info(`[handleDistDelegatorClaim] (tx ${msg.tx.hash}): indexing DistDelegatorClaim ${messageId(msg)}`)
+  logger.debug(`[handleDistDelegatorClaim] (event.msg.msg): ${JSON.stringify(msg.msg, null, 2)}`)
+
+  const id = messageId(msg);
+  const delegatorAddress = msg?.msg?.decodedMsg?.delegatorAddress;
+  const validatorAddress = msg?.msg?.decodedMsg?.validatorAddress;
+
+  if (!delegatorAddress || !validatorAddress) {
+    logger.warn(`[handleDistDelegatorClaim] (tx ${event.tx.hash}): cannot index event (event.event): ${JSON.stringify(event.event, null, 2)}`)
+    return
+  }
+
+  const claim = DistDelegatorClaim.create({
+    id,
+    delegatorAddress,
+    validatorAddress,
+    messageId: id,
+    transactionId: msg.tx.hash,
+    blockId: msg.block.block.id,
+    amount: BigInt(-1),
+    denom: "",
+  });
+
+  // TODO:
+  // claim.amount =
+  // claim.denom =
+
+  await claim.save();
+}
+
+export async function handleDelegatorWithdrawRewardEvent(event: CosmosEvent): Promise<void> {
+  logger.debug(`[handleDelegateWithdrawRewardEvent] (event.event): ${JSON.stringify(event.event, null, 2)}`)
+  logger.debug(`[handleDelegateWithdrawRewardEvent] (event.log): ${JSON.stringify(event.log, null, 2)}`)
+
+  const attrs: Record<string, any> = event.event.attributes.reduce((acc, attr) => {
+    acc[attr.key] = attr.value;
+    return acc;
+  }, {});
+
+  if (!attrs.amount || !attrs.validator) {
+    logger.warn(`[handleDelegatorWithdrawRewardEvent] (tx ${event.tx.hash}): cannot index event (event.event): ${JSON.stringify(event.event, null, 2)}`)
+    return
+  }
+
+  const claims = await DistDelegatorClaim.getByTransactionId(event.tx.hash);
+
+  const {amount: amountStr, validator} = attrs as { amount: string, validator: string };
+  const claim = claims.find((claim) => claim.validatorAddress === validator);
+  if (typeof (claim) === "undefined") {
+    // Skip this call as unprocessable and allow indexer to continue.
+    logger.warn(`[handleDelegateWithdrawRewardEvent] (!SKIPPED!) no claim msgs found in tx: ${event.tx.hash}`);
+    return;
+  }
+
+  const coins = parseCoins(amountStr);
+  if (coins.length === 0) {
+    // Skip this call as unprocessable and allow indexer to continue.
+    logger.warn(`[handleDelegateWithdrawRewardEvent] (!SKIPPED!) error parsing claim amount: ${amountStr}`);
+    return;
+  }
+
+  const {amount, denom} = coins[0];
+  claim.amount = BigInt(amount);
+  claim.denom = denom;
+  await claim.save();
+}

src/mappings/gov/index.ts

@@ -0,0 +1 @@
+export * from "./votes"

src/mappings/gov/votes.ts

@@ -0,0 +1,31 @@
+import {CosmosEvent, CosmosMessage} from "@subql/types-cosmos";
+import {GovProposalVoteMsg} from "../types";
+import {messageId} from "../utils";
+import {GovProposalVote, GovProposalVoteOption} from "../../types";
+
+export async function handleGovProposalVote(event: CosmosEvent): Promise<void> {
+  const msg: CosmosMessage<GovProposalVoteMsg> = event.msg;
+  logger.info(`[handleGovProposalVote] (tx ${msg.tx.hash}): indexing GovProposalVote ${messageId(msg)}`)
+  logger.debug(`[handleGovProposalVote] (event.msg.msg): ${JSON.stringify(msg.msg, null, 2)}`)
+
+  const id = messageId(msg);
+  const option = msg?.msg?.decodedMsg?.option;
+  const proposalId = msg?.msg?.decodedMsg?.proposalId, voter = msg?.msg?.decodedMsg?.voter;
+
+  if (!option || !proposalId || !voter) {
+    logger.warn(`[handleGovProposalVote] (tx ${event.tx.hash}): cannot index event (event.event): ${JSON.stringify(event.event, null, 2)}`)
+    return
+  }
+
+  const vote = GovProposalVote.create({
+    id,
+    proposalId: proposalId,
+    voterAddress: voter,
+    option: Object.values(GovProposalVoteOption)[option],
+    messageId: id,
+    transactionId: msg.tx.hash,
+    blockId: msg.block.block.id,
+  });
+
+  await vote.save();
+}

src/mappings/ibc/index.ts

@@ -0,0 +1 @@
+export * from "./transfer"

src/mappings/ibc/transfer.ts

@@ -0,0 +1,39 @@
+import {CosmosEvent} from "@subql/types-cosmos";
+import {IbcTransfer} from "../../types";
+import {messageId} from "../utils";
+
+export async function handleIBCTransfer(event: CosmosEvent): Promise<void> {
+  const msg = event.msg;
+  logger.info(`[handleIBCTransfer] (tx ${msg.tx.hash}): indexing message ${msg.idx + 1} / ${msg.tx.decodedTx.body.messages.length}`)
+  logger.debug(`[handleIBCTransfer] (msg.msg): ${JSON.stringify(msg.msg, null, 2)}`)
+
+  const decodedMsg = msg.msg.decodedMsg;
+  const sourcePort = decodedMsg.sourcePort;
+  const sourceChannel = decodedMsg.sourceChannel;
+  const tokenAmount = decodedMsg.token?.amount;
+  const tokenDenom = decodedMsg.token?.denom;
+  const sender = decodedMsg.sender;
+  const receiver = decodedMsg.receiver;
+
+  if (!sourcePort || !sourceChannel || !tokenAmount || !tokenDenom || !sender || !receiver) {
+    logger.warn(`[handleIBCTransfer] (tx ${msg.tx.hash}): cannot index message (msg.msg): ${JSON.stringify(msg.msg, null, 2)}`)
+    return
+  }
+
+  const id = messageId(msg);
+  const transferEntity = IbcTransfer.create({
+    id,
+    toAddress: receiver,
+    fromAddress: sender,
+    amount: {amount: tokenAmount, denom: tokenDenom},
+    denom: tokenDenom,
+    sourcePort,
+    sourceChannel,
+    eventId: `${messageId(event)}-${event.idx}`,
+    messageId: id,
+    transactionId: msg.tx.hash,
+    blockId: msg.block.block.id
+  });
+
+  await transferEntity.save();
+}