@moonbeam-network/xcm-builder 1.0.0-dev.210 → 1.0.0-dev.211

package/build/index.d.ts

@@ -4,6 +4,7 @@ import { FrameSystemAccountInfo, StagingXcmV3MultiLocation } from '@polkadot/typ
 import { Struct, u128, Enum } from '@polkadot/types';
 import { Abi, PublicClient, HttpTransport } from 'viem';
 import { SubmittableExtrinsicFunction } from '@polkadot/api/types';
+import { EventRecord } from '@polkadot/types/interfaces';
 import { HexString } from '@polkadot/util/types';
 import { Wormhole, Network } from '@wormhole-foundation/sdk-connect';
 
@@ -370,6 +371,7 @@ declare function polkadotXcm$1(): {
     };
     transferAssets: () => {
         here: (parents?: number) => ExtrinsicConfigBuilder;
+        X1: () => ExtrinsicConfigBuilder;
         X2: () => ExtrinsicConfigBuilder;
         X3: () => ExtrinsicConfigBuilder;
         X2AndFeeHere: () => ExtrinsicConfigBuilder;
@@ -469,6 +471,51 @@ declare function FeeBuilder(): {
     xcmPaymentApi: typeof xcmPaymentApi;
 };
 
+type SourceChecker = (events: EventRecord[], sourceAddress: string) => {
+    matched: boolean;
+    messageId?: string;
+    event?: EventRecord;
+};
+type DestinationChecker = (events: EventRecord[], messageId?: string) => {
+    matched: boolean;
+    success: boolean;
+    event?: EventRecord;
+};
+interface MonitoringConfig {
+    checkSource: SourceChecker;
+    checkDestination: DestinationChecker;
+}
+declare function MonitoringBuilder(): {
+    xcmPallet: () => {
+        messageQueue: () => {
+            checkSource: SourceChecker;
+            checkDestination: DestinationChecker;
+        };
+    };
+    polkadotXcm: () => {
+        messageQueue: () => {
+            checkSource: SourceChecker;
+            checkDestination: DestinationChecker;
+        };
+        xcmpQueue: () => {
+            checkSource: SourceChecker;
+            checkDestination: DestinationChecker;
+        };
+    };
+    xTokens: () => {
+        messageQueue: () => {
+            checkSource: SourceChecker;
+            checkDestination: DestinationChecker;
+        };
+    };
+    bridgeMessages: () => {
+        bridgeMessages: () => {
+            checkSource: SourceChecker;
+            checkDestination: DestinationChecker;
+        };
+    };
+};
+
 type WormholeTransferFunctions = 'tokenTransfer';
 type WormholeFunctionArgs = Parameters<Wormhole<Network>[WormholeTransferFunctions]>;
 interface WormholeConfigConstructorParams {
@@ -646,4 +693,4 @@ declare function MrlBuilder(): {
 
 declare const BATCH_CONTRACT_ADDRESS = "0x0000000000000000000000000000000000000808";
 
-export { AssetMinBuilder, type AssetMinConfigBuilder, type AssetMinConfigBuilderParams, BATCH_CONTRACT_ABI, BATCH_CONTRACT_ADDRESS, BalanceBuilder, type BalanceBuilderParams, type BalanceConfigBuilder, type BuilderParams, type ConfigBuilder, ContractBuilder, ContractConfig, type ContractConfigBuilder, type ContractConfigConstructorParams, ERC20_ABI, type EquilibriumSystemBalanceData, type EvmFunctionArgs, EvmQueryConfig, type EvmQueryConfigParams, type EvmQueryFunctions, ExtrinsicBuilder, ExtrinsicConfig, type ExtrinsicConfigBuilder, type ExtrinsicConfigConstructorParams, FeeBuilder, type FeeConfigBuilder, type FeeConfigBuilderParams, type GetVersionedAssetId, type MoonbeamRuntimeXcmConfigAssetType, MrlBuilder, type MrlBuilderParams, type MrlConfigBuilder, type MrlExecuteBuilderParams, type MrlExecuteConfigBuilder, type PalletBalancesAccountDataOld, type Parents, type QueryConfigConstructorParams, SubstrateCallConfig, type SubstrateCallConfigConstructorParams, SubstrateQueryConfig, type TokensPalletAccountData, type Transact, WormholeConfig, type WormholeConfigConstructorParams, type WormholeFunctionArgs, type WormholeTransferFunctions, type XcmPaymentFeeProps, XcmVersion, calculateSystemAccountBalance, evm, substrate, wormhole, wormholeFactory };
+export { AssetMinBuilder, type AssetMinConfigBuilder, type AssetMinConfigBuilderParams, BATCH_CONTRACT_ABI, BATCH_CONTRACT_ADDRESS, BalanceBuilder, type BalanceBuilderParams, type BalanceConfigBuilder, type BuilderParams, type ConfigBuilder, ContractBuilder, ContractConfig, type ContractConfigBuilder, type ContractConfigConstructorParams, type DestinationChecker, ERC20_ABI, type EquilibriumSystemBalanceData, type EvmFunctionArgs, EvmQueryConfig, type EvmQueryConfigParams, type EvmQueryFunctions, ExtrinsicBuilder, ExtrinsicConfig, type ExtrinsicConfigBuilder, type ExtrinsicConfigConstructorParams, FeeBuilder, type FeeConfigBuilder, type FeeConfigBuilderParams, type GetVersionedAssetId, MonitoringBuilder, type MonitoringConfig, type MoonbeamRuntimeXcmConfigAssetType, MrlBuilder, type MrlBuilderParams, type MrlConfigBuilder, type MrlExecuteBuilderParams, type MrlExecuteConfigBuilder, type PalletBalancesAccountDataOld, type Parents, type QueryConfigConstructorParams, type SourceChecker, SubstrateCallConfig, type SubstrateCallConfigConstructorParams, SubstrateQueryConfig, type TokensPalletAccountData, type Transact, WormholeConfig, type WormholeConfigConstructorParams, type WormholeFunctionArgs, type WormholeTransferFunctions, type XcmPaymentFeeProps, XcmVersion, calculateSystemAccountBalance, evm, substrate, wormhole, wormholeFactory };

package/build/index.mjs

@@ -83,6 +83,7 @@ function applyConcreteWrapper(versionedObject) {
 var BaseConfig = class {
   module;
   func;
+  // TODO add section and method here or some mapping that transforms the module in section and func in method, for the event monitoring
   constructor({ module: module5, func }) {
     this.module = module5;
     this.func = func;
@@ -1722,6 +1723,36 @@ function polkadotXcm() {
             }
           })
         }),
+        X1: () => ({
+          build: (params) => new ExtrinsicConfig({
+            module: pallet2,
+            func,
+            getArgs: (extrinsicFunction) => {
+              const version = getExtrinsicArgumentVersion(extrinsicFunction);
+              return getPolkadotXcmExtrinsicArgs({
+                ...params,
+                func: extrinsicFunction,
+                asset: [
+                  {
+                    id: normalizeConcrete(version, {
+                      parents: 0,
+                      interior: {
+                        X1: [
+                          {
+                            GeneralIndex: params.asset.getAssetId()
+                          }
+                        ]
+                      }
+                    }),
+                    fun: {
+                      Fungible: params.asset.amount
+                    }
+                  }
+                ]
+              });
+            }
+          })
+        }),
         X2: () => ({
           build: (params) => new ExtrinsicConfig({
             module: pallet2,
@@ -2208,6 +2239,7 @@ function xcmPallet() {
                 {
                   [version]: {
                     parents: 0,
+                    // TODO put 1 to force error in source, revert to 0 to fix
                     interior: {
                       X1: [
                         {
@@ -2936,6 +2968,234 @@ function FeeBuilder() {
   };
 }
 
+// src/monitoring/MonitoringBuilder.ts
+import { u8aToHex as u8aToHex6 } from "@polkadot/util";
+import { decodeAddress as decodeAddress6 } from "@polkadot/util-crypto";
+function GetAddress() {
+  return {
+    fromXcmEvent: () => (event) => {
+      const eventData = event.event.data;
+      const interior = eventData.origin.interior.asX1[0];
+      if (interior.isAccountId32) {
+        return interior.asAccountId32.id.toHex();
+      } else if (interior.isAccountKey20) {
+        return interior.asAccountKey20.key.toString();
+      } else {
+        throw new Error("Unsupported address type");
+      }
+    },
+    fromXTokensEvent: () => (event) => {
+      const eventData = event.event.data;
+      return u8aToHex6(decodeAddress6(eventData.sender.toString()));
+    }
+  };
+}
+function GetMessageId() {
+  return {
+    fromXcmEvent: () => (event) => {
+      const eventData = event.event.data;
+      return eventData.messageId.toHex();
+    },
+    fromXcmpQueue: () => (event, events) => {
+      const xcmpEvent = events?.find(
+        (event2) => event2.event.section === "xcmpQueue" && event2.event.method === "XcmpMessageSent"
+      );
+      if (!xcmpEvent) {
+        throw new Error("XcmpMessageSent event not found");
+      }
+      const eventData = xcmpEvent.event.data;
+      return eventData.messageHash.toHex();
+    }
+  };
+}
+function MatchMessageId() {
+  return {
+    fromMessageQueueId: () => (event, messageId) => {
+      if (!messageId) return true;
+      try {
+        const eventData = event.event.data;
+        return eventData.id.toString() === messageId;
+      } catch {
+        return false;
+      }
+    },
+    fromXcmpQueueHash: () => (event, messageId) => {
+      if (!messageId) return true;
+      try {
+        const eventData = event.event.data;
+        return eventData.messageHash.toString() === messageId;
+      } catch {
+        return false;
+      }
+    },
+    // TODO
+    never: () => () => true
+    // Always match for cases where messageId is not used
+  };
+}
+function GetIsSuccess() {
+  return {
+    fromMessageQueueProcessed: () => (event) => {
+      try {
+        const eventData = event.event.data;
+        return eventData.success.isTrue;
+      } catch {
+        return false;
+      }
+    },
+    fromXcmpQueueEvent: () => (event) => {
+      return event.event.method === "Success";
+    },
+    // TODO
+    alwaysTrue: () => () => true
+    // Always successful for simple cases
+  };
+}
+var createDestinationChecker = (section, method, matchMessageId, getIsSuccess) => (events, messageId) => {
+  const methods = Array.isArray(method) ? method : [method];
+  const event = events.find((event2) => {
+    if (event2.event.section !== section || !methods.includes(event2.event.method)) {
+      return false;
+    }
+    return matchMessageId(event2, messageId);
+  });
+  if (!event) {
+    return { matched: false, success: false };
+  }
+  const success = getIsSuccess(event);
+  return { matched: true, success, event };
+};
+var createSourceChecker = (section, method, addressExtractor, messageIdExtractor) => (events, sourceAddress) => {
+  const decodedSourceAddress = u8aToHex6(decodeAddress6(sourceAddress));
+  const methods = Array.isArray(method) ? method : [method];
+  const event = events.find((event2) => {
+    if (event2.event.section !== section || !methods.includes(event2.event.method)) {
+      return false;
+    }
+    try {
+      const address = addressExtractor(event2);
+      return address === decodedSourceAddress;
+    } catch {
+      return false;
+    }
+  });
+  if (!event) {
+    return { matched: false };
+  }
+  try {
+    const messageId = messageIdExtractor(event, events);
+    return { matched: true, messageId, event };
+  } catch {
+    return { matched: true, event };
+  }
+};
+function CheckSource() {
+  return {
+    xcmPallet: () => createSourceChecker(
+      "xcmPallet",
+      "Sent",
+      GetAddress().fromXcmEvent(),
+      GetMessageId().fromXcmEvent()
+    ),
+    polkadotXcm: () => createSourceChecker(
+      "polkadotXcm",
+      "Sent",
+      GetAddress().fromXcmEvent(),
+      GetMessageId().fromXcmEvent()
+    ),
+    polkadotXcmAndXcmpQueue: () => createSourceChecker(
+      "polkadotXcm",
+      "Sent",
+      GetAddress().fromXcmEvent(),
+      GetMessageId().fromXcmpQueue()
+    ),
+    xTokens: () => createSourceChecker(
+      "xTokens",
+      ["TransferredMultiAssets", "TransferredAssets"],
+      GetAddress().fromXTokensEvent(),
+      GetMessageId().fromXcmpQueue()
+    ),
+    bridgeMessages: () => (events, sourceAddress) => {
+      const event = events.find(
+        (event2) => event2.event.section === "bridgeMessages" && event2.event.method === "MessageAccepted"
+      );
+      return event ? { matched: true, event } : { matched: false };
+    }
+  };
+}
+function CheckDestination() {
+  return {
+    messageQueue: () => createDestinationChecker(
+      "messageQueue",
+      "Processed",
+      MatchMessageId().fromMessageQueueId(),
+      GetIsSuccess().fromMessageQueueProcessed()
+    ),
+    xcmpQueue: () => (events, messageId) => {
+      const matchMessageId = MatchMessageId().fromXcmpQueueHash();
+      const successEvent = events.find((event) => {
+        if (event.event.section !== "xcmpQueue" || event.event.method !== "Success") {
+          return false;
+        }
+        return matchMessageId(event, messageId);
+      });
+      const failEvent = events.find((event) => {
+        if (event.event.section !== "xcmpQueue" || event.event.method !== "Fail") {
+          return false;
+        }
+        return matchMessageId(event, messageId);
+      });
+      if (!successEvent && !failEvent) {
+        return { matched: false, success: false };
+      }
+      return {
+        matched: true,
+        success: !!successEvent,
+        event: successEvent || failEvent
+      };
+    },
+    bridgeMessages: () => createDestinationChecker(
+      "bridgeMessages",
+      "MessagesReceived",
+      MatchMessageId().never(),
+      GetIsSuccess().alwaysTrue()
+    )
+  };
+}
+function MonitoringBuilder() {
+  return {
+    xcmPallet: () => ({
+      messageQueue: () => ({
+        checkSource: CheckSource().xcmPallet(),
+        checkDestination: CheckDestination().messageQueue()
+      })
+    }),
+    polkadotXcm: () => ({
+      messageQueue: () => ({
+        checkSource: CheckSource().polkadotXcm(),
+        checkDestination: CheckDestination().messageQueue()
+      }),
+      xcmpQueue: () => ({
+        checkSource: CheckSource().polkadotXcmAndXcmpQueue(),
+        checkDestination: CheckDestination().xcmpQueue()
+      })
+    }),
+    xTokens: () => ({
+      messageQueue: () => ({
+        checkSource: CheckSource().xTokens(),
+        checkDestination: CheckDestination().messageQueue()
+      })
+    }),
+    // TODO mjm call ecosystem bridge or something?
+    bridgeMessages: () => ({
+      bridgeMessages: () => ({
+        checkSource: CheckSource().bridgeMessages(),
+        checkDestination: CheckDestination().bridgeMessages()
+      })
+    })
+  };
+}
+
 // src/mrl/providers/wormhole/contract/Batch/Batch.ts
 import {
   EvmParachain as EvmParachain2
@@ -3838,7 +4098,7 @@ function getCurrencies({ source, moonAsset, asset }) {
 }
 
 // src/mrl/providers/wormhole/contract/Gmp/Gmp.ts
-import { u8aToHex as u8aToHex6 } from "@polkadot/util";
+import { u8aToHex as u8aToHex7 } from "@polkadot/util";
 
 // src/mrl/providers/wormhole/contract/Gmp/GmpAbi.ts
 var GMP_ABI = [
@@ -3864,7 +4124,7 @@ function Gmp() {
   return {
     wormholeTransferERC20: () => ({
       build: ({ bytes }) => {
-        const hex = u8aToHex6(bytes);
+        const hex = u8aToHex7(bytes);
         return new ContractConfig({
           address: GMP_CONTRACT_ADDRESS,
           abi: GMP_ABI,
@@ -5611,6 +5871,7 @@ export {
   ExtrinsicBuilder,
   ExtrinsicConfig,
   FeeBuilder,
+  MonitoringBuilder,
   MrlBuilder,
   SubstrateCallConfig,
   SubstrateQueryConfig,