@chainflip/processor 1.4.0

package/dist/141/index.mjs

@@ -0,0 +1,1019 @@
+// generated/141/index.ts
+import { wrapHandler } from "../utils.mjs";
+import { environmentAddedNewArbAsset } from "./environment/addedNewArbAsset.mjs";
+import { environmentUpdatedArbAsset } from "./environment/updatedArbAsset.mjs";
+import { environmentRuntimeSafeModeUpdated } from "./environment/runtimeSafeModeUpdated.mjs";
+import { environmentUtxoConsolidationParametersUpdated } from "./environment/utxoConsolidationParametersUpdated.mjs";
+import { environmentArbitrumInitialized } from "./environment/arbitrumInitialized.mjs";
+import { environmentStaleUtxosDiscarded } from "./environment/staleUtxosDiscarded.mjs";
+import { emissionsNetworkFeeBurned } from "./emissions/networkFeeBurned.mjs";
+import { accountRolesAccountRoleDeregistered } from "./accountRoles/accountRoleDeregistered.mjs";
+import { accountRolesVanityNameSet } from "./accountRoles/vanityNameSet.mjs";
+import { witnesserReportedWitnessingFailures } from "./witnesser/reportedWitnessingFailures.mjs";
+import { witnesserCallDispatched } from "./witnesser/callDispatched.mjs";
+import { validatorRotationPhaseUpdated } from "./validator/rotationPhaseUpdated.mjs";
+import { validatorStoppedBidding } from "./validator/stoppedBidding.mjs";
+import { validatorStartedBidding } from "./validator/startedBidding.mjs";
+import { tokenholderGovernanceProposalSubmitted } from "./tokenholderGovernance/proposalSubmitted.mjs";
+import { tokenholderGovernanceProposalPassed } from "./tokenholderGovernance/proposalPassed.mjs";
+import { tokenholderGovernanceProposalRejected } from "./tokenholderGovernance/proposalRejected.mjs";
+import { tokenholderGovernanceProposalEnacted } from "./tokenholderGovernance/proposalEnacted.mjs";
+import { tokenholderGovernanceGovKeyUpdatedHasFailed } from "./tokenholderGovernance/govKeyUpdatedHasFailed.mjs";
+import { tokenholderGovernanceGovKeyUpdatedWasSuccessful } from "./tokenholderGovernance/govKeyUpdatedWasSuccessful.mjs";
+import { ethereumVaultChainInitialized } from "./ethereumVault/chainInitialized.mjs";
+import { polkadotVaultChainInitialized } from "./polkadotVault/chainInitialized.mjs";
+import { bitcoinVaultChainInitialized } from "./bitcoinVault/chainInitialized.mjs";
+import { evmThresholdSignerThresholdSignatureRequest } from "./evmThresholdSigner/thresholdSignatureRequest.mjs";
+import { evmThresholdSignerThresholdSignatureFailed } from "./evmThresholdSigner/thresholdSignatureFailed.mjs";
+import { evmThresholdSignerThresholdSignatureSuccess } from "./evmThresholdSigner/thresholdSignatureSuccess.mjs";
+import { evmThresholdSignerThresholdDispatchComplete } from "./evmThresholdSigner/thresholdDispatchComplete.mjs";
+import { evmThresholdSignerRetryRequested } from "./evmThresholdSigner/retryRequested.mjs";
+import { evmThresholdSignerFailureReportProcessed } from "./evmThresholdSigner/failureReportProcessed.mjs";
+import { evmThresholdSignerSignersUnavailable } from "./evmThresholdSigner/signersUnavailable.mjs";
+import { evmThresholdSignerThresholdSignatureResponseTimeoutUpdated } from "./evmThresholdSigner/thresholdSignatureResponseTimeoutUpdated.mjs";
+import { evmThresholdSignerKeygenRequest } from "./evmThresholdSigner/keygenRequest.mjs";
+import { evmThresholdSignerKeyHandoverRequest } from "./evmThresholdSigner/keyHandoverRequest.mjs";
+import { evmThresholdSignerKeygenSuccessReported } from "./evmThresholdSigner/keygenSuccessReported.mjs";
+import { evmThresholdSignerKeyHandoverSuccessReported } from "./evmThresholdSigner/keyHandoverSuccessReported.mjs";
+import { evmThresholdSignerKeygenFailureReported } from "./evmThresholdSigner/keygenFailureReported.mjs";
+import { evmThresholdSignerKeyHandoverFailureReported } from "./evmThresholdSigner/keyHandoverFailureReported.mjs";
+import { evmThresholdSignerKeygenSuccess } from "./evmThresholdSigner/keygenSuccess.mjs";
+import { evmThresholdSignerKeyHandoverSuccess } from "./evmThresholdSigner/keyHandoverSuccess.mjs";
+import { evmThresholdSignerNoKeyHandover } from "./evmThresholdSigner/noKeyHandover.mjs";
+import { evmThresholdSignerKeygenVerificationSuccess } from "./evmThresholdSigner/keygenVerificationSuccess.mjs";
+import { evmThresholdSignerKeyHandoverVerificationSuccess } from "./evmThresholdSigner/keyHandoverVerificationSuccess.mjs";
+import { evmThresholdSignerKeygenVerificationFailure } from "./evmThresholdSigner/keygenVerificationFailure.mjs";
+import { evmThresholdSignerKeyHandoverVerificationFailure } from "./evmThresholdSigner/keyHandoverVerificationFailure.mjs";
+import { evmThresholdSignerKeygenFailure } from "./evmThresholdSigner/keygenFailure.mjs";
+import { evmThresholdSignerKeygenResponseTimeout } from "./evmThresholdSigner/keygenResponseTimeout.mjs";
+import { evmThresholdSignerKeyHandoverResponseTimeout } from "./evmThresholdSigner/keyHandoverResponseTimeout.mjs";
+import { evmThresholdSignerKeygenResponseTimeoutUpdated } from "./evmThresholdSigner/keygenResponseTimeoutUpdated.mjs";
+import { evmThresholdSignerKeyHandoverFailure } from "./evmThresholdSigner/keyHandoverFailure.mjs";
+import { evmThresholdSignerKeyRotationCompleted } from "./evmThresholdSigner/keyRotationCompleted.mjs";
+import { swappingSwapDepositAddressReady } from "./swapping/swapDepositAddressReady.mjs";
+import { swappingSwapScheduled } from "./swapping/swapScheduled.mjs";
+import { swappingSwapExecuted } from "./swapping/swapExecuted.mjs";
+import { swappingSwapEgressScheduled } from "./swapping/swapEgressScheduled.mjs";
+import { swappingWithdrawalRequested } from "./swapping/withdrawalRequested.mjs";
+import { swappingBatchSwapFailed } from "./swapping/batchSwapFailed.mjs";
+import { swappingCcmEgressScheduled } from "./swapping/ccmEgressScheduled.mjs";
+import { swappingCcmDepositReceived } from "./swapping/ccmDepositReceived.mjs";
+import { swappingCcmFailed } from "./swapping/ccmFailed.mjs";
+import { swappingMaximumSwapAmountSet } from "./swapping/maximumSwapAmountSet.mjs";
+import { swappingSwapAmountConfiscated } from "./swapping/swapAmountConfiscated.mjs";
+import { swappingSwapEgressIgnored } from "./swapping/swapEgressIgnored.mjs";
+import { liquidityProviderAccountDebited } from "./liquidityProvider/accountDebited.mjs";
+import { liquidityProviderAccountCredited } from "./liquidityProvider/accountCredited.mjs";
+import { liquidityProviderLiquidityDepositAddressReady } from "./liquidityProvider/liquidityDepositAddressReady.mjs";
+import { liquidityProviderWithdrawalEgressScheduled } from "./liquidityProvider/withdrawalEgressScheduled.mjs";
+import { liquidityProviderLiquidityRefundAddressRegistered } from "./liquidityProvider/liquidityRefundAddressRegistered.mjs";
+import { liquidityProviderLiquidityDepositCredited } from "./liquidityProvider/liquidityDepositCredited.mjs";
+import { liquidityProviderAssetTransferred } from "./liquidityProvider/assetTransferred.mjs";
+import { ethereumIngressEgressDepositFinalised } from "./ethereumIngressEgress/depositFinalised.mjs";
+import { ethereumIngressEgressCcmBroadcastRequested } from "./ethereumIngressEgress/ccmBroadcastRequested.mjs";
+import { ethereumIngressEgressCcmEgressInvalid } from "./ethereumIngressEgress/ccmEgressInvalid.mjs";
+import { ethereumIngressEgressBatchBroadcastRequested } from "./ethereumIngressEgress/batchBroadcastRequested.mjs";
+import { ethereumIngressEgressDepositBoosted } from "./ethereumIngressEgress/depositBoosted.mjs";
+import { ethereumIngressEgressBoostFundsAdded } from "./ethereumIngressEgress/boostFundsAdded.mjs";
+import { ethereumIngressEgressStoppedBoosting } from "./ethereumIngressEgress/stoppedBoosting.mjs";
+import { ethereumIngressEgressInsufficientBoostLiquidity } from "./ethereumIngressEgress/insufficientBoostLiquidity.mjs";
+import { ethereumIngressEgressBoostPoolCreated } from "./ethereumIngressEgress/boostPoolCreated.mjs";
+import { polkadotIngressEgressDepositFinalised } from "./polkadotIngressEgress/depositFinalised.mjs";
+import { polkadotIngressEgressCcmBroadcastRequested } from "./polkadotIngressEgress/ccmBroadcastRequested.mjs";
+import { polkadotIngressEgressCcmEgressInvalid } from "./polkadotIngressEgress/ccmEgressInvalid.mjs";
+import { polkadotIngressEgressBatchBroadcastRequested } from "./polkadotIngressEgress/batchBroadcastRequested.mjs";
+import { polkadotIngressEgressDepositBoosted } from "./polkadotIngressEgress/depositBoosted.mjs";
+import { polkadotIngressEgressBoostFundsAdded } from "./polkadotIngressEgress/boostFundsAdded.mjs";
+import { polkadotIngressEgressStoppedBoosting } from "./polkadotIngressEgress/stoppedBoosting.mjs";
+import { polkadotIngressEgressInsufficientBoostLiquidity } from "./polkadotIngressEgress/insufficientBoostLiquidity.mjs";
+import { polkadotIngressEgressBoostPoolCreated } from "./polkadotIngressEgress/boostPoolCreated.mjs";
+import { bitcoinIngressEgressDepositFinalised } from "./bitcoinIngressEgress/depositFinalised.mjs";
+import { bitcoinIngressEgressCcmBroadcastRequested } from "./bitcoinIngressEgress/ccmBroadcastRequested.mjs";
+import { bitcoinIngressEgressCcmEgressInvalid } from "./bitcoinIngressEgress/ccmEgressInvalid.mjs";
+import { bitcoinIngressEgressBatchBroadcastRequested } from "./bitcoinIngressEgress/batchBroadcastRequested.mjs";
+import { bitcoinIngressEgressDepositBoosted } from "./bitcoinIngressEgress/depositBoosted.mjs";
+import { bitcoinIngressEgressBoostFundsAdded } from "./bitcoinIngressEgress/boostFundsAdded.mjs";
+import { bitcoinIngressEgressStoppedBoosting } from "./bitcoinIngressEgress/stoppedBoosting.mjs";
+import { bitcoinIngressEgressInsufficientBoostLiquidity } from "./bitcoinIngressEgress/insufficientBoostLiquidity.mjs";
+import { bitcoinIngressEgressBoostPoolCreated } from "./bitcoinIngressEgress/boostPoolCreated.mjs";
+import { liquidityPoolsNewPoolCreated } from "./liquidityPools/newPoolCreated.mjs";
+import { liquidityPoolsRangeOrderUpdated } from "./liquidityPools/rangeOrderUpdated.mjs";
+import { liquidityPoolsLimitOrderUpdated } from "./liquidityPools/limitOrderUpdated.mjs";
+import { liquidityPoolsAssetSwapped } from "./liquidityPools/assetSwapped.mjs";
+import { liquidityPoolsPoolFeeSet } from "./liquidityPools/poolFeeSet.mjs";
+import { liquidityPoolsPriceImpactLimitSet } from "./liquidityPools/priceImpactLimitSet.mjs";
+import { arbitrumChainTrackingChainStateUpdated } from "./arbitrumChainTracking/chainStateUpdated.mjs";
+import { arbitrumChainTrackingFeeMultiplierUpdated } from "./arbitrumChainTracking/feeMultiplierUpdated.mjs";
+import { arbitrumVaultVaultActivationCompleted } from "./arbitrumVault/vaultActivationCompleted.mjs";
+import { arbitrumVaultVaultRotatedExternally } from "./arbitrumVault/vaultRotatedExternally.mjs";
+import { arbitrumVaultAwaitingGovernanceActivation } from "./arbitrumVault/awaitingGovernanceActivation.mjs";
+import { arbitrumVaultChainInitialized } from "./arbitrumVault/chainInitialized.mjs";
+import { arbitrumBroadcasterTransactionBroadcastRequest } from "./arbitrumBroadcaster/transactionBroadcastRequest.mjs";
+import { arbitrumBroadcasterBroadcastRetryScheduled } from "./arbitrumBroadcaster/broadcastRetryScheduled.mjs";
+import { arbitrumBroadcasterBroadcastTimeout } from "./arbitrumBroadcaster/broadcastTimeout.mjs";
+import { arbitrumBroadcasterBroadcastAborted } from "./arbitrumBroadcaster/broadcastAborted.mjs";
+import { arbitrumBroadcasterBroadcastSuccess } from "./arbitrumBroadcaster/broadcastSuccess.mjs";
+import { arbitrumBroadcasterThresholdSignatureInvalid } from "./arbitrumBroadcaster/thresholdSignatureInvalid.mjs";
+import { arbitrumBroadcasterBroadcastCallbackExecuted } from "./arbitrumBroadcaster/broadcastCallbackExecuted.mjs";
+import { arbitrumBroadcasterTransactionFeeDeficitRecorded } from "./arbitrumBroadcaster/transactionFeeDeficitRecorded.mjs";
+import { arbitrumBroadcasterTransactionFeeDeficitRefused } from "./arbitrumBroadcaster/transactionFeeDeficitRefused.mjs";
+import { arbitrumBroadcasterCallResigned } from "./arbitrumBroadcaster/callResigned.mjs";
+import { arbitrumIngressEgressDepositFinalised } from "./arbitrumIngressEgress/depositFinalised.mjs";
+import { arbitrumIngressEgressAssetEgressStatusChanged } from "./arbitrumIngressEgress/assetEgressStatusChanged.mjs";
+import { arbitrumIngressEgressCcmBroadcastRequested } from "./arbitrumIngressEgress/ccmBroadcastRequested.mjs";
+import { arbitrumIngressEgressCcmEgressInvalid } from "./arbitrumIngressEgress/ccmEgressInvalid.mjs";
+import { arbitrumIngressEgressDepositFetchesScheduled } from "./arbitrumIngressEgress/depositFetchesScheduled.mjs";
+import { arbitrumIngressEgressBatchBroadcastRequested } from "./arbitrumIngressEgress/batchBroadcastRequested.mjs";
+import { arbitrumIngressEgressMinimumDepositSet } from "./arbitrumIngressEgress/minimumDepositSet.mjs";
+import { arbitrumIngressEgressDepositIgnored } from "./arbitrumIngressEgress/depositIgnored.mjs";
+import { arbitrumIngressEgressTransferFallbackRequested } from "./arbitrumIngressEgress/transferFallbackRequested.mjs";
+import { arbitrumIngressEgressDepositWitnessRejected } from "./arbitrumIngressEgress/depositWitnessRejected.mjs";
+import { arbitrumIngressEgressCcmBroadcastFailed } from "./arbitrumIngressEgress/ccmBroadcastFailed.mjs";
+import { arbitrumIngressEgressFailedForeignChainCallResigned } from "./arbitrumIngressEgress/failedForeignChainCallResigned.mjs";
+import { arbitrumIngressEgressFailedForeignChainCallExpired } from "./arbitrumIngressEgress/failedForeignChainCallExpired.mjs";
+import { arbitrumIngressEgressUtxoConsolidation } from "./arbitrumIngressEgress/utxoConsolidation.mjs";
+import { arbitrumIngressEgressFailedToBuildAllBatchCall } from "./arbitrumIngressEgress/failedToBuildAllBatchCall.mjs";
+import { arbitrumIngressEgressChannelOpeningFeePaid } from "./arbitrumIngressEgress/channelOpeningFeePaid.mjs";
+import { arbitrumIngressEgressChannelOpeningFeeSet } from "./arbitrumIngressEgress/channelOpeningFeeSet.mjs";
+import { arbitrumIngressEgressDepositBoosted } from "./arbitrumIngressEgress/depositBoosted.mjs";
+import { arbitrumIngressEgressBoostFundsAdded } from "./arbitrumIngressEgress/boostFundsAdded.mjs";
+import { arbitrumIngressEgressStoppedBoosting } from "./arbitrumIngressEgress/stoppedBoosting.mjs";
+import { arbitrumIngressEgressInsufficientBoostLiquidity } from "./arbitrumIngressEgress/insufficientBoostLiquidity.mjs";
+import { arbitrumIngressEgressBoostPoolCreated } from "./arbitrumIngressEgress/boostPoolCreated.mjs";
+var handleEvents = (map) => ({
+  spec: 141,
+  handlers: [
+    {
+      name: "Environment.AddedNewArbAsset",
+      handler: wrapHandler(map.Environment?.AddedNewArbAsset, environmentAddedNewArbAsset)
+    },
+    {
+      name: "Environment.UpdatedArbAsset",
+      handler: wrapHandler(map.Environment?.UpdatedArbAsset, environmentUpdatedArbAsset)
+    },
+    {
+      name: "Environment.RuntimeSafeModeUpdated",
+      handler: wrapHandler(
+        map.Environment?.RuntimeSafeModeUpdated,
+        environmentRuntimeSafeModeUpdated
+      )
+    },
+    {
+      name: "Environment.UtxoConsolidationParametersUpdated",
+      handler: wrapHandler(
+        map.Environment?.UtxoConsolidationParametersUpdated,
+        environmentUtxoConsolidationParametersUpdated
+      )
+    },
+    {
+      name: "Environment.ArbitrumInitialized",
+      handler: wrapHandler(map.Environment?.ArbitrumInitialized, environmentArbitrumInitialized)
+    },
+    {
+      name: "Environment.StaleUtxosDiscarded",
+      handler: wrapHandler(map.Environment?.StaleUtxosDiscarded, environmentStaleUtxosDiscarded)
+    },
+    {
+      name: "Emissions.NetworkFeeBurned",
+      handler: wrapHandler(map.Emissions?.NetworkFeeBurned, emissionsNetworkFeeBurned)
+    },
+    {
+      name: "AccountRoles.AccountRoleDeregistered",
+      handler: wrapHandler(
+        map.AccountRoles?.AccountRoleDeregistered,
+        accountRolesAccountRoleDeregistered
+      )
+    },
+    {
+      name: "AccountRoles.VanityNameSet",
+      handler: wrapHandler(map.AccountRoles?.VanityNameSet, accountRolesVanityNameSet)
+    },
+    {
+      name: "Witnesser.ReportedWitnessingFailures",
+      handler: wrapHandler(
+        map.Witnesser?.ReportedWitnessingFailures,
+        witnesserReportedWitnessingFailures
+      )
+    },
+    {
+      name: "Witnesser.CallDispatched",
+      handler: wrapHandler(map.Witnesser?.CallDispatched, witnesserCallDispatched)
+    },
+    {
+      name: "Validator.RotationPhaseUpdated",
+      handler: wrapHandler(map.Validator?.RotationPhaseUpdated, validatorRotationPhaseUpdated)
+    },
+    {
+      name: "Validator.StoppedBidding",
+      handler: wrapHandler(map.Validator?.StoppedBidding, validatorStoppedBidding)
+    },
+    {
+      name: "Validator.StartedBidding",
+      handler: wrapHandler(map.Validator?.StartedBidding, validatorStartedBidding)
+    },
+    {
+      name: "TokenholderGovernance.ProposalSubmitted",
+      handler: wrapHandler(
+        map.TokenholderGovernance?.ProposalSubmitted,
+        tokenholderGovernanceProposalSubmitted
+      )
+    },
+    {
+      name: "TokenholderGovernance.ProposalPassed",
+      handler: wrapHandler(
+        map.TokenholderGovernance?.ProposalPassed,
+        tokenholderGovernanceProposalPassed
+      )
+    },
+    {
+      name: "TokenholderGovernance.ProposalRejected",
+      handler: wrapHandler(
+        map.TokenholderGovernance?.ProposalRejected,
+        tokenholderGovernanceProposalRejected
+      )
+    },
+    {
+      name: "TokenholderGovernance.ProposalEnacted",
+      handler: wrapHandler(
+        map.TokenholderGovernance?.ProposalEnacted,
+        tokenholderGovernanceProposalEnacted
+      )
+    },
+    {
+      name: "TokenholderGovernance.GovKeyUpdatedHasFailed",
+      handler: wrapHandler(
+        map.TokenholderGovernance?.GovKeyUpdatedHasFailed,
+        tokenholderGovernanceGovKeyUpdatedHasFailed
+      )
+    },
+    {
+      name: "TokenholderGovernance.GovKeyUpdatedWasSuccessful",
+      handler: wrapHandler(
+        map.TokenholderGovernance?.GovKeyUpdatedWasSuccessful,
+        tokenholderGovernanceGovKeyUpdatedWasSuccessful
+      )
+    },
+    {
+      name: "EthereumVault.ChainInitialized",
+      handler: wrapHandler(map.EthereumVault?.ChainInitialized, ethereumVaultChainInitialized)
+    },
+    {
+      name: "PolkadotVault.ChainInitialized",
+      handler: wrapHandler(map.PolkadotVault?.ChainInitialized, polkadotVaultChainInitialized)
+    },
+    {
+      name: "BitcoinVault.ChainInitialized",
+      handler: wrapHandler(map.BitcoinVault?.ChainInitialized, bitcoinVaultChainInitialized)
+    },
+    {
+      name: "EvmThresholdSigner.ThresholdSignatureRequest",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.ThresholdSignatureRequest,
+        evmThresholdSignerThresholdSignatureRequest
+      )
+    },
+    {
+      name: "EvmThresholdSigner.ThresholdSignatureFailed",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.ThresholdSignatureFailed,
+        evmThresholdSignerThresholdSignatureFailed
+      )
+    },
+    {
+      name: "EvmThresholdSigner.ThresholdSignatureSuccess",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.ThresholdSignatureSuccess,
+        evmThresholdSignerThresholdSignatureSuccess
+      )
+    },
+    {
+      name: "EvmThresholdSigner.ThresholdDispatchComplete",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.ThresholdDispatchComplete,
+        evmThresholdSignerThresholdDispatchComplete
+      )
+    },
+    {
+      name: "EvmThresholdSigner.RetryRequested",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.RetryRequested,
+        evmThresholdSignerRetryRequested
+      )
+    },
+    {
+      name: "EvmThresholdSigner.FailureReportProcessed",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.FailureReportProcessed,
+        evmThresholdSignerFailureReportProcessed
+      )
+    },
+    {
+      name: "EvmThresholdSigner.SignersUnavailable",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.SignersUnavailable,
+        evmThresholdSignerSignersUnavailable
+      )
+    },
+    {
+      name: "EvmThresholdSigner.ThresholdSignatureResponseTimeoutUpdated",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.ThresholdSignatureResponseTimeoutUpdated,
+        evmThresholdSignerThresholdSignatureResponseTimeoutUpdated
+      )
+    },
+    {
+      name: "EvmThresholdSigner.KeygenRequest",
+      handler: wrapHandler(map.EvmThresholdSigner?.KeygenRequest, evmThresholdSignerKeygenRequest)
+    },
+    {
+      name: "EvmThresholdSigner.KeyHandoverRequest",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.KeyHandoverRequest,
+        evmThresholdSignerKeyHandoverRequest
+      )
+    },
+    {
+      name: "EvmThresholdSigner.KeygenSuccessReported",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.KeygenSuccessReported,
+        evmThresholdSignerKeygenSuccessReported
+      )
+    },
+    {
+      name: "EvmThresholdSigner.KeyHandoverSuccessReported",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.KeyHandoverSuccessReported,
+        evmThresholdSignerKeyHandoverSuccessReported
+      )
+    },
+    {
+      name: "EvmThresholdSigner.KeygenFailureReported",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.KeygenFailureReported,
+        evmThresholdSignerKeygenFailureReported
+      )
+    },
+    {
+      name: "EvmThresholdSigner.KeyHandoverFailureReported",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.KeyHandoverFailureReported,
+        evmThresholdSignerKeyHandoverFailureReported
+      )
+    },
+    {
+      name: "EvmThresholdSigner.KeygenSuccess",
+      handler: wrapHandler(map.EvmThresholdSigner?.KeygenSuccess, evmThresholdSignerKeygenSuccess)
+    },
+    {
+      name: "EvmThresholdSigner.KeyHandoverSuccess",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.KeyHandoverSuccess,
+        evmThresholdSignerKeyHandoverSuccess
+      )
+    },
+    {
+      name: "EvmThresholdSigner.NoKeyHandover",
+      handler: wrapHandler(map.EvmThresholdSigner?.NoKeyHandover, evmThresholdSignerNoKeyHandover)
+    },
+    {
+      name: "EvmThresholdSigner.KeygenVerificationSuccess",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.KeygenVerificationSuccess,
+        evmThresholdSignerKeygenVerificationSuccess
+      )
+    },
+    {
+      name: "EvmThresholdSigner.KeyHandoverVerificationSuccess",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.KeyHandoverVerificationSuccess,
+        evmThresholdSignerKeyHandoverVerificationSuccess
+      )
+    },
+    {
+      name: "EvmThresholdSigner.KeygenVerificationFailure",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.KeygenVerificationFailure,
+        evmThresholdSignerKeygenVerificationFailure
+      )
+    },
+    {
+      name: "EvmThresholdSigner.KeyHandoverVerificationFailure",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.KeyHandoverVerificationFailure,
+        evmThresholdSignerKeyHandoverVerificationFailure
+      )
+    },
+    {
+      name: "EvmThresholdSigner.KeygenFailure",
+      handler: wrapHandler(map.EvmThresholdSigner?.KeygenFailure, evmThresholdSignerKeygenFailure)
+    },
+    {
+      name: "EvmThresholdSigner.KeygenResponseTimeout",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.KeygenResponseTimeout,
+        evmThresholdSignerKeygenResponseTimeout
+      )
+    },
+    {
+      name: "EvmThresholdSigner.KeyHandoverResponseTimeout",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.KeyHandoverResponseTimeout,
+        evmThresholdSignerKeyHandoverResponseTimeout
+      )
+    },
+    {
+      name: "EvmThresholdSigner.KeygenResponseTimeoutUpdated",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.KeygenResponseTimeoutUpdated,
+        evmThresholdSignerKeygenResponseTimeoutUpdated
+      )
+    },
+    {
+      name: "EvmThresholdSigner.KeyHandoverFailure",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.KeyHandoverFailure,
+        evmThresholdSignerKeyHandoverFailure
+      )
+    },
+    {
+      name: "EvmThresholdSigner.KeyRotationCompleted",
+      handler: wrapHandler(
+        map.EvmThresholdSigner?.KeyRotationCompleted,
+        evmThresholdSignerKeyRotationCompleted
+      )
+    },
+    {
+      name: "Swapping.SwapDepositAddressReady",
+      handler: wrapHandler(map.Swapping?.SwapDepositAddressReady, swappingSwapDepositAddressReady)
+    },
+    {
+      name: "Swapping.SwapScheduled",
+      handler: wrapHandler(map.Swapping?.SwapScheduled, swappingSwapScheduled)
+    },
+    {
+      name: "Swapping.SwapExecuted",
+      handler: wrapHandler(map.Swapping?.SwapExecuted, swappingSwapExecuted)
+    },
+    {
+      name: "Swapping.SwapEgressScheduled",
+      handler: wrapHandler(map.Swapping?.SwapEgressScheduled, swappingSwapEgressScheduled)
+    },
+    {
+      name: "Swapping.WithdrawalRequested",
+      handler: wrapHandler(map.Swapping?.WithdrawalRequested, swappingWithdrawalRequested)
+    },
+    {
+      name: "Swapping.BatchSwapFailed",
+      handler: wrapHandler(map.Swapping?.BatchSwapFailed, swappingBatchSwapFailed)
+    },
+    {
+      name: "Swapping.CcmEgressScheduled",
+      handler: wrapHandler(map.Swapping?.CcmEgressScheduled, swappingCcmEgressScheduled)
+    },
+    {
+      name: "Swapping.CcmDepositReceived",
+      handler: wrapHandler(map.Swapping?.CcmDepositReceived, swappingCcmDepositReceived)
+    },
+    {
+      name: "Swapping.CcmFailed",
+      handler: wrapHandler(map.Swapping?.CcmFailed, swappingCcmFailed)
+    },
+    {
+      name: "Swapping.MaximumSwapAmountSet",
+      handler: wrapHandler(map.Swapping?.MaximumSwapAmountSet, swappingMaximumSwapAmountSet)
+    },
+    {
+      name: "Swapping.SwapAmountConfiscated",
+      handler: wrapHandler(map.Swapping?.SwapAmountConfiscated, swappingSwapAmountConfiscated)
+    },
+    {
+      name: "Swapping.SwapEgressIgnored",
+      handler: wrapHandler(map.Swapping?.SwapEgressIgnored, swappingSwapEgressIgnored)
+    },
+    {
+      name: "LiquidityProvider.AccountDebited",
+      handler: wrapHandler(map.LiquidityProvider?.AccountDebited, liquidityProviderAccountDebited)
+    },
+    {
+      name: "LiquidityProvider.AccountCredited",
+      handler: wrapHandler(
+        map.LiquidityProvider?.AccountCredited,
+        liquidityProviderAccountCredited
+      )
+    },
+    {
+      name: "LiquidityProvider.LiquidityDepositAddressReady",
+      handler: wrapHandler(
+        map.LiquidityProvider?.LiquidityDepositAddressReady,
+        liquidityProviderLiquidityDepositAddressReady
+      )
+    },
+    {
+      name: "LiquidityProvider.WithdrawalEgressScheduled",
+      handler: wrapHandler(
+        map.LiquidityProvider?.WithdrawalEgressScheduled,
+        liquidityProviderWithdrawalEgressScheduled
+      )
+    },
+    {
+      name: "LiquidityProvider.LiquidityRefundAddressRegistered",
+      handler: wrapHandler(
+        map.LiquidityProvider?.LiquidityRefundAddressRegistered,
+        liquidityProviderLiquidityRefundAddressRegistered
+      )
+    },
+    {
+      name: "LiquidityProvider.LiquidityDepositCredited",
+      handler: wrapHandler(
+        map.LiquidityProvider?.LiquidityDepositCredited,
+        liquidityProviderLiquidityDepositCredited
+      )
+    },
+    {
+      name: "LiquidityProvider.AssetTransferred",
+      handler: wrapHandler(
+        map.LiquidityProvider?.AssetTransferred,
+        liquidityProviderAssetTransferred
+      )
+    },
+    {
+      name: "EthereumIngressEgress.DepositFinalised",
+      handler: wrapHandler(
+        map.EthereumIngressEgress?.DepositFinalised,
+        ethereumIngressEgressDepositFinalised
+      )
+    },
+    {
+      name: "EthereumIngressEgress.CcmBroadcastRequested",
+      handler: wrapHandler(
+        map.EthereumIngressEgress?.CcmBroadcastRequested,
+        ethereumIngressEgressCcmBroadcastRequested
+      )
+    },
+    {
+      name: "EthereumIngressEgress.CcmEgressInvalid",
+      handler: wrapHandler(
+        map.EthereumIngressEgress?.CcmEgressInvalid,
+        ethereumIngressEgressCcmEgressInvalid
+      )
+    },
+    {
+      name: "EthereumIngressEgress.BatchBroadcastRequested",
+      handler: wrapHandler(
+        map.EthereumIngressEgress?.BatchBroadcastRequested,
+        ethereumIngressEgressBatchBroadcastRequested
+      )
+    },
+    {
+      name: "EthereumIngressEgress.DepositBoosted",
+      handler: wrapHandler(
+        map.EthereumIngressEgress?.DepositBoosted,
+        ethereumIngressEgressDepositBoosted
+      )
+    },
+    {
+      name: "EthereumIngressEgress.BoostFundsAdded",
+      handler: wrapHandler(
+        map.EthereumIngressEgress?.BoostFundsAdded,
+        ethereumIngressEgressBoostFundsAdded
+      )
+    },
+    {
+      name: "EthereumIngressEgress.StoppedBoosting",
+      handler: wrapHandler(
+        map.EthereumIngressEgress?.StoppedBoosting,
+        ethereumIngressEgressStoppedBoosting
+      )
+    },
+    {
+      name: "EthereumIngressEgress.InsufficientBoostLiquidity",
+      handler: wrapHandler(
+        map.EthereumIngressEgress?.InsufficientBoostLiquidity,
+        ethereumIngressEgressInsufficientBoostLiquidity
+      )
+    },
+    {
+      name: "EthereumIngressEgress.BoostPoolCreated",
+      handler: wrapHandler(
+        map.EthereumIngressEgress?.BoostPoolCreated,
+        ethereumIngressEgressBoostPoolCreated
+      )
+    },
+    {
+      name: "PolkadotIngressEgress.DepositFinalised",
+      handler: wrapHandler(
+        map.PolkadotIngressEgress?.DepositFinalised,
+        polkadotIngressEgressDepositFinalised
+      )
+    },
+    {
+      name: "PolkadotIngressEgress.CcmBroadcastRequested",
+      handler: wrapHandler(
+        map.PolkadotIngressEgress?.CcmBroadcastRequested,
+        polkadotIngressEgressCcmBroadcastRequested
+      )
+    },
+    {
+      name: "PolkadotIngressEgress.CcmEgressInvalid",
+      handler: wrapHandler(
+        map.PolkadotIngressEgress?.CcmEgressInvalid,
+        polkadotIngressEgressCcmEgressInvalid
+      )
+    },
+    {
+      name: "PolkadotIngressEgress.BatchBroadcastRequested",
+      handler: wrapHandler(
+        map.PolkadotIngressEgress?.BatchBroadcastRequested,
+        polkadotIngressEgressBatchBroadcastRequested
+      )
+    },
+    {
+      name: "PolkadotIngressEgress.DepositBoosted",
+      handler: wrapHandler(
+        map.PolkadotIngressEgress?.DepositBoosted,
+        polkadotIngressEgressDepositBoosted
+      )
+    },
+    {
+      name: "PolkadotIngressEgress.BoostFundsAdded",
+      handler: wrapHandler(
+        map.PolkadotIngressEgress?.BoostFundsAdded,
+        polkadotIngressEgressBoostFundsAdded
+      )
+    },
+    {
+      name: "PolkadotIngressEgress.StoppedBoosting",
+      handler: wrapHandler(
+        map.PolkadotIngressEgress?.StoppedBoosting,
+        polkadotIngressEgressStoppedBoosting
+      )
+    },
+    {
+      name: "PolkadotIngressEgress.InsufficientBoostLiquidity",
+      handler: wrapHandler(
+        map.PolkadotIngressEgress?.InsufficientBoostLiquidity,
+        polkadotIngressEgressInsufficientBoostLiquidity
+      )
+    },
+    {
+      name: "PolkadotIngressEgress.BoostPoolCreated",
+      handler: wrapHandler(
+        map.PolkadotIngressEgress?.BoostPoolCreated,
+        polkadotIngressEgressBoostPoolCreated
+      )
+    },
+    {
+      name: "BitcoinIngressEgress.DepositFinalised",
+      handler: wrapHandler(
+        map.BitcoinIngressEgress?.DepositFinalised,
+        bitcoinIngressEgressDepositFinalised
+      )
+    },
+    {
+      name: "BitcoinIngressEgress.CcmBroadcastRequested",
+      handler: wrapHandler(
+        map.BitcoinIngressEgress?.CcmBroadcastRequested,
+        bitcoinIngressEgressCcmBroadcastRequested
+      )
+    },
+    {
+      name: "BitcoinIngressEgress.CcmEgressInvalid",
+      handler: wrapHandler(
+        map.BitcoinIngressEgress?.CcmEgressInvalid,
+        bitcoinIngressEgressCcmEgressInvalid
+      )
+    },
+    {
+      name: "BitcoinIngressEgress.BatchBroadcastRequested",
+      handler: wrapHandler(
+        map.BitcoinIngressEgress?.BatchBroadcastRequested,
+        bitcoinIngressEgressBatchBroadcastRequested
+      )
+    },
+    {
+      name: "BitcoinIngressEgress.DepositBoosted",
+      handler: wrapHandler(
+        map.BitcoinIngressEgress?.DepositBoosted,
+        bitcoinIngressEgressDepositBoosted
+      )
+    },
+    {
+      name: "BitcoinIngressEgress.BoostFundsAdded",
+      handler: wrapHandler(
+        map.BitcoinIngressEgress?.BoostFundsAdded,
+        bitcoinIngressEgressBoostFundsAdded
+      )
+    },
+    {
+      name: "BitcoinIngressEgress.StoppedBoosting",
+      handler: wrapHandler(
+        map.BitcoinIngressEgress?.StoppedBoosting,
+        bitcoinIngressEgressStoppedBoosting
+      )
+    },
+    {
+      name: "BitcoinIngressEgress.InsufficientBoostLiquidity",
+      handler: wrapHandler(
+        map.BitcoinIngressEgress?.InsufficientBoostLiquidity,
+        bitcoinIngressEgressInsufficientBoostLiquidity
+      )
+    },
+    {
+      name: "BitcoinIngressEgress.BoostPoolCreated",
+      handler: wrapHandler(
+        map.BitcoinIngressEgress?.BoostPoolCreated,
+        bitcoinIngressEgressBoostPoolCreated
+      )
+    },
+    {
+      name: "LiquidityPools.NewPoolCreated",
+      handler: wrapHandler(map.LiquidityPools?.NewPoolCreated, liquidityPoolsNewPoolCreated)
+    },
+    {
+      name: "LiquidityPools.RangeOrderUpdated",
+      handler: wrapHandler(map.LiquidityPools?.RangeOrderUpdated, liquidityPoolsRangeOrderUpdated)
+    },
+    {
+      name: "LiquidityPools.LimitOrderUpdated",
+      handler: wrapHandler(map.LiquidityPools?.LimitOrderUpdated, liquidityPoolsLimitOrderUpdated)
+    },
+    {
+      name: "LiquidityPools.AssetSwapped",
+      handler: wrapHandler(map.LiquidityPools?.AssetSwapped, liquidityPoolsAssetSwapped)
+    },
+    {
+      name: "LiquidityPools.PoolFeeSet",
+      handler: wrapHandler(map.LiquidityPools?.PoolFeeSet, liquidityPoolsPoolFeeSet)
+    },
+    {
+      name: "LiquidityPools.PriceImpactLimitSet",
+      handler: wrapHandler(
+        map.LiquidityPools?.PriceImpactLimitSet,
+        liquidityPoolsPriceImpactLimitSet
+      )
+    },
+    {
+      name: "ArbitrumChainTracking.ChainStateUpdated",
+      handler: wrapHandler(
+        map.ArbitrumChainTracking?.ChainStateUpdated,
+        arbitrumChainTrackingChainStateUpdated
+      )
+    },
+    {
+      name: "ArbitrumChainTracking.FeeMultiplierUpdated",
+      handler: wrapHandler(
+        map.ArbitrumChainTracking?.FeeMultiplierUpdated,
+        arbitrumChainTrackingFeeMultiplierUpdated
+      )
+    },
+    {
+      name: "ArbitrumVault.VaultActivationCompleted",
+      handler: wrapHandler(
+        map.ArbitrumVault?.VaultActivationCompleted,
+        arbitrumVaultVaultActivationCompleted
+      )
+    },
+    {
+      name: "ArbitrumVault.VaultRotatedExternally",
+      handler: wrapHandler(
+        map.ArbitrumVault?.VaultRotatedExternally,
+        arbitrumVaultVaultRotatedExternally
+      )
+    },
+    {
+      name: "ArbitrumVault.AwaitingGovernanceActivation",
+      handler: wrapHandler(
+        map.ArbitrumVault?.AwaitingGovernanceActivation,
+        arbitrumVaultAwaitingGovernanceActivation
+      )
+    },
+    {
+      name: "ArbitrumVault.ChainInitialized",
+      handler: wrapHandler(map.ArbitrumVault?.ChainInitialized, arbitrumVaultChainInitialized)
+    },
+    {
+      name: "ArbitrumBroadcaster.TransactionBroadcastRequest",
+      handler: wrapHandler(
+        map.ArbitrumBroadcaster?.TransactionBroadcastRequest,
+        arbitrumBroadcasterTransactionBroadcastRequest
+      )
+    },
+    {
+      name: "ArbitrumBroadcaster.BroadcastRetryScheduled",
+      handler: wrapHandler(
+        map.ArbitrumBroadcaster?.BroadcastRetryScheduled,
+        arbitrumBroadcasterBroadcastRetryScheduled
+      )
+    },
+    {
+      name: "ArbitrumBroadcaster.BroadcastTimeout",
+      handler: wrapHandler(
+        map.ArbitrumBroadcaster?.BroadcastTimeout,
+        arbitrumBroadcasterBroadcastTimeout
+      )
+    },
+    {
+      name: "ArbitrumBroadcaster.BroadcastAborted",
+      handler: wrapHandler(
+        map.ArbitrumBroadcaster?.BroadcastAborted,
+        arbitrumBroadcasterBroadcastAborted
+      )
+    },
+    {
+      name: "ArbitrumBroadcaster.BroadcastSuccess",
+      handler: wrapHandler(
+        map.ArbitrumBroadcaster?.BroadcastSuccess,
+        arbitrumBroadcasterBroadcastSuccess
+      )
+    },
+    {
+      name: "ArbitrumBroadcaster.ThresholdSignatureInvalid",
+      handler: wrapHandler(
+        map.ArbitrumBroadcaster?.ThresholdSignatureInvalid,
+        arbitrumBroadcasterThresholdSignatureInvalid
+      )
+    },
+    {
+      name: "ArbitrumBroadcaster.BroadcastCallbackExecuted",
+      handler: wrapHandler(
+        map.ArbitrumBroadcaster?.BroadcastCallbackExecuted,
+        arbitrumBroadcasterBroadcastCallbackExecuted
+      )
+    },
+    {
+      name: "ArbitrumBroadcaster.TransactionFeeDeficitRecorded",
+      handler: wrapHandler(
+        map.ArbitrumBroadcaster?.TransactionFeeDeficitRecorded,
+        arbitrumBroadcasterTransactionFeeDeficitRecorded
+      )
+    },
+    {
+      name: "ArbitrumBroadcaster.TransactionFeeDeficitRefused",
+      handler: wrapHandler(
+        map.ArbitrumBroadcaster?.TransactionFeeDeficitRefused,
+        arbitrumBroadcasterTransactionFeeDeficitRefused
+      )
+    },
+    {
+      name: "ArbitrumBroadcaster.CallResigned",
+      handler: wrapHandler(map.ArbitrumBroadcaster?.CallResigned, arbitrumBroadcasterCallResigned)
+    },
+    {
+      name: "ArbitrumIngressEgress.DepositFinalised",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.DepositFinalised,
+        arbitrumIngressEgressDepositFinalised
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.AssetEgressStatusChanged",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.AssetEgressStatusChanged,
+        arbitrumIngressEgressAssetEgressStatusChanged
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.CcmBroadcastRequested",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.CcmBroadcastRequested,
+        arbitrumIngressEgressCcmBroadcastRequested
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.CcmEgressInvalid",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.CcmEgressInvalid,
+        arbitrumIngressEgressCcmEgressInvalid
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.DepositFetchesScheduled",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.DepositFetchesScheduled,
+        arbitrumIngressEgressDepositFetchesScheduled
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.BatchBroadcastRequested",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.BatchBroadcastRequested,
+        arbitrumIngressEgressBatchBroadcastRequested
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.MinimumDepositSet",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.MinimumDepositSet,
+        arbitrumIngressEgressMinimumDepositSet
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.DepositIgnored",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.DepositIgnored,
+        arbitrumIngressEgressDepositIgnored
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.TransferFallbackRequested",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.TransferFallbackRequested,
+        arbitrumIngressEgressTransferFallbackRequested
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.DepositWitnessRejected",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.DepositWitnessRejected,
+        arbitrumIngressEgressDepositWitnessRejected
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.CcmBroadcastFailed",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.CcmBroadcastFailed,
+        arbitrumIngressEgressCcmBroadcastFailed
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.FailedForeignChainCallResigned",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.FailedForeignChainCallResigned,
+        arbitrumIngressEgressFailedForeignChainCallResigned
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.FailedForeignChainCallExpired",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.FailedForeignChainCallExpired,
+        arbitrumIngressEgressFailedForeignChainCallExpired
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.UtxoConsolidation",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.UtxoConsolidation,
+        arbitrumIngressEgressUtxoConsolidation
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.FailedToBuildAllBatchCall",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.FailedToBuildAllBatchCall,
+        arbitrumIngressEgressFailedToBuildAllBatchCall
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.ChannelOpeningFeePaid",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.ChannelOpeningFeePaid,
+        arbitrumIngressEgressChannelOpeningFeePaid
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.ChannelOpeningFeeSet",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.ChannelOpeningFeeSet,
+        arbitrumIngressEgressChannelOpeningFeeSet
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.DepositBoosted",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.DepositBoosted,
+        arbitrumIngressEgressDepositBoosted
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.BoostFundsAdded",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.BoostFundsAdded,
+        arbitrumIngressEgressBoostFundsAdded
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.StoppedBoosting",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.StoppedBoosting,
+        arbitrumIngressEgressStoppedBoosting
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.InsufficientBoostLiquidity",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.InsufficientBoostLiquidity,
+        arbitrumIngressEgressInsufficientBoostLiquidity
+      )
+    },
+    {
+      name: "ArbitrumIngressEgress.BoostPoolCreated",
+      handler: wrapHandler(
+        map.ArbitrumIngressEgress?.BoostPoolCreated,
+        arbitrumIngressEgressBoostPoolCreated
+      )
+    }
+  ].filter((h) => h.handler !== void 0)
+});
+export {
+  handleEvents
+};