Support paseo

commands.json

@@ -95,6 +95,15 @@
         "--out=versions/westend/bridgehub-versions.jsonl"
       ]
     },
+    "generateMeta:bridgehub:paseo": {
+      "description": "Generate metadata for bridge hub",
+      "cmd": [
+        "npx",
+        "squid-substrate-metadata-explorer",
+        "--rpc=wss://sys.ibp.network/bridgehub-paseo",
+        "--out=versions/paseo/bridgehub-versions.jsonl"
+      ]
+    },
     "typegen:bridgehub": {
       "description": "Generate data access classes for an substrate metadata",
       "cmd": [
@@ -109,6 +118,13 @@
         "./versions/westend/typegen-bridgehub.json"
       ]
     },
+    "typegen:bridgehub:paseo": {
+      "description": "Generate data access classes for an substrate metadata",
+      "cmd": [
+        "squid-substrate-typegen",
+        "./versions/paseo/typegen-bridgehub.json"
+      ]
+    },
     "process:bridgehub": {
       "description": "start the squid processor for BridgeHub",
       "deps": ["build"],
@@ -129,6 +145,16 @@
         "src/westend/bridgehub/main.ts"
       ]
     },
+    "process:bridgehub:paseo": {
+      "description": "start the squid processor for Westend BridgeHub",
+      "deps": ["build"],
+      "cmd": [
+        "node",
+        "--require=ts-node/register",
+        "--require=dotenv/config",
+        "src/paseo/bridgehub/main.ts"
+      ]
+    },
     "generateMeta:assethub": {
       "description": "Generate metadata for asset hub",
       "cmd": [
@@ -147,6 +173,15 @@
         "--out=versions/westend/assethub-versions.jsonl"
       ]
     },
+    "generateMeta:assethub:paseo": {
+      "description": "Generate metadata for asset hub",
+      "cmd": [
+        "npx",
+        "squid-substrate-metadata-explorer",
+        "--rpc=wss://sys.ibp.network/asset-hub-paseo",
+        "--out=versions/paseo/assethub-versions.jsonl"
+      ]
+    },
     "typegen:assethub": {
       "description": "Generate data access classes for an substrate metadata",
       "cmd": [
@@ -161,6 +196,13 @@
         "./versions/westend/typegen-assethub.json"
       ]
     },
+    "typegen:assethub:paseo": {
+      "description": "Generate data access classes for an substrate metadata",
+      "cmd": [
+        "squid-substrate-typegen",
+        "./versions/paseo/typegen-assethub.json"
+      ]
+    },
     "process:assethub": {
       "description": "start the squid processor for AssetHub",
       "deps": ["build"],
@@ -181,6 +223,16 @@
         "src/westend/assethub/main.ts"
       ]
     },
+    "process:assethub:paseo": {
+      "description": "start the squid processor for Westend AssetHub",
+      "deps": ["build"],
+      "cmd": [
+        "node",
+        "--require=ts-node/register",
+        "--require=dotenv/config",
+        "src/paseo/assethub/main.ts"
+      ]
+    },
     "postprocess": {
       "description": "Aggregate data from multiple tables",
       "deps": ["build"],

src/paseo/assethub/main.ts

@@ -0,0 +1,293 @@
+import { TypeormDatabase, Store } from "@subsquid/typeorm-store";
+import { processor, ProcessorContext } from "./processor";
+import {
+  MessageProcessedOnPolkadot,
+  TransferStatusToPolkadot,
+  TransferStatusToEthereum,
+} from "../../model";
+import { events } from "./types";
+import { Bytes } from "./types/support";
+import { AggregateMessageOrigin, ProcessMessageError } from "./types/v1002000";
+import { V4Instruction, V4Location } from "./types/v1002000";
+import {
+  AggregateMessageOrigin as AggregateMessageOriginV1013000,
+  ProcessMessageError as ProcessMessageErrorV1013000,
+} from "./types/v1003000";
+import {
+  TransferStatusEnum,
+  BridgeHubParaId,
+  AssetHubParaId,
+  toSubscanEventID,
+  findTokenAddress,
+} from "../../common";
+
+processor.run(
+  new TypeormDatabase({
+    supportHotBlocks: true,
+    stateSchema: "assethub_processor",
+  }),
+  async (ctx) => {
+    await processInboundEvents(ctx);
+    await processOutboundEvents(ctx);
+  }
+);
+
+async function processOutboundEvents(ctx: ProcessorContext<Store>) {
+  let transfersToEthereum: TransferStatusToEthereum[] = [],
+    forwardMessages: MessageProcessedOnPolkadot[] = [];
+  for (let block of ctx.blocks) {
+    let xcmpMessageSent = false;
+    let transfers: TransferStatusToEthereum[] = [];
+    let messagesInBlock: MessageProcessedOnPolkadot[] = [];
+    for (let event of block.events) {
+      if (event.name == events.xcmpQueue.xcmpMessageSent.name) {
+        xcmpMessageSent = true;
+      } else if (
+        event.name == events.messageQueue.processed.name ||
+        event.name == events.messageQueue.processingFailed.name
+      ) {
+        let rec: {
+          id: Bytes;
+          origin: AggregateMessageOrigin | AggregateMessageOriginV1013000;
+          success?: boolean;
+          error?: ProcessMessageError | ProcessMessageErrorV1013000;
+        };
+        if (events.messageQueue.processed.v1002000.is(event)) {
+          rec = events.messageQueue.processed.v1002000.decode(event);
+        } else if (events.messageQueue.processingFailed.v1002000.is(event)) {
+          rec = events.messageQueue.processingFailed.v1002000.decode(event);
+        } else if (events.messageQueue.processingFailed.v1003000.is(event)) {
+          rec = events.messageQueue.processingFailed.v1003000.decode(event);
+        } else {
+          throw Object.assign(new Error("Unsupported spec"), event);
+        }
+        // Filter message from non system parachain
+        if (rec.origin.__kind == "Sibling" && rec.origin.value >= 2000) {
+          let messageForwarded = new MessageProcessedOnPolkadot({
+            id: toSubscanEventID(event.id),
+            blockNumber: block.header.height,
+            timestamp: new Date(block.header.timestamp!),
+            messageId: rec.id.toString().toLowerCase(),
+            paraId: AssetHubParaId,
+            success: rec.success,
+            eventId: toSubscanEventID(event.id),
+          });
+          messagesInBlock.push(messageForwarded);
+          forwardMessages.push(messageForwarded);
+        }
+      } else if (event.name == events.polkadotXcm.sent.name) {
+        let rec: {
+          origin: V4Location;
+          destination: V4Location;
+          messageId: Bytes;
+          message: V4Instruction[];
+        };
+        if (events.polkadotXcm.sent.v1002000.is(event)) {
+          rec = events.polkadotXcm.sent.v1002000.decode(event);
+        } else {
+          throw Object.assign(new Error("Unsupported spec"), event);
+        }
+        if (
+          rec.destination.parents == 2 &&
+          rec.destination.interior.__kind == "X1" &&
+          rec.destination.interior.value[0].__kind == "GlobalConsensus" &&
+          rec.destination.interior.value[0].value.__kind == "Ethereum"
+        ) {
+          let amount: bigint = BigInt(0);
+          let senderAddress: Bytes = "";
+          let tokenAddress: Bytes = "";
+          let tokenLocation: Bytes = "";
+          let destinationAddress: Bytes = "";
+
+          let messageId = rec.messageId.toString().toLowerCase();
+          if (rec.origin.interior.__kind == "X1") {
+            let val = rec.origin.interior.value[0];
+            if (val.__kind == "AccountId32") {
+              senderAddress = val.id;
+            }
+          }
+
+          let instruction0 = rec.message[0];
+          // WithdrawAsset for ENA and ReserveAssetDeposited for PNA
+          if (
+            instruction0.__kind == "WithdrawAsset" ||
+            instruction0.__kind == "ReserveAssetDeposited"
+          ) {
+            let asset = instruction0.value[0];
+            tokenLocation = JSON.stringify(asset.id, (key, value) =>
+              typeof value === "bigint" ? value.toString() : value
+            );
+            if (asset.fun.__kind == "Fungible") {
+              amount = asset.fun.value;
+              // For ENA extract the token address
+              if (
+                instruction0.__kind == "WithdrawAsset" &&
+                asset.id.interior.__kind == "X1"
+              ) {
+                let val = asset.id.interior.value[0];
+                if (val.__kind == "AccountKey20") {
+                  tokenAddress = val.key;
+                }
+              }
+              // For native Ether
+              else if (
+                instruction0.__kind == "WithdrawAsset" &&
+                asset.id.interior.__kind == "Here"
+              ) {
+                tokenAddress = "0x0000000000000000000000000000000000000000";
+              }
+              // For PNA retrieving from the static map, can be improved by using another indexer
+              else {
+                tokenAddress = findTokenAddress("westend", tokenLocation);
+              }
+            }
+          }
+
+          let instruction3 = rec.message[3];
+          if (instruction3.__kind == "DepositAsset") {
+            let beneficiary = instruction3.beneficiary;
+            if (beneficiary.interior.__kind == "X1") {
+              let val = beneficiary.interior.value[0];
+              if (val.__kind == "AccountKey20") {
+                destinationAddress = val.key;
+              }
+            }
+          }
+
+          let transferToEthereum = new TransferStatusToEthereum({
+            id: messageId,
+            txHash: event.extrinsic?.hash,
+            blockNumber: block.header.height,
+            timestamp: new Date(block.header.timestamp!),
+            messageId: messageId,
+            tokenAddress,
+            tokenLocation,
+            sourceParaId: AssetHubParaId,
+            senderAddress,
+            destinationAddress,
+            amount,
+            status: TransferStatusEnum.Pending,
+          });
+          transfers.push(transferToEthereum);
+        }
+      }
+    }
+    // Start from AH
+    if (transfers.length) {
+      for (let transfer of transfers) {
+        let transferStatus = await ctx.store.findOneBy(
+          TransferStatusToEthereum,
+          {
+            id: transfer.messageId,
+          }
+        );
+        if (!transferStatus) {
+          transfersToEthereum.push(transfer);
+        }
+      }
+    }
+    // Start from 3rd Parachain
+    if (xcmpMessageSent) {
+      for (let messageForwarded of messagesInBlock) {
+        let transfer = await ctx.store.findOneBy(TransferStatusToEthereum, {
+          id: messageForwarded.messageId,
+        });
+        if (transfer!) {
+          transfer.toAssetHubMessageQueue = messageForwarded;
+          if (!messageForwarded.success) {
+            transfer.status = TransferStatusEnum.Failed;
+          }
+          transfersToEthereum.push(transfer);
+        }
+      }
+    }
+  }
+
+  if (forwardMessages.length > 0) {
+    ctx.log.debug("saving forward messages to ethereum");
+    await ctx.store.save(forwardMessages);
+  }
+
+  if (transfersToEthereum.length > 0) {
+    ctx.log.debug("saving transfer messages to ethereum");
+    await ctx.store.save(transfersToEthereum);
+  }
+}
+
+async function processInboundEvents(ctx: ProcessorContext<Store>) {
+  let transfersToPolkadot: TransferStatusToPolkadot[] = [],
+    processedMessages: MessageProcessedOnPolkadot[] = [];
+  for (let block of ctx.blocks) {
+    let processedMessagesInBlock: MessageProcessedOnPolkadot[] = [];
+    for (let event of block.events) {
+      if (
+        event.name == events.messageQueue.processed.name ||
+        event.name == events.messageQueue.processingFailed.name
+      ) {
+        let rec: {
+          id: Bytes;
+          origin: AggregateMessageOrigin | AggregateMessageOriginV1013000;
+          success?: boolean;
+          error?: ProcessMessageError | ProcessMessageErrorV1013000;
+        };
+        if (events.messageQueue.processed.v1002000.is(event)) {
+          rec = events.messageQueue.processed.v1002000.decode(event);
+        } else if (events.messageQueue.processingFailed.v1002000.is(event)) {
+          rec = events.messageQueue.processingFailed.v1002000.decode(event);
+        } else {
+          throw Object.assign(new Error("Unsupported spec"), event);
+        }
+        // Filter message from BH
+        if (
+          rec.origin.__kind == "Sibling" &&
+          rec.origin.value == BridgeHubParaId
+        ) {
+          let processedMessage = new MessageProcessedOnPolkadot({
+            id: event.id,
+            blockNumber: block.header.height,
+            timestamp: new Date(block.header.timestamp!),
+            messageId: rec.id.toString().toLowerCase(),
+            paraId: AssetHubParaId,
+            success: rec.success,
+            eventId: toSubscanEventID(event.id),
+          });
+          processedMessagesInBlock.push(processedMessage);
+        }
+      }
+    }
+
+    if (processedMessagesInBlock.length) {
+      for (let processedMessage of processedMessagesInBlock) {
+        processedMessages.push(processedMessage);
+        let transfer = await ctx.store.findOneBy(TransferStatusToPolkadot, {
+          id: processedMessage.messageId,
+        });
+        if (transfer!) {
+          if (!processedMessage.success) {
+            transfer.status = TransferStatusEnum.Failed;
+          } else {
+            transfer.status = TransferStatusEnum.Complete;
+            if (transfer.destinationParaId == AssetHubParaId) {
+              // Terminated on AH
+              transfer.toAssetHubMessageQueue = processedMessage;
+              transfer.toDestination = processedMessage;
+            } else {
+              // Forward to 3rd Parachain
+              transfer.toAssetHubMessageQueue = processedMessage;
+            }
+          }
+          transfersToPolkadot.push(transfer);
+        }
+      }
+    }
+  }
+
+  if (processedMessages.length > 0) {
+    ctx.log.debug("saving messageQueue processed messages");
+    await ctx.store.save(processedMessages);
+  }
+  if (transfersToPolkadot.length > 0) {
+    ctx.log.debug("saving transfer messages from ethereum to polkadot");
+    await ctx.store.save(transfersToPolkadot);
+  }
+}