fix evm transfer token metadata fallback

Author: xlc

packages/acala-evm-transfer/package.json

@@ -10,6 +10,7 @@
     "dev": "subql codegen && subql build && docker-compose pull && docker-compose up --remove-orphans",
     "prepack": "rm -rf dist && npm run build",
     "test": "subql build && subql-node-ethereum test",
+    "test:unit": "bun test tests/token.test.ts",
     "build:typechain": "typechain --target=ethers-v5 --out-dir=contracts abis/*.json",
     "build:develop": "NODE_ENV=develop subql codegen && NODE_ENV=develop subql build"
   },

packages/acala-evm-transfer/src/mappings/approve.ts

@@ -10,7 +10,11 @@ export async function handleApprove(call: ApproveTransaction) {
   const receipt = await call.receipt();
   const success = receipt.status;
   const address = call.to;
-  const token = await getToken(address);
+  const token = await getToken(address, {
+    handler: "handleApprove",
+    blockHeight: call.blockNumber,
+    transactionHash: call.hash,
+  });
 
   const approve = new Approve(
     call.hash,

packages/acala-evm-transfer/src/mappings/token.ts

@@ -1,21 +1,113 @@
 import { Token } from "../types";
 import { Erc20__factory } from "../types/contracts";
 
-export async function getToken (address: string) {
+export type TokenLookupContext = {
+  handler?: string;
+  blockHeight?: bigint | number | string;
+  transactionHash?: string;
+  logIndex?: bigint | number | string;
+};
+
+type MetadataMethod = "name" | "symbol" | "decimals";
+
+const FALLBACK_SYMBOL = "UNKNOWN";
+const FALLBACK_DECIMALS = BigInt(0);
+
+export async function getToken (address: string, context: TokenLookupContext = {}) {
   let token = await Token.get(address);
 
   if (token) {
     return token;
   }
 
   const erc20 = Erc20__factory.connect(address, api);
-  const name = await erc20.name();
-  const symbol = await erc20.symbol();
-  const decimals = await erc20.decimals();
+  const name = await readMetadata(address, "name", () => erc20.name(), context);
+  const symbol = await readMetadata(address, "symbol", () => erc20.symbol(), context);
+  const decimals = await readMetadata(address, "decimals", () => erc20.decimals(), context);
 
-  token = new Token(address, name, symbol, BigInt(decimals.toString()));
+  token = new Token(
+    address,
+    name ?? fallbackName(address),
+    symbol ?? FALLBACK_SYMBOL,
+    decimals === undefined ? FALLBACK_DECIMALS : BigInt(decimals.toString())
+  );
 
   await token.save();
 
   return token;
 }
+
+async function readMetadata<T> (
+  address: string,
+  method: MetadataMethod,
+  read: () => Promise<T>,
+  context: TokenLookupContext
+): Promise<T | undefined> {
+  try {
+    return await read();
+  } catch (error) {
+    if (!isContractMetadataFailure(error)) {
+      throw error;
+    }
+
+    logger.warn(`Failed to read ERC20 metadata: address=${address} method=${method}${formatContext(context)} error=${formatError(error)}`);
+    return undefined;
+  }
+}
+
+function fallbackName (address: string): string {
+  return `Unknown Token ${address}`;
+}
+
+function formatContext (context: TokenLookupContext): string {
+  const parts: string[] = [];
+
+  if (context.handler) parts.push(`handler=${context.handler}`);
+  if (context.blockHeight !== undefined) parts.push(`block=${context.blockHeight.toString()}`);
+  if (context.transactionHash) parts.push(`tx=${context.transactionHash}`);
+  if (context.logIndex !== undefined) parts.push(`logIndex=${context.logIndex.toString()}`);
+
+  return parts.length ? ` ${parts.join(" ")}` : "";
+}
+
+function formatError (error: unknown): string {
+  const code = errorCode(error);
+
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}${code ? ` code=${code}` : ""}`;
+  }
+
+  if (typeof error === "string") {
+    return error;
+  }
+
+  return code ? `code=${code}` : "unknown";
+}
+
+function errorCode (error: unknown): string | undefined {
+  if (typeof error !== "object" || error === null || !("code" in error)) {
+    return undefined;
+  }
+
+  const code = error.code;
+  return typeof code === "string" ? code : undefined;
+}
+
+function isContractMetadataFailure (error: unknown): boolean {
+  const code = errorCode(error);
+
+  if (code === "CALL_EXCEPTION" || code === "BAD_DATA") {
+    return true;
+  }
+
+  if (!(error instanceof Error)) {
+    return false;
+  }
+
+  if (code !== undefined && code !== "INVALID_ARGUMENT") {
+    return false;
+  }
+
+  return error.message.includes("data out-of-bounds")
+    || error.message.includes("could not decode result data");
+}

packages/acala-evm-transfer/src/mappings/transfer-event.ts

@@ -9,7 +9,12 @@ export async function handleTransferEvent(event: TransferLog) {
   if (!event.args) return;
 
   const address = event.address;
-  const token = await getToken(address);
+  const token = await getToken(address, {
+    handler: "handleTransferEvent",
+    blockHeight: event.block.number,
+    transactionHash: event.transactionHash,
+    logIndex: event.logIndex,
+  });
 
   const transferEvent = new TransferEvent(
     `${event.transactionHash}-${event.logIndex}`,
@@ -24,4 +29,3 @@ export async function handleTransferEvent(event: TransferLog) {
 
   await transferEvent.save();
 }
-

packages/acala-evm-transfer/src/mappings/transfer.ts

@@ -12,7 +12,11 @@ export async function handleTransfer(call: TransferTransaction) {
   const receipt = await call.receipt();
   const success = receipt.status;
   const address = call.to;
-  let token = await getToken(address);
+  const token = await getToken(address, {
+    handler: "handleTransfer",
+    blockHeight: call.blockNumber,
+    transactionHash: call.hash,
+  });
 
   const transfer = new Transfer(
     call.hash,

packages/acala-evm-transfer/tests/token.test.ts

@@ -0,0 +1,73 @@
+import { beforeEach, expect, mock, test } from "bun:test";
+
+const records = new Map<string, unknown>();
+let warnings: string[] = [];
+let erc20Contract: {
+  name: () => Promise<string>;
+  symbol: () => Promise<string>;
+  decimals: () => Promise<number>;
+};
+
+mock.module("../src/types/contracts", () => ({
+  Erc20__factory: {
+    connect: () => erc20Contract,
+  },
+}));
+
+const { getToken } = await import("../src/mappings/token");
+
+beforeEach(() => {
+  records.clear();
+  warnings = [];
+
+  Object.assign(globalThis, {
+    api: {},
+    logger: {
+      warn: (message: string) => warnings.push(message),
+    },
+    store: {
+      get: async (entity: string, id: string) => records.get(`${entity}:${id}`),
+      set: async (entity: string, id: string, value: unknown) => {
+        records.set(`${entity}:${id}`, value);
+      },
+      remove: async (entity: string, id: string) => {
+        records.delete(`${entity}:${id}`);
+      },
+    },
+  });
+});
+
+test("persists fallback token metadata when decimals reverts", async () => {
+  const address = "0x00000000000000000000000000000000006036414";
+  const callException = new Error('call revert exception data="0x"');
+  Object.assign(callException, { code: "CALL_EXCEPTION" });
+
+  erc20Contract = {
+    name: async () => "Broken Metadata Token",
+    symbol: async () => "BMT",
+    decimals: async () => {
+      throw callException;
+    },
+  };
+
+  const token = await getToken(address, {
+    handler: "handleTransferEvent",
+    blockHeight: 6036414,
+    transactionHash: "0xdeadbeef",
+    logIndex: 12,
+  });
+
+  expect(token.id).toBe(address);
+  expect(token.name).toBe("Broken Metadata Token");
+  expect(token.symbol).toBe("BMT");
+  expect(token.decimals).toBe(0n);
+  expect(records.get(`Token:${address}`)).toBe(token);
+  expect(warnings).toHaveLength(1);
+  expect(warnings[0]).toContain(`address=${address}`);
+  expect(warnings[0]).toContain("method=decimals");
+  expect(warnings[0]).toContain("handler=handleTransferEvent");
+  expect(warnings[0]).toContain("block=6036414");
+  expect(warnings[0]).toContain("tx=0xdeadbeef");
+  expect(warnings[0]).toContain("logIndex=12");
+  expect(warnings[0]).toContain("code=CALL_EXCEPTION");
+});