@moonbeam-network/xcm-builder 1.0.0-dev.224 → 1.0.0-dev.226

package/build/index.d.ts

@@ -4,8 +4,9 @@ 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 { TokenId, ChainAddress, TokenTransfer, Wormhole } from '@wormhole-foundation/sdk-connect';
+import { Wormhole, Network } from '@wormhole-foundation/sdk-connect';
 
 interface ConfigBuilder<Config, Params = BuilderParams> {
     build: (params: Params) => Config;
@@ -472,15 +473,54 @@ 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 MonitorEventReturn {
+    xcmPallet: () => {
+        messageQueue: () => EventMonitoringConfig$1;
+    };
+    polkadotXcm: () => {
+        messageQueue: () => EventMonitoringConfig$1;
+        mixedQueue: () => EventMonitoringConfig$1;
+        xcmpQueue: () => EventMonitoringConfig$1;
+    };
+    xTokens: () => {
+        messageQueue: () => EventMonitoringConfig$1;
+        ethereumXcm: () => EventMonitoringConfig$1;
+    };
+    bridgeMessages: () => {
+        bridgeMessages: () => EventMonitoringConfig$1;
+    };
+}
+interface EventMonitoringConfig$1 {
+    checkSource: SourceChecker;
+    checkDestination: DestinationChecker;
+}
+
+declare function monitorEvent(): MonitorEventReturn;
+
+declare function MonitoringBuilder(): {
+    monitorEvent: typeof monitorEvent;
+};
+
+interface MonitoringBuilderConfig {
+    eventMonitoring: EventMonitoringConfig;
+}
+interface EventMonitoringConfig {
+    checkSource: SourceChecker;
+    checkDestination: DestinationChecker;
+}
+
 type WormholeTransferFunctions = 'tokenTransfer';
-type WormholeFunctionArgs = [
-    TokenId,
-    bigint,
-    ChainAddress,
-    ChainAddress,
-    TokenTransfer.Protocol,
-    Uint8Array?
-];
+type WormholeFunctionArgs = Parameters<Wormhole<Network>[WormholeTransferFunctions]>;
 interface WormholeConfigConstructorParams {
     args: WormholeFunctionArgs;
     func: WormholeTransferFunctions;
@@ -496,7 +536,7 @@ declare function wormhole$1(): {
     tokenTransfer: () => MrlConfigBuilder;
 };
 
-declare function wormholeFactory(chain: AnyChain): Wormhole<"Testnet" | "Mainnet">;
+declare function wormholeFactory(chain: AnyChain): Wormhole<"Mainnet" | "Testnet">;
 
 type MrlConfigBuilder = ConfigBuilder<ContractConfig | ExtrinsicConfig | WormholeConfig, MrlBuilderParams>;
 type MrlExecuteConfigBuilder = ConfigBuilder<ContractConfig, MrlExecuteBuilderParams>;
@@ -656,4 +696,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, ERC20_ABI, type EquilibriumSystemBalanceData, type EventMonitoringConfig, type EvmFunctionArgs, EvmQueryConfig, type EvmQueryConfigParams, type EvmQueryFunctions, ExtrinsicBuilder, ExtrinsicConfig, type ExtrinsicConfigBuilder, type ExtrinsicConfigConstructorParams, FeeBuilder, type FeeConfigBuilder, type FeeConfigBuilderParams, type GetVersionedAssetId, MonitoringBuilder, type MonitoringBuilderConfig, 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 };

package/build/index.mjs

@@ -3054,6 +3054,263 @@ function FeeBuilder() {
   };
 }
 
+// src/monitoring/eventMonitoring/eventMonitoring.ts
+import { u8aToHex as u8aToHex7 } from "@polkadot/util";
+import { decodeAddress as decodeAddress7 } from "@polkadot/util-crypto";
+
+// src/monitoring/eventMonitoring/eventMonitoring.utils.ts
+import { u8aToHex as u8aToHex6 } from "@polkadot/util";
+import { decodeAddress as decodeAddress6 } from "@polkadot/util-crypto";
+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 };
+  }
+};
+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 };
+};
+
+// src/monitoring/eventMonitoring/eventMonitoring.ts
+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 u8aToHex7(decodeAddress7(eventData.sender.toString()));
+    }
+  };
+}
+function GetMessageId() {
+  return {
+    fromXcmEvent: () => (event) => {
+      const eventData = event.event.data;
+      return eventData.messageId.toHex();
+    },
+    fromXcmpQueue: () => (_event, events) => {
+      const xcmpEvent = events?.find(
+        (event) => event.event.section === "xcmpQueue" && event.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;
+      }
+    },
+    fromEthereumXcmEvent: () => (event) => {
+      const eventData = event.event.data;
+      return eventData.xcmMsgHash.toHex();
+    },
+    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";
+    },
+    alwaysTrue: () => () => true
+    // Always successful for simple cases
+  };
+}
+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) => {
+      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 messageIdMatcher = MatchMessageId().fromXcmpQueueHash();
+      const successEvent = events.find((event) => {
+        if (event.event.section !== "xcmpQueue" || event.event.method !== "Success") {
+          return false;
+        }
+        return messageIdMatcher(event, messageId);
+      });
+      const failEvent = events.find((event) => {
+        if (event.event.section !== "xcmpQueue" || event.event.method !== "Fail") {
+          return false;
+        }
+        return messageIdMatcher(event, messageId);
+      });
+      if (!successEvent && !failEvent) {
+        return { matched: false, success: false };
+      }
+      return {
+        matched: true,
+        success: !!successEvent,
+        event: successEvent || failEvent
+      };
+    },
+    bridgeMessages: () => createDestinationChecker(
+      "bridgeMessages",
+      "MessagesReceived",
+      // TODO implement message matching
+      MatchMessageId().never(),
+      GetIsSuccess().alwaysTrue()
+    ),
+    ethereumXcm: () => createDestinationChecker(
+      "ethereumXcm",
+      "ExecutedFromXcm",
+      MatchMessageId().never(),
+      GetIsSuccess().alwaysTrue()
+    )
+  };
+}
+function monitorEvent() {
+  return {
+    xcmPallet: () => ({
+      messageQueue: () => ({
+        checkSource: CheckSource().xcmPallet(),
+        checkDestination: CheckDestination().messageQueue()
+      })
+    }),
+    polkadotXcm: () => ({
+      messageQueue: () => ({
+        checkSource: CheckSource().polkadotXcm(),
+        checkDestination: CheckDestination().messageQueue()
+      }),
+      mixedQueue: () => ({
+        checkSource: CheckSource().polkadotXcmAndXcmpQueue(),
+        checkDestination: CheckDestination().messageQueue()
+      }),
+      xcmpQueue: () => ({
+        checkSource: CheckSource().polkadotXcmAndXcmpQueue(),
+        checkDestination: CheckDestination().xcmpQueue()
+      })
+    }),
+    xTokens: () => ({
+      messageQueue: () => ({
+        checkSource: CheckSource().xTokens(),
+        checkDestination: CheckDestination().messageQueue()
+      }),
+      ethereumXcm: () => ({
+        checkSource: CheckSource().xTokens(),
+        checkDestination: CheckDestination().ethereumXcm()
+      })
+    }),
+    bridgeMessages: () => ({
+      bridgeMessages: () => ({
+        checkSource: CheckSource().bridgeMessages(),
+        checkDestination: CheckDestination().bridgeMessages()
+      })
+    })
+  };
+}
+
+// src/monitoring/MonitoringBuilder.ts
+function MonitoringBuilder() {
+  return {
+    monitorEvent
+  };
+}
+
 // src/mrl/providers/wormhole/contract/Batch/Batch.ts
 import {
   EvmParachain as EvmParachain2
@@ -3956,7 +4213,7 @@ function getCurrencies({ source, moonAsset, asset }) {
 }
 
 // src/mrl/providers/wormhole/contract/Gmp/Gmp.ts
-import { u8aToHex as u8aToHex6 } from "@polkadot/util";
+import { u8aToHex as u8aToHex8 } from "@polkadot/util";
 
 // src/mrl/providers/wormhole/contract/Gmp/GmpAbi.ts
 var GMP_ABI = [
@@ -3982,7 +4239,7 @@ function Gmp() {
   return {
     wormholeTransferERC20: () => ({
       build: ({ bytes }) => {
-        const hex = u8aToHex6(bytes);
+        const hex = u8aToHex8(bytes);
         return new ContractConfig({
           address: GMP_CONTRACT_ADDRESS,
           abi: GMP_ABI,
@@ -4082,7 +4339,7 @@ function wormhole() {
             asset.amount,
             whSourceAddress,
             whDestinationAddress,
-            isAutomatic ? "AutomaticTokenBridge" : "TokenBridge",
+            isAutomatic,
             isDestinationMoonChain || isDestinationEvmChain ? void 0 : getPayload({ destination, destinationAddress, moonApi })
           ],
           func: "tokenTransfer"
@@ -5729,6 +5986,7 @@ export {
   ExtrinsicBuilder,
   ExtrinsicConfig,
   FeeBuilder,
+  MonitoringBuilder,
   MrlBuilder,
   SubstrateCallConfig,
   SubstrateQueryConfig,