@chainflip/processor 1.4.0

package/dist/100/index.mjs

@@ -0,0 +1,1732 @@
+// generated/100/index.ts
+import { wrapHandler } from "../utils.mjs";
+import { systemExtrinsicSuccess } from "./system/extrinsicSuccess.mjs";
+import { systemExtrinsicFailed } from "./system/extrinsicFailed.mjs";
+import { systemCodeUpdated } from "./system/codeUpdated.mjs";
+import { systemNewAccount } from "./system/newAccount.mjs";
+import { systemKilledAccount } from "./system/killedAccount.mjs";
+import { systemRemarked } from "./system/remarked.mjs";
+import { environmentAddedNewEthAsset } from "./environment/addedNewEthAsset.mjs";
+import { environmentUpdatedEthAsset } from "./environment/updatedEthAsset.mjs";
+import { environmentPolkadotVaultAccountSet } from "./environment/polkadotVaultAccountSet.mjs";
+import { environmentBitcoinBlockNumberSetForVault } from "./environment/bitcoinBlockNumberSetForVault.mjs";
+import { environmentRuntimeSafeModeUpdated } from "./environment/runtimeSafeModeUpdated.mjs";
+import { flipRemainingImbalance } from "./flip/remainingImbalance.mjs";
+import { flipSlashingPerformed } from "./flip/slashingPerformed.mjs";
+import { flipAccountReaped } from "./flip/accountReaped.mjs";
+import { flipSlashingRateUpdated } from "./flip/slashingRateUpdated.mjs";
+import { emissionsSupplyUpdateBroadcastRequested } from "./emissions/supplyUpdateBroadcastRequested.mjs";
+import { emissionsCurrentAuthorityInflationEmissionsUpdated } from "./emissions/currentAuthorityInflationEmissionsUpdated.mjs";
+import { emissionsBackupNodeInflationEmissionsUpdated } from "./emissions/backupNodeInflationEmissionsUpdated.mjs";
+import { emissionsSupplyUpdateIntervalUpdated } from "./emissions/supplyUpdateIntervalUpdated.mjs";
+import { fundingFunded } from "./funding/funded.mjs";
+import { fundingRedemptionRequested } from "./funding/redemptionRequested.mjs";
+import { fundingRedemptionSettled } from "./funding/redemptionSettled.mjs";
+import { fundingStoppedBidding } from "./funding/stoppedBidding.mjs";
+import { fundingStartedBidding } from "./funding/startedBidding.mjs";
+import { fundingRedemptionExpired } from "./funding/redemptionExpired.mjs";
+import { fundingAddedRestrictedAddress } from "./funding/addedRestrictedAddress.mjs";
+import { fundingRemovedRestrictedAddress } from "./funding/removedRestrictedAddress.mjs";
+import { fundingFailedFundingAttempt } from "./funding/failedFundingAttempt.mjs";
+import { fundingMinimumFundingUpdated } from "./funding/minimumFundingUpdated.mjs";
+import { fundingRedemptionTaxAmountUpdated } from "./funding/redemptionTaxAmountUpdated.mjs";
+import { fundingRedemptionAmountZero } from "./funding/redemptionAmountZero.mjs";
+import { fundingBoundRedeemAddress } from "./funding/boundRedeemAddress.mjs";
+import { fundingBoundExecutorAddress } from "./funding/boundExecutorAddress.mjs";
+import { accountRolesAccountRoleRegistered } from "./accountRoles/accountRoleRegistered.mjs";
+import { transactionPaymentTransactionFeePaid } from "./transactionPayment/transactionFeePaid.mjs";
+import { witnesserWitnessExecutionFailed } from "./witnesser/witnessExecutionFailed.mjs";
+import { witnesserPrewitnessed } from "./witnesser/prewitnessed.mjs";
+import { validatorRotationAborted } from "./validator/rotationAborted.mjs";
+import { validatorNewEpoch } from "./validator/newEpoch.mjs";
+import { validatorRotationPhaseUpdated } from "./validator/rotationPhaseUpdated.mjs";
+import { validatorCFEVersionUpdated } from "./validator/cFEVersionUpdated.mjs";
+import { validatorPeerIdRegistered } from "./validator/peerIdRegistered.mjs";
+import { validatorPeerIdUnregistered } from "./validator/peerIdUnregistered.mjs";
+import { validatorVanityNameSet } from "./validator/vanityNameSet.mjs";
+import { validatorAuctionCompleted } from "./validator/auctionCompleted.mjs";
+import { validatorPalletConfigUpdated } from "./validator/palletConfigUpdated.mjs";
+import { sessionNewSession } from "./session/newSession.mjs";
+import { grandpaNewAuthorities } from "./grandpa/newAuthorities.mjs";
+import { grandpaPaused } from "./grandpa/paused.mjs";
+import { grandpaResumed } from "./grandpa/resumed.mjs";
+import { governanceProposed } from "./governance/proposed.mjs";
+import { governanceExecuted } from "./governance/executed.mjs";
+import { governanceExpired } from "./governance/expired.mjs";
+import { governanceApproved } from "./governance/approved.mjs";
+import { governanceFailedExecution } from "./governance/failedExecution.mjs";
+import { governanceDecodeOfCallFailed } from "./governance/decodeOfCallFailed.mjs";
+import { governanceGovKeyCallExecuted } from "./governance/govKeyCallExecuted.mjs";
+import { governanceGovKeyCallHashWhitelisted } from "./governance/govKeyCallHashWhitelisted.mjs";
+import { governanceGovKeyCallExecutionFailed } from "./governance/govKeyCallExecutionFailed.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 { reputationOffencePenalty } from "./reputation/offencePenalty.mjs";
+import { reputationAccrualRateUpdated } from "./reputation/accrualRateUpdated.mjs";
+import { reputationMissedHeartbeatPenaltyUpdated } from "./reputation/missedHeartbeatPenaltyUpdated.mjs";
+import { reputationPenaltyUpdated } from "./reputation/penaltyUpdated.mjs";
+import { ethereumChainTrackingChainStateUpdated } from "./ethereumChainTracking/chainStateUpdated.mjs";
+import { polkadotChainTrackingChainStateUpdated } from "./polkadotChainTracking/chainStateUpdated.mjs";
+import { bitcoinChainTrackingChainStateUpdated } from "./bitcoinChainTracking/chainStateUpdated.mjs";
+import { ethereumVaultKeygenRequest } from "./ethereumVault/keygenRequest.mjs";
+import { ethereumVaultKeyHandoverRequest } from "./ethereumVault/keyHandoverRequest.mjs";
+import { ethereumVaultVaultRotationCompleted } from "./ethereumVault/vaultRotationCompleted.mjs";
+import { ethereumVaultVaultRotatedExternally } from "./ethereumVault/vaultRotatedExternally.mjs";
+import { ethereumVaultKeygenSuccessReported } from "./ethereumVault/keygenSuccessReported.mjs";
+import { ethereumVaultKeyHandoverSuccessReported } from "./ethereumVault/keyHandoverSuccessReported.mjs";
+import { ethereumVaultKeygenFailureReported } from "./ethereumVault/keygenFailureReported.mjs";
+import { ethereumVaultKeyHandoverFailureReported } from "./ethereumVault/keyHandoverFailureReported.mjs";
+import { ethereumVaultKeygenSuccess } from "./ethereumVault/keygenSuccess.mjs";
+import { ethereumVaultKeyHandoverSuccess } from "./ethereumVault/keyHandoverSuccess.mjs";
+import { ethereumVaultNoKeyHandover } from "./ethereumVault/noKeyHandover.mjs";
+import { ethereumVaultKeygenVerificationSuccess } from "./ethereumVault/keygenVerificationSuccess.mjs";
+import { ethereumVaultKeyHandoverVerificationSuccess } from "./ethereumVault/keyHandoverVerificationSuccess.mjs";
+import { ethereumVaultKeygenVerificationFailure } from "./ethereumVault/keygenVerificationFailure.mjs";
+import { ethereumVaultKeyHandoverVerificationFailure } from "./ethereumVault/keyHandoverVerificationFailure.mjs";
+import { ethereumVaultKeygenFailure } from "./ethereumVault/keygenFailure.mjs";
+import { ethereumVaultKeygenResponseTimeout } from "./ethereumVault/keygenResponseTimeout.mjs";
+import { ethereumVaultKeyHandoverResponseTimeout } from "./ethereumVault/keyHandoverResponseTimeout.mjs";
+import { ethereumVaultKeygenResponseTimeoutUpdated } from "./ethereumVault/keygenResponseTimeoutUpdated.mjs";
+import { ethereumVaultAwaitingGovernanceActivation } from "./ethereumVault/awaitingGovernanceActivation.mjs";
+import { ethereumVaultKeyHandoverFailure } from "./ethereumVault/keyHandoverFailure.mjs";
+import { ethereumVaultVaultRotationAborted } from "./ethereumVault/vaultRotationAborted.mjs";
+import { polkadotVaultKeygenRequest } from "./polkadotVault/keygenRequest.mjs";
+import { polkadotVaultKeyHandoverRequest } from "./polkadotVault/keyHandoverRequest.mjs";
+import { polkadotVaultVaultRotationCompleted } from "./polkadotVault/vaultRotationCompleted.mjs";
+import { polkadotVaultVaultRotatedExternally } from "./polkadotVault/vaultRotatedExternally.mjs";
+import { polkadotVaultKeygenSuccessReported } from "./polkadotVault/keygenSuccessReported.mjs";
+import { polkadotVaultKeyHandoverSuccessReported } from "./polkadotVault/keyHandoverSuccessReported.mjs";
+import { polkadotVaultKeygenFailureReported } from "./polkadotVault/keygenFailureReported.mjs";
+import { polkadotVaultKeyHandoverFailureReported } from "./polkadotVault/keyHandoverFailureReported.mjs";
+import { polkadotVaultKeygenSuccess } from "./polkadotVault/keygenSuccess.mjs";
+import { polkadotVaultKeyHandoverSuccess } from "./polkadotVault/keyHandoverSuccess.mjs";
+import { polkadotVaultNoKeyHandover } from "./polkadotVault/noKeyHandover.mjs";
+import { polkadotVaultKeygenVerificationSuccess } from "./polkadotVault/keygenVerificationSuccess.mjs";
+import { polkadotVaultKeyHandoverVerificationSuccess } from "./polkadotVault/keyHandoverVerificationSuccess.mjs";
+import { polkadotVaultKeygenVerificationFailure } from "./polkadotVault/keygenVerificationFailure.mjs";
+import { polkadotVaultKeyHandoverVerificationFailure } from "./polkadotVault/keyHandoverVerificationFailure.mjs";
+import { polkadotVaultKeygenFailure } from "./polkadotVault/keygenFailure.mjs";
+import { polkadotVaultKeygenResponseTimeout } from "./polkadotVault/keygenResponseTimeout.mjs";
+import { polkadotVaultKeyHandoverResponseTimeout } from "./polkadotVault/keyHandoverResponseTimeout.mjs";
+import { polkadotVaultKeygenResponseTimeoutUpdated } from "./polkadotVault/keygenResponseTimeoutUpdated.mjs";
+import { polkadotVaultAwaitingGovernanceActivation } from "./polkadotVault/awaitingGovernanceActivation.mjs";
+import { polkadotVaultKeyHandoverFailure } from "./polkadotVault/keyHandoverFailure.mjs";
+import { polkadotVaultVaultRotationAborted } from "./polkadotVault/vaultRotationAborted.mjs";
+import { bitcoinVaultKeygenRequest } from "./bitcoinVault/keygenRequest.mjs";
+import { bitcoinVaultKeyHandoverRequest } from "./bitcoinVault/keyHandoverRequest.mjs";
+import { bitcoinVaultVaultRotationCompleted } from "./bitcoinVault/vaultRotationCompleted.mjs";
+import { bitcoinVaultVaultRotatedExternally } from "./bitcoinVault/vaultRotatedExternally.mjs";
+import { bitcoinVaultKeygenSuccessReported } from "./bitcoinVault/keygenSuccessReported.mjs";
+import { bitcoinVaultKeyHandoverSuccessReported } from "./bitcoinVault/keyHandoverSuccessReported.mjs";
+import { bitcoinVaultKeygenFailureReported } from "./bitcoinVault/keygenFailureReported.mjs";
+import { bitcoinVaultKeyHandoverFailureReported } from "./bitcoinVault/keyHandoverFailureReported.mjs";
+import { bitcoinVaultKeygenSuccess } from "./bitcoinVault/keygenSuccess.mjs";
+import { bitcoinVaultKeyHandoverSuccess } from "./bitcoinVault/keyHandoverSuccess.mjs";
+import { bitcoinVaultNoKeyHandover } from "./bitcoinVault/noKeyHandover.mjs";
+import { bitcoinVaultKeygenVerificationSuccess } from "./bitcoinVault/keygenVerificationSuccess.mjs";
+import { bitcoinVaultKeyHandoverVerificationSuccess } from "./bitcoinVault/keyHandoverVerificationSuccess.mjs";
+import { bitcoinVaultKeygenVerificationFailure } from "./bitcoinVault/keygenVerificationFailure.mjs";
+import { bitcoinVaultKeyHandoverVerificationFailure } from "./bitcoinVault/keyHandoverVerificationFailure.mjs";
+import { bitcoinVaultKeygenFailure } from "./bitcoinVault/keygenFailure.mjs";
+import { bitcoinVaultKeygenResponseTimeout } from "./bitcoinVault/keygenResponseTimeout.mjs";
+import { bitcoinVaultKeyHandoverResponseTimeout } from "./bitcoinVault/keyHandoverResponseTimeout.mjs";
+import { bitcoinVaultKeygenResponseTimeoutUpdated } from "./bitcoinVault/keygenResponseTimeoutUpdated.mjs";
+import { bitcoinVaultAwaitingGovernanceActivation } from "./bitcoinVault/awaitingGovernanceActivation.mjs";
+import { bitcoinVaultKeyHandoverFailure } from "./bitcoinVault/keyHandoverFailure.mjs";
+import { bitcoinVaultVaultRotationAborted } from "./bitcoinVault/vaultRotationAborted.mjs";
+import { ethereumThresholdSignerThresholdSignatureRequest } from "./ethereumThresholdSigner/thresholdSignatureRequest.mjs";
+import { ethereumThresholdSignerThresholdSignatureFailed } from "./ethereumThresholdSigner/thresholdSignatureFailed.mjs";
+import { ethereumThresholdSignerThresholdSignatureSuccess } from "./ethereumThresholdSigner/thresholdSignatureSuccess.mjs";
+import { ethereumThresholdSignerThresholdDispatchComplete } from "./ethereumThresholdSigner/thresholdDispatchComplete.mjs";
+import { ethereumThresholdSignerRetryRequested } from "./ethereumThresholdSigner/retryRequested.mjs";
+import { ethereumThresholdSignerFailureReportProcessed } from "./ethereumThresholdSigner/failureReportProcessed.mjs";
+import { ethereumThresholdSignerSignersUnavailable } from "./ethereumThresholdSigner/signersUnavailable.mjs";
+import { ethereumThresholdSignerCurrentKeyUnavailable } from "./ethereumThresholdSigner/currentKeyUnavailable.mjs";
+import { ethereumThresholdSignerThresholdSignatureResponseTimeoutUpdated } from "./ethereumThresholdSigner/thresholdSignatureResponseTimeoutUpdated.mjs";
+import { polkadotThresholdSignerThresholdSignatureRequest } from "./polkadotThresholdSigner/thresholdSignatureRequest.mjs";
+import { polkadotThresholdSignerThresholdSignatureFailed } from "./polkadotThresholdSigner/thresholdSignatureFailed.mjs";
+import { polkadotThresholdSignerThresholdSignatureSuccess } from "./polkadotThresholdSigner/thresholdSignatureSuccess.mjs";
+import { polkadotThresholdSignerThresholdDispatchComplete } from "./polkadotThresholdSigner/thresholdDispatchComplete.mjs";
+import { polkadotThresholdSignerRetryRequested } from "./polkadotThresholdSigner/retryRequested.mjs";
+import { polkadotThresholdSignerFailureReportProcessed } from "./polkadotThresholdSigner/failureReportProcessed.mjs";
+import { polkadotThresholdSignerSignersUnavailable } from "./polkadotThresholdSigner/signersUnavailable.mjs";
+import { polkadotThresholdSignerCurrentKeyUnavailable } from "./polkadotThresholdSigner/currentKeyUnavailable.mjs";
+import { polkadotThresholdSignerThresholdSignatureResponseTimeoutUpdated } from "./polkadotThresholdSigner/thresholdSignatureResponseTimeoutUpdated.mjs";
+import { bitcoinThresholdSignerThresholdSignatureRequest } from "./bitcoinThresholdSigner/thresholdSignatureRequest.mjs";
+import { bitcoinThresholdSignerThresholdSignatureFailed } from "./bitcoinThresholdSigner/thresholdSignatureFailed.mjs";
+import { bitcoinThresholdSignerThresholdSignatureSuccess } from "./bitcoinThresholdSigner/thresholdSignatureSuccess.mjs";
+import { bitcoinThresholdSignerThresholdDispatchComplete } from "./bitcoinThresholdSigner/thresholdDispatchComplete.mjs";
+import { bitcoinThresholdSignerRetryRequested } from "./bitcoinThresholdSigner/retryRequested.mjs";
+import { bitcoinThresholdSignerFailureReportProcessed } from "./bitcoinThresholdSigner/failureReportProcessed.mjs";
+import { bitcoinThresholdSignerSignersUnavailable } from "./bitcoinThresholdSigner/signersUnavailable.mjs";
+import { bitcoinThresholdSignerCurrentKeyUnavailable } from "./bitcoinThresholdSigner/currentKeyUnavailable.mjs";
+import { bitcoinThresholdSignerThresholdSignatureResponseTimeoutUpdated } from "./bitcoinThresholdSigner/thresholdSignatureResponseTimeoutUpdated.mjs";
+import { ethereumBroadcasterTransactionBroadcastRequest } from "./ethereumBroadcaster/transactionBroadcastRequest.mjs";
+import { ethereumBroadcasterBroadcastRetryScheduled } from "./ethereumBroadcaster/broadcastRetryScheduled.mjs";
+import { ethereumBroadcasterBroadcastAttemptTimeout } from "./ethereumBroadcaster/broadcastAttemptTimeout.mjs";
+import { ethereumBroadcasterBroadcastAborted } from "./ethereumBroadcaster/broadcastAborted.mjs";
+import { ethereumBroadcasterBroadcastSuccess } from "./ethereumBroadcaster/broadcastSuccess.mjs";
+import { ethereumBroadcasterThresholdSignatureInvalid } from "./ethereumBroadcaster/thresholdSignatureInvalid.mjs";
+import { ethereumBroadcasterBroadcastCallbackExecuted } from "./ethereumBroadcaster/broadcastCallbackExecuted.mjs";
+import { ethereumBroadcasterTransactionFeeDeficitRecorded } from "./ethereumBroadcaster/transactionFeeDeficitRecorded.mjs";
+import { ethereumBroadcasterTransactionFeeDeficitRefused } from "./ethereumBroadcaster/transactionFeeDeficitRefused.mjs";
+import { polkadotBroadcasterTransactionBroadcastRequest } from "./polkadotBroadcaster/transactionBroadcastRequest.mjs";
+import { polkadotBroadcasterBroadcastRetryScheduled } from "./polkadotBroadcaster/broadcastRetryScheduled.mjs";
+import { polkadotBroadcasterBroadcastAttemptTimeout } from "./polkadotBroadcaster/broadcastAttemptTimeout.mjs";
+import { polkadotBroadcasterBroadcastAborted } from "./polkadotBroadcaster/broadcastAborted.mjs";
+import { polkadotBroadcasterBroadcastSuccess } from "./polkadotBroadcaster/broadcastSuccess.mjs";
+import { polkadotBroadcasterThresholdSignatureInvalid } from "./polkadotBroadcaster/thresholdSignatureInvalid.mjs";
+import { polkadotBroadcasterBroadcastCallbackExecuted } from "./polkadotBroadcaster/broadcastCallbackExecuted.mjs";
+import { polkadotBroadcasterTransactionFeeDeficitRecorded } from "./polkadotBroadcaster/transactionFeeDeficitRecorded.mjs";
+import { polkadotBroadcasterTransactionFeeDeficitRefused } from "./polkadotBroadcaster/transactionFeeDeficitRefused.mjs";
+import { bitcoinBroadcasterTransactionBroadcastRequest } from "./bitcoinBroadcaster/transactionBroadcastRequest.mjs";
+import { bitcoinBroadcasterBroadcastRetryScheduled } from "./bitcoinBroadcaster/broadcastRetryScheduled.mjs";
+import { bitcoinBroadcasterBroadcastAttemptTimeout } from "./bitcoinBroadcaster/broadcastAttemptTimeout.mjs";
+import { bitcoinBroadcasterBroadcastAborted } from "./bitcoinBroadcaster/broadcastAborted.mjs";
+import { bitcoinBroadcasterBroadcastSuccess } from "./bitcoinBroadcaster/broadcastSuccess.mjs";
+import { bitcoinBroadcasterThresholdSignatureInvalid } from "./bitcoinBroadcaster/thresholdSignatureInvalid.mjs";
+import { bitcoinBroadcasterBroadcastCallbackExecuted } from "./bitcoinBroadcaster/broadcastCallbackExecuted.mjs";
+import { bitcoinBroadcasterTransactionFeeDeficitRecorded } from "./bitcoinBroadcaster/transactionFeeDeficitRecorded.mjs";
+import { bitcoinBroadcasterTransactionFeeDeficitRefused } from "./bitcoinBroadcaster/transactionFeeDeficitRefused.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 { swappingMinimumSwapAmountSet } from "./swapping/minimumSwapAmountSet.mjs";
+import { swappingSwapAmountTooLow } from "./swapping/swapAmountTooLow.mjs";
+import { swappingCcmFailed } from "./swapping/ccmFailed.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 { ethereumIngressEgressDepositReceived } from "./ethereumIngressEgress/depositReceived.mjs";
+import { ethereumIngressEgressAssetEgressStatusChanged } from "./ethereumIngressEgress/assetEgressStatusChanged.mjs";
+import { ethereumIngressEgressEgressScheduled } from "./ethereumIngressEgress/egressScheduled.mjs";
+import { ethereumIngressEgressCcmBroadcastRequested } from "./ethereumIngressEgress/ccmBroadcastRequested.mjs";
+import { ethereumIngressEgressCcmEgressInvalid } from "./ethereumIngressEgress/ccmEgressInvalid.mjs";
+import { ethereumIngressEgressDepositFetchesScheduled } from "./ethereumIngressEgress/depositFetchesScheduled.mjs";
+import { ethereumIngressEgressBatchBroadcastRequested } from "./ethereumIngressEgress/batchBroadcastRequested.mjs";
+import { ethereumIngressEgressMinimumDepositSet } from "./ethereumIngressEgress/minimumDepositSet.mjs";
+import { ethereumIngressEgressDepositIgnored } from "./ethereumIngressEgress/depositIgnored.mjs";
+import { ethereumIngressEgressVaultTransferFailed } from "./ethereumIngressEgress/vaultTransferFailed.mjs";
+import { ethereumIngressEgressDepositWitnessRejected } from "./ethereumIngressEgress/depositWitnessRejected.mjs";
+import { polkadotIngressEgressDepositReceived } from "./polkadotIngressEgress/depositReceived.mjs";
+import { polkadotIngressEgressAssetEgressStatusChanged } from "./polkadotIngressEgress/assetEgressStatusChanged.mjs";
+import { polkadotIngressEgressEgressScheduled } from "./polkadotIngressEgress/egressScheduled.mjs";
+import { polkadotIngressEgressCcmBroadcastRequested } from "./polkadotIngressEgress/ccmBroadcastRequested.mjs";
+import { polkadotIngressEgressCcmEgressInvalid } from "./polkadotIngressEgress/ccmEgressInvalid.mjs";
+import { polkadotIngressEgressDepositFetchesScheduled } from "./polkadotIngressEgress/depositFetchesScheduled.mjs";
+import { polkadotIngressEgressBatchBroadcastRequested } from "./polkadotIngressEgress/batchBroadcastRequested.mjs";
+import { polkadotIngressEgressMinimumDepositSet } from "./polkadotIngressEgress/minimumDepositSet.mjs";
+import { polkadotIngressEgressDepositIgnored } from "./polkadotIngressEgress/depositIgnored.mjs";
+import { polkadotIngressEgressVaultTransferFailed } from "./polkadotIngressEgress/vaultTransferFailed.mjs";
+import { polkadotIngressEgressDepositWitnessRejected } from "./polkadotIngressEgress/depositWitnessRejected.mjs";
+import { bitcoinIngressEgressDepositReceived } from "./bitcoinIngressEgress/depositReceived.mjs";
+import { bitcoinIngressEgressAssetEgressStatusChanged } from "./bitcoinIngressEgress/assetEgressStatusChanged.mjs";
+import { bitcoinIngressEgressEgressScheduled } from "./bitcoinIngressEgress/egressScheduled.mjs";
+import { bitcoinIngressEgressCcmBroadcastRequested } from "./bitcoinIngressEgress/ccmBroadcastRequested.mjs";
+import { bitcoinIngressEgressCcmEgressInvalid } from "./bitcoinIngressEgress/ccmEgressInvalid.mjs";
+import { bitcoinIngressEgressDepositFetchesScheduled } from "./bitcoinIngressEgress/depositFetchesScheduled.mjs";
+import { bitcoinIngressEgressBatchBroadcastRequested } from "./bitcoinIngressEgress/batchBroadcastRequested.mjs";
+import { bitcoinIngressEgressMinimumDepositSet } from "./bitcoinIngressEgress/minimumDepositSet.mjs";
+import { bitcoinIngressEgressDepositIgnored } from "./bitcoinIngressEgress/depositIgnored.mjs";
+import { bitcoinIngressEgressVaultTransferFailed } from "./bitcoinIngressEgress/vaultTransferFailed.mjs";
+import { bitcoinIngressEgressDepositWitnessRejected } from "./bitcoinIngressEgress/depositWitnessRejected.mjs";
+import { liquidityPoolsUpdatedBuyInterval } from "./liquidityPools/updatedBuyInterval.mjs";
+import { liquidityPoolsPoolStateUpdated } from "./liquidityPools/poolStateUpdated.mjs";
+import { liquidityPoolsNewPoolCreated } from "./liquidityPools/newPoolCreated.mjs";
+import { liquidityPoolsRangeOrderUpdated } from "./liquidityPools/rangeOrderUpdated.mjs";
+import { liquidityPoolsLimitOrderUpdated } from "./liquidityPools/limitOrderUpdated.mjs";
+import { liquidityPoolsNetworkFeeTaken } from "./liquidityPools/networkFeeTaken.mjs";
+import { liquidityPoolsAssetSwapped } from "./liquidityPools/assetSwapped.mjs";
+import { liquidityPoolsPoolFeeSet } from "./liquidityPools/poolFeeSet.mjs";
+var handleEvents = (map) => ({
+  spec: 100,
+  handlers: [
+    {
+      name: "System.ExtrinsicSuccess",
+      handler: wrapHandler(map.System?.ExtrinsicSuccess, systemExtrinsicSuccess)
+    },
+    {
+      name: "System.ExtrinsicFailed",
+      handler: wrapHandler(map.System?.ExtrinsicFailed, systemExtrinsicFailed)
+    },
+    {
+      name: "System.CodeUpdated",
+      handler: wrapHandler(map.System?.CodeUpdated, systemCodeUpdated)
+    },
+    {
+      name: "System.NewAccount",
+      handler: wrapHandler(map.System?.NewAccount, systemNewAccount)
+    },
+    {
+      name: "System.KilledAccount",
+      handler: wrapHandler(map.System?.KilledAccount, systemKilledAccount)
+    },
+    {
+      name: "System.Remarked",
+      handler: wrapHandler(map.System?.Remarked, systemRemarked)
+    },
+    {
+      name: "Environment.AddedNewEthAsset",
+      handler: wrapHandler(map.Environment?.AddedNewEthAsset, environmentAddedNewEthAsset)
+    },
+    {
+      name: "Environment.UpdatedEthAsset",
+      handler: wrapHandler(map.Environment?.UpdatedEthAsset, environmentUpdatedEthAsset)
+    },
+    {
+      name: "Environment.PolkadotVaultAccountSet",
+      handler: wrapHandler(
+        map.Environment?.PolkadotVaultAccountSet,
+        environmentPolkadotVaultAccountSet
+      )
+    },
+    {
+      name: "Environment.BitcoinBlockNumberSetForVault",
+      handler: wrapHandler(
+        map.Environment?.BitcoinBlockNumberSetForVault,
+        environmentBitcoinBlockNumberSetForVault
+      )
+    },
+    {
+      name: "Environment.RuntimeSafeModeUpdated",
+      handler: wrapHandler(
+        map.Environment?.RuntimeSafeModeUpdated,
+        environmentRuntimeSafeModeUpdated
+      )
+    },
+    {
+      name: "Flip.RemainingImbalance",
+      handler: wrapHandler(map.Flip?.RemainingImbalance, flipRemainingImbalance)
+    },
+    {
+      name: "Flip.SlashingPerformed",
+      handler: wrapHandler(map.Flip?.SlashingPerformed, flipSlashingPerformed)
+    },
+    {
+      name: "Flip.AccountReaped",
+      handler: wrapHandler(map.Flip?.AccountReaped, flipAccountReaped)
+    },
+    {
+      name: "Flip.SlashingRateUpdated",
+      handler: wrapHandler(map.Flip?.SlashingRateUpdated, flipSlashingRateUpdated)
+    },
+    {
+      name: "Emissions.SupplyUpdateBroadcastRequested",
+      handler: wrapHandler(
+        map.Emissions?.SupplyUpdateBroadcastRequested,
+        emissionsSupplyUpdateBroadcastRequested
+      )
+    },
+    {
+      name: "Emissions.CurrentAuthorityInflationEmissionsUpdated",
+      handler: wrapHandler(
+        map.Emissions?.CurrentAuthorityInflationEmissionsUpdated,
+        emissionsCurrentAuthorityInflationEmissionsUpdated
+      )
+    },
+    {
+      name: "Emissions.BackupNodeInflationEmissionsUpdated",
+      handler: wrapHandler(
+        map.Emissions?.BackupNodeInflationEmissionsUpdated,
+        emissionsBackupNodeInflationEmissionsUpdated
+      )
+    },
+    {
+      name: "Emissions.SupplyUpdateIntervalUpdated",
+      handler: wrapHandler(
+        map.Emissions?.SupplyUpdateIntervalUpdated,
+        emissionsSupplyUpdateIntervalUpdated
+      )
+    },
+    {
+      name: "Funding.Funded",
+      handler: wrapHandler(map.Funding?.Funded, fundingFunded)
+    },
+    {
+      name: "Funding.RedemptionRequested",
+      handler: wrapHandler(map.Funding?.RedemptionRequested, fundingRedemptionRequested)
+    },
+    {
+      name: "Funding.RedemptionSettled",
+      handler: wrapHandler(map.Funding?.RedemptionSettled, fundingRedemptionSettled)
+    },
+    {
+      name: "Funding.StoppedBidding",
+      handler: wrapHandler(map.Funding?.StoppedBidding, fundingStoppedBidding)
+    },
+    {
+      name: "Funding.StartedBidding",
+      handler: wrapHandler(map.Funding?.StartedBidding, fundingStartedBidding)
+    },
+    {
+      name: "Funding.RedemptionExpired",
+      handler: wrapHandler(map.Funding?.RedemptionExpired, fundingRedemptionExpired)
+    },
+    {
+      name: "Funding.AddedRestrictedAddress",
+      handler: wrapHandler(map.Funding?.AddedRestrictedAddress, fundingAddedRestrictedAddress)
+    },
+    {
+      name: "Funding.RemovedRestrictedAddress",
+      handler: wrapHandler(map.Funding?.RemovedRestrictedAddress, fundingRemovedRestrictedAddress)
+    },
+    {
+      name: "Funding.FailedFundingAttempt",
+      handler: wrapHandler(map.Funding?.FailedFundingAttempt, fundingFailedFundingAttempt)
+    },
+    {
+      name: "Funding.MinimumFundingUpdated",
+      handler: wrapHandler(map.Funding?.MinimumFundingUpdated, fundingMinimumFundingUpdated)
+    },
+    {
+      name: "Funding.RedemptionTaxAmountUpdated",
+      handler: wrapHandler(
+        map.Funding?.RedemptionTaxAmountUpdated,
+        fundingRedemptionTaxAmountUpdated
+      )
+    },
+    {
+      name: "Funding.RedemptionAmountZero",
+      handler: wrapHandler(map.Funding?.RedemptionAmountZero, fundingRedemptionAmountZero)
+    },
+    {
+      name: "Funding.BoundRedeemAddress",
+      handler: wrapHandler(map.Funding?.BoundRedeemAddress, fundingBoundRedeemAddress)
+    },
+    {
+      name: "Funding.BoundExecutorAddress",
+      handler: wrapHandler(map.Funding?.BoundExecutorAddress, fundingBoundExecutorAddress)
+    },
+    {
+      name: "AccountRoles.AccountRoleRegistered",
+      handler: wrapHandler(
+        map.AccountRoles?.AccountRoleRegistered,
+        accountRolesAccountRoleRegistered
+      )
+    },
+    {
+      name: "TransactionPayment.TransactionFeePaid",
+      handler: wrapHandler(
+        map.TransactionPayment?.TransactionFeePaid,
+        transactionPaymentTransactionFeePaid
+      )
+    },
+    {
+      name: "Witnesser.WitnessExecutionFailed",
+      handler: wrapHandler(map.Witnesser?.WitnessExecutionFailed, witnesserWitnessExecutionFailed)
+    },
+    {
+      name: "Witnesser.Prewitnessed",
+      handler: wrapHandler(map.Witnesser?.Prewitnessed, witnesserPrewitnessed)
+    },
+    {
+      name: "Validator.RotationAborted",
+      handler: wrapHandler(map.Validator?.RotationAborted, validatorRotationAborted)
+    },
+    {
+      name: "Validator.NewEpoch",
+      handler: wrapHandler(map.Validator?.NewEpoch, validatorNewEpoch)
+    },
+    {
+      name: "Validator.RotationPhaseUpdated",
+      handler: wrapHandler(map.Validator?.RotationPhaseUpdated, validatorRotationPhaseUpdated)
+    },
+    {
+      name: "Validator.CFEVersionUpdated",
+      handler: wrapHandler(map.Validator?.CFEVersionUpdated, validatorCFEVersionUpdated)
+    },
+    {
+      name: "Validator.PeerIdRegistered",
+      handler: wrapHandler(map.Validator?.PeerIdRegistered, validatorPeerIdRegistered)
+    },
+    {
+      name: "Validator.PeerIdUnregistered",
+      handler: wrapHandler(map.Validator?.PeerIdUnregistered, validatorPeerIdUnregistered)
+    },
+    {
+      name: "Validator.VanityNameSet",
+      handler: wrapHandler(map.Validator?.VanityNameSet, validatorVanityNameSet)
+    },
+    {
+      name: "Validator.AuctionCompleted",
+      handler: wrapHandler(map.Validator?.AuctionCompleted, validatorAuctionCompleted)
+    },
+    {
+      name: "Validator.PalletConfigUpdated",
+      handler: wrapHandler(map.Validator?.PalletConfigUpdated, validatorPalletConfigUpdated)
+    },
+    {
+      name: "Session.NewSession",
+      handler: wrapHandler(map.Session?.NewSession, sessionNewSession)
+    },
+    {
+      name: "Grandpa.NewAuthorities",
+      handler: wrapHandler(map.Grandpa?.NewAuthorities, grandpaNewAuthorities)
+    },
+    {
+      name: "Grandpa.Paused",
+      handler: wrapHandler(map.Grandpa?.Paused, grandpaPaused)
+    },
+    {
+      name: "Grandpa.Resumed",
+      handler: wrapHandler(map.Grandpa?.Resumed, grandpaResumed)
+    },
+    {
+      name: "Governance.Proposed",
+      handler: wrapHandler(map.Governance?.Proposed, governanceProposed)
+    },
+    {
+      name: "Governance.Executed",
+      handler: wrapHandler(map.Governance?.Executed, governanceExecuted)
+    },
+    {
+      name: "Governance.Expired",
+      handler: wrapHandler(map.Governance?.Expired, governanceExpired)
+    },
+    {
+      name: "Governance.Approved",
+      handler: wrapHandler(map.Governance?.Approved, governanceApproved)
+    },
+    {
+      name: "Governance.FailedExecution",
+      handler: wrapHandler(map.Governance?.FailedExecution, governanceFailedExecution)
+    },
+    {
+      name: "Governance.DecodeOfCallFailed",
+      handler: wrapHandler(map.Governance?.DecodeOfCallFailed, governanceDecodeOfCallFailed)
+    },
+    {
+      name: "Governance.GovKeyCallExecuted",
+      handler: wrapHandler(map.Governance?.GovKeyCallExecuted, governanceGovKeyCallExecuted)
+    },
+    {
+      name: "Governance.GovKeyCallHashWhitelisted",
+      handler: wrapHandler(
+        map.Governance?.GovKeyCallHashWhitelisted,
+        governanceGovKeyCallHashWhitelisted
+      )
+    },
+    {
+      name: "Governance.GovKeyCallExecutionFailed",
+      handler: wrapHandler(
+        map.Governance?.GovKeyCallExecutionFailed,
+        governanceGovKeyCallExecutionFailed
+      )
+    },
+    {
+      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: "Reputation.OffencePenalty",
+      handler: wrapHandler(map.Reputation?.OffencePenalty, reputationOffencePenalty)
+    },
+    {
+      name: "Reputation.AccrualRateUpdated",
+      handler: wrapHandler(map.Reputation?.AccrualRateUpdated, reputationAccrualRateUpdated)
+    },
+    {
+      name: "Reputation.MissedHeartbeatPenaltyUpdated",
+      handler: wrapHandler(
+        map.Reputation?.MissedHeartbeatPenaltyUpdated,
+        reputationMissedHeartbeatPenaltyUpdated
+      )
+    },
+    {
+      name: "Reputation.PenaltyUpdated",
+      handler: wrapHandler(map.Reputation?.PenaltyUpdated, reputationPenaltyUpdated)
+    },
+    {
+      name: "EthereumChainTracking.ChainStateUpdated",
+      handler: wrapHandler(
+        map.EthereumChainTracking?.ChainStateUpdated,
+        ethereumChainTrackingChainStateUpdated
+      )
+    },
+    {
+      name: "PolkadotChainTracking.ChainStateUpdated",
+      handler: wrapHandler(
+        map.PolkadotChainTracking?.ChainStateUpdated,
+        polkadotChainTrackingChainStateUpdated
+      )
+    },
+    {
+      name: "BitcoinChainTracking.ChainStateUpdated",
+      handler: wrapHandler(
+        map.BitcoinChainTracking?.ChainStateUpdated,
+        bitcoinChainTrackingChainStateUpdated
+      )
+    },
+    {
+      name: "EthereumVault.KeygenRequest",
+      handler: wrapHandler(map.EthereumVault?.KeygenRequest, ethereumVaultKeygenRequest)
+    },
+    {
+      name: "EthereumVault.KeyHandoverRequest",
+      handler: wrapHandler(map.EthereumVault?.KeyHandoverRequest, ethereumVaultKeyHandoverRequest)
+    },
+    {
+      name: "EthereumVault.VaultRotationCompleted",
+      handler: wrapHandler(
+        map.EthereumVault?.VaultRotationCompleted,
+        ethereumVaultVaultRotationCompleted
+      )
+    },
+    {
+      name: "EthereumVault.VaultRotatedExternally",
+      handler: wrapHandler(
+        map.EthereumVault?.VaultRotatedExternally,
+        ethereumVaultVaultRotatedExternally
+      )
+    },
+    {
+      name: "EthereumVault.KeygenSuccessReported",
+      handler: wrapHandler(
+        map.EthereumVault?.KeygenSuccessReported,
+        ethereumVaultKeygenSuccessReported
+      )
+    },
+    {
+      name: "EthereumVault.KeyHandoverSuccessReported",
+      handler: wrapHandler(
+        map.EthereumVault?.KeyHandoverSuccessReported,
+        ethereumVaultKeyHandoverSuccessReported
+      )
+    },
+    {
+      name: "EthereumVault.KeygenFailureReported",
+      handler: wrapHandler(
+        map.EthereumVault?.KeygenFailureReported,
+        ethereumVaultKeygenFailureReported
+      )
+    },
+    {
+      name: "EthereumVault.KeyHandoverFailureReported",
+      handler: wrapHandler(
+        map.EthereumVault?.KeyHandoverFailureReported,
+        ethereumVaultKeyHandoverFailureReported
+      )
+    },
+    {
+      name: "EthereumVault.KeygenSuccess",
+      handler: wrapHandler(map.EthereumVault?.KeygenSuccess, ethereumVaultKeygenSuccess)
+    },
+    {
+      name: "EthereumVault.KeyHandoverSuccess",
+      handler: wrapHandler(map.EthereumVault?.KeyHandoverSuccess, ethereumVaultKeyHandoverSuccess)
+    },
+    {
+      name: "EthereumVault.NoKeyHandover",
+      handler: wrapHandler(map.EthereumVault?.NoKeyHandover, ethereumVaultNoKeyHandover)
+    },
+    {
+      name: "EthereumVault.KeygenVerificationSuccess",
+      handler: wrapHandler(
+        map.EthereumVault?.KeygenVerificationSuccess,
+        ethereumVaultKeygenVerificationSuccess
+      )
+    },
+    {
+      name: "EthereumVault.KeyHandoverVerificationSuccess",
+      handler: wrapHandler(
+        map.EthereumVault?.KeyHandoverVerificationSuccess,
+        ethereumVaultKeyHandoverVerificationSuccess
+      )
+    },
+    {
+      name: "EthereumVault.KeygenVerificationFailure",
+      handler: wrapHandler(
+        map.EthereumVault?.KeygenVerificationFailure,
+        ethereumVaultKeygenVerificationFailure
+      )
+    },
+    {
+      name: "EthereumVault.KeyHandoverVerificationFailure",
+      handler: wrapHandler(
+        map.EthereumVault?.KeyHandoverVerificationFailure,
+        ethereumVaultKeyHandoverVerificationFailure
+      )
+    },
+    {
+      name: "EthereumVault.KeygenFailure",
+      handler: wrapHandler(map.EthereumVault?.KeygenFailure, ethereumVaultKeygenFailure)
+    },
+    {
+      name: "EthereumVault.KeygenResponseTimeout",
+      handler: wrapHandler(
+        map.EthereumVault?.KeygenResponseTimeout,
+        ethereumVaultKeygenResponseTimeout
+      )
+    },
+    {
+      name: "EthereumVault.KeyHandoverResponseTimeout",
+      handler: wrapHandler(
+        map.EthereumVault?.KeyHandoverResponseTimeout,
+        ethereumVaultKeyHandoverResponseTimeout
+      )
+    },
+    {
+      name: "EthereumVault.KeygenResponseTimeoutUpdated",
+      handler: wrapHandler(
+        map.EthereumVault?.KeygenResponseTimeoutUpdated,
+        ethereumVaultKeygenResponseTimeoutUpdated
+      )
+    },
+    {
+      name: "EthereumVault.AwaitingGovernanceActivation",
+      handler: wrapHandler(
+        map.EthereumVault?.AwaitingGovernanceActivation,
+        ethereumVaultAwaitingGovernanceActivation
+      )
+    },
+    {
+      name: "EthereumVault.KeyHandoverFailure",
+      handler: wrapHandler(map.EthereumVault?.KeyHandoverFailure, ethereumVaultKeyHandoverFailure)
+    },
+    {
+      name: "EthereumVault.VaultRotationAborted",
+      handler: wrapHandler(
+        map.EthereumVault?.VaultRotationAborted,
+        ethereumVaultVaultRotationAborted
+      )
+    },
+    {
+      name: "PolkadotVault.KeygenRequest",
+      handler: wrapHandler(map.PolkadotVault?.KeygenRequest, polkadotVaultKeygenRequest)
+    },
+    {
+      name: "PolkadotVault.KeyHandoverRequest",
+      handler: wrapHandler(map.PolkadotVault?.KeyHandoverRequest, polkadotVaultKeyHandoverRequest)
+    },
+    {
+      name: "PolkadotVault.VaultRotationCompleted",
+      handler: wrapHandler(
+        map.PolkadotVault?.VaultRotationCompleted,
+        polkadotVaultVaultRotationCompleted
+      )
+    },
+    {
+      name: "PolkadotVault.VaultRotatedExternally",
+      handler: wrapHandler(
+        map.PolkadotVault?.VaultRotatedExternally,
+        polkadotVaultVaultRotatedExternally
+      )
+    },
+    {
+      name: "PolkadotVault.KeygenSuccessReported",
+      handler: wrapHandler(
+        map.PolkadotVault?.KeygenSuccessReported,
+        polkadotVaultKeygenSuccessReported
+      )
+    },
+    {
+      name: "PolkadotVault.KeyHandoverSuccessReported",
+      handler: wrapHandler(
+        map.PolkadotVault?.KeyHandoverSuccessReported,
+        polkadotVaultKeyHandoverSuccessReported
+      )
+    },
+    {
+      name: "PolkadotVault.KeygenFailureReported",
+      handler: wrapHandler(
+        map.PolkadotVault?.KeygenFailureReported,
+        polkadotVaultKeygenFailureReported
+      )
+    },
+    {
+      name: "PolkadotVault.KeyHandoverFailureReported",
+      handler: wrapHandler(
+        map.PolkadotVault?.KeyHandoverFailureReported,
+        polkadotVaultKeyHandoverFailureReported
+      )
+    },
+    {
+      name: "PolkadotVault.KeygenSuccess",
+      handler: wrapHandler(map.PolkadotVault?.KeygenSuccess, polkadotVaultKeygenSuccess)
+    },
+    {
+      name: "PolkadotVault.KeyHandoverSuccess",
+      handler: wrapHandler(map.PolkadotVault?.KeyHandoverSuccess, polkadotVaultKeyHandoverSuccess)
+    },
+    {
+      name: "PolkadotVault.NoKeyHandover",
+      handler: wrapHandler(map.PolkadotVault?.NoKeyHandover, polkadotVaultNoKeyHandover)
+    },
+    {
+      name: "PolkadotVault.KeygenVerificationSuccess",
+      handler: wrapHandler(
+        map.PolkadotVault?.KeygenVerificationSuccess,
+        polkadotVaultKeygenVerificationSuccess
+      )
+    },
+    {
+      name: "PolkadotVault.KeyHandoverVerificationSuccess",
+      handler: wrapHandler(
+        map.PolkadotVault?.KeyHandoverVerificationSuccess,
+        polkadotVaultKeyHandoverVerificationSuccess
+      )
+    },
+    {
+      name: "PolkadotVault.KeygenVerificationFailure",
+      handler: wrapHandler(
+        map.PolkadotVault?.KeygenVerificationFailure,
+        polkadotVaultKeygenVerificationFailure
+      )
+    },
+    {
+      name: "PolkadotVault.KeyHandoverVerificationFailure",
+      handler: wrapHandler(
+        map.PolkadotVault?.KeyHandoverVerificationFailure,
+        polkadotVaultKeyHandoverVerificationFailure
+      )
+    },
+    {
+      name: "PolkadotVault.KeygenFailure",
+      handler: wrapHandler(map.PolkadotVault?.KeygenFailure, polkadotVaultKeygenFailure)
+    },
+    {
+      name: "PolkadotVault.KeygenResponseTimeout",
+      handler: wrapHandler(
+        map.PolkadotVault?.KeygenResponseTimeout,
+        polkadotVaultKeygenResponseTimeout
+      )
+    },
+    {
+      name: "PolkadotVault.KeyHandoverResponseTimeout",
+      handler: wrapHandler(
+        map.PolkadotVault?.KeyHandoverResponseTimeout,
+        polkadotVaultKeyHandoverResponseTimeout
+      )
+    },
+    {
+      name: "PolkadotVault.KeygenResponseTimeoutUpdated",
+      handler: wrapHandler(
+        map.PolkadotVault?.KeygenResponseTimeoutUpdated,
+        polkadotVaultKeygenResponseTimeoutUpdated
+      )
+    },
+    {
+      name: "PolkadotVault.AwaitingGovernanceActivation",
+      handler: wrapHandler(
+        map.PolkadotVault?.AwaitingGovernanceActivation,
+        polkadotVaultAwaitingGovernanceActivation
+      )
+    },
+    {
+      name: "PolkadotVault.KeyHandoverFailure",
+      handler: wrapHandler(map.PolkadotVault?.KeyHandoverFailure, polkadotVaultKeyHandoverFailure)
+    },
+    {
+      name: "PolkadotVault.VaultRotationAborted",
+      handler: wrapHandler(
+        map.PolkadotVault?.VaultRotationAborted,
+        polkadotVaultVaultRotationAborted
+      )
+    },
+    {
+      name: "BitcoinVault.KeygenRequest",
+      handler: wrapHandler(map.BitcoinVault?.KeygenRequest, bitcoinVaultKeygenRequest)
+    },
+    {
+      name: "BitcoinVault.KeyHandoverRequest",
+      handler: wrapHandler(map.BitcoinVault?.KeyHandoverRequest, bitcoinVaultKeyHandoverRequest)
+    },
+    {
+      name: "BitcoinVault.VaultRotationCompleted",
+      handler: wrapHandler(
+        map.BitcoinVault?.VaultRotationCompleted,
+        bitcoinVaultVaultRotationCompleted
+      )
+    },
+    {
+      name: "BitcoinVault.VaultRotatedExternally",
+      handler: wrapHandler(
+        map.BitcoinVault?.VaultRotatedExternally,
+        bitcoinVaultVaultRotatedExternally
+      )
+    },
+    {
+      name: "BitcoinVault.KeygenSuccessReported",
+      handler: wrapHandler(
+        map.BitcoinVault?.KeygenSuccessReported,
+        bitcoinVaultKeygenSuccessReported
+      )
+    },
+    {
+      name: "BitcoinVault.KeyHandoverSuccessReported",
+      handler: wrapHandler(
+        map.BitcoinVault?.KeyHandoverSuccessReported,
+        bitcoinVaultKeyHandoverSuccessReported
+      )
+    },
+    {
+      name: "BitcoinVault.KeygenFailureReported",
+      handler: wrapHandler(
+        map.BitcoinVault?.KeygenFailureReported,
+        bitcoinVaultKeygenFailureReported
+      )
+    },
+    {
+      name: "BitcoinVault.KeyHandoverFailureReported",
+      handler: wrapHandler(
+        map.BitcoinVault?.KeyHandoverFailureReported,
+        bitcoinVaultKeyHandoverFailureReported
+      )
+    },
+    {
+      name: "BitcoinVault.KeygenSuccess",
+      handler: wrapHandler(map.BitcoinVault?.KeygenSuccess, bitcoinVaultKeygenSuccess)
+    },
+    {
+      name: "BitcoinVault.KeyHandoverSuccess",
+      handler: wrapHandler(map.BitcoinVault?.KeyHandoverSuccess, bitcoinVaultKeyHandoverSuccess)
+    },
+    {
+      name: "BitcoinVault.NoKeyHandover",
+      handler: wrapHandler(map.BitcoinVault?.NoKeyHandover, bitcoinVaultNoKeyHandover)
+    },
+    {
+      name: "BitcoinVault.KeygenVerificationSuccess",
+      handler: wrapHandler(
+        map.BitcoinVault?.KeygenVerificationSuccess,
+        bitcoinVaultKeygenVerificationSuccess
+      )
+    },
+    {
+      name: "BitcoinVault.KeyHandoverVerificationSuccess",
+      handler: wrapHandler(
+        map.BitcoinVault?.KeyHandoverVerificationSuccess,
+        bitcoinVaultKeyHandoverVerificationSuccess
+      )
+    },
+    {
+      name: "BitcoinVault.KeygenVerificationFailure",
+      handler: wrapHandler(
+        map.BitcoinVault?.KeygenVerificationFailure,
+        bitcoinVaultKeygenVerificationFailure
+      )
+    },
+    {
+      name: "BitcoinVault.KeyHandoverVerificationFailure",
+      handler: wrapHandler(
+        map.BitcoinVault?.KeyHandoverVerificationFailure,
+        bitcoinVaultKeyHandoverVerificationFailure
+      )
+    },
+    {
+      name: "BitcoinVault.KeygenFailure",
+      handler: wrapHandler(map.BitcoinVault?.KeygenFailure, bitcoinVaultKeygenFailure)
+    },
+    {
+      name: "BitcoinVault.KeygenResponseTimeout",
+      handler: wrapHandler(
+        map.BitcoinVault?.KeygenResponseTimeout,
+        bitcoinVaultKeygenResponseTimeout
+      )
+    },
+    {
+      name: "BitcoinVault.KeyHandoverResponseTimeout",
+      handler: wrapHandler(
+        map.BitcoinVault?.KeyHandoverResponseTimeout,
+        bitcoinVaultKeyHandoverResponseTimeout
+      )
+    },
+    {
+      name: "BitcoinVault.KeygenResponseTimeoutUpdated",
+      handler: wrapHandler(
+        map.BitcoinVault?.KeygenResponseTimeoutUpdated,
+        bitcoinVaultKeygenResponseTimeoutUpdated
+      )
+    },
+    {
+      name: "BitcoinVault.AwaitingGovernanceActivation",
+      handler: wrapHandler(
+        map.BitcoinVault?.AwaitingGovernanceActivation,
+        bitcoinVaultAwaitingGovernanceActivation
+      )
+    },
+    {
+      name: "BitcoinVault.KeyHandoverFailure",
+      handler: wrapHandler(map.BitcoinVault?.KeyHandoverFailure, bitcoinVaultKeyHandoverFailure)
+    },
+    {
+      name: "BitcoinVault.VaultRotationAborted",
+      handler: wrapHandler(
+        map.BitcoinVault?.VaultRotationAborted,
+        bitcoinVaultVaultRotationAborted
+      )
+    },
+    {
+      name: "EthereumThresholdSigner.ThresholdSignatureRequest",
+      handler: wrapHandler(
+        map.EthereumThresholdSigner?.ThresholdSignatureRequest,
+        ethereumThresholdSignerThresholdSignatureRequest
+      )
+    },
+    {
+      name: "EthereumThresholdSigner.ThresholdSignatureFailed",
+      handler: wrapHandler(
+        map.EthereumThresholdSigner?.ThresholdSignatureFailed,
+        ethereumThresholdSignerThresholdSignatureFailed
+      )
+    },
+    {
+      name: "EthereumThresholdSigner.ThresholdSignatureSuccess",
+      handler: wrapHandler(
+        map.EthereumThresholdSigner?.ThresholdSignatureSuccess,
+        ethereumThresholdSignerThresholdSignatureSuccess
+      )
+    },
+    {
+      name: "EthereumThresholdSigner.ThresholdDispatchComplete",
+      handler: wrapHandler(
+        map.EthereumThresholdSigner?.ThresholdDispatchComplete,
+        ethereumThresholdSignerThresholdDispatchComplete
+      )
+    },
+    {
+      name: "EthereumThresholdSigner.RetryRequested",
+      handler: wrapHandler(
+        map.EthereumThresholdSigner?.RetryRequested,
+        ethereumThresholdSignerRetryRequested
+      )
+    },
+    {
+      name: "EthereumThresholdSigner.FailureReportProcessed",
+      handler: wrapHandler(
+        map.EthereumThresholdSigner?.FailureReportProcessed,
+        ethereumThresholdSignerFailureReportProcessed
+      )
+    },
+    {
+      name: "EthereumThresholdSigner.SignersUnavailable",
+      handler: wrapHandler(
+        map.EthereumThresholdSigner?.SignersUnavailable,
+        ethereumThresholdSignerSignersUnavailable
+      )
+    },
+    {
+      name: "EthereumThresholdSigner.CurrentKeyUnavailable",
+      handler: wrapHandler(
+        map.EthereumThresholdSigner?.CurrentKeyUnavailable,
+        ethereumThresholdSignerCurrentKeyUnavailable
+      )
+    },
+    {
+      name: "EthereumThresholdSigner.ThresholdSignatureResponseTimeoutUpdated",
+      handler: wrapHandler(
+        map.EthereumThresholdSigner?.ThresholdSignatureResponseTimeoutUpdated,
+        ethereumThresholdSignerThresholdSignatureResponseTimeoutUpdated
+      )
+    },
+    {
+      name: "PolkadotThresholdSigner.ThresholdSignatureRequest",
+      handler: wrapHandler(
+        map.PolkadotThresholdSigner?.ThresholdSignatureRequest,
+        polkadotThresholdSignerThresholdSignatureRequest
+      )
+    },
+    {
+      name: "PolkadotThresholdSigner.ThresholdSignatureFailed",
+      handler: wrapHandler(
+        map.PolkadotThresholdSigner?.ThresholdSignatureFailed,
+        polkadotThresholdSignerThresholdSignatureFailed
+      )
+    },
+    {
+      name: "PolkadotThresholdSigner.ThresholdSignatureSuccess",
+      handler: wrapHandler(
+        map.PolkadotThresholdSigner?.ThresholdSignatureSuccess,
+        polkadotThresholdSignerThresholdSignatureSuccess
+      )
+    },
+    {
+      name: "PolkadotThresholdSigner.ThresholdDispatchComplete",
+      handler: wrapHandler(
+        map.PolkadotThresholdSigner?.ThresholdDispatchComplete,
+        polkadotThresholdSignerThresholdDispatchComplete
+      )
+    },
+    {
+      name: "PolkadotThresholdSigner.RetryRequested",
+      handler: wrapHandler(
+        map.PolkadotThresholdSigner?.RetryRequested,
+        polkadotThresholdSignerRetryRequested
+      )
+    },
+    {
+      name: "PolkadotThresholdSigner.FailureReportProcessed",
+      handler: wrapHandler(
+        map.PolkadotThresholdSigner?.FailureReportProcessed,
+        polkadotThresholdSignerFailureReportProcessed
+      )
+    },
+    {
+      name: "PolkadotThresholdSigner.SignersUnavailable",
+      handler: wrapHandler(
+        map.PolkadotThresholdSigner?.SignersUnavailable,
+        polkadotThresholdSignerSignersUnavailable
+      )
+    },
+    {
+      name: "PolkadotThresholdSigner.CurrentKeyUnavailable",
+      handler: wrapHandler(
+        map.PolkadotThresholdSigner?.CurrentKeyUnavailable,
+        polkadotThresholdSignerCurrentKeyUnavailable
+      )
+    },
+    {
+      name: "PolkadotThresholdSigner.ThresholdSignatureResponseTimeoutUpdated",
+      handler: wrapHandler(
+        map.PolkadotThresholdSigner?.ThresholdSignatureResponseTimeoutUpdated,
+        polkadotThresholdSignerThresholdSignatureResponseTimeoutUpdated
+      )
+    },
+    {
+      name: "BitcoinThresholdSigner.ThresholdSignatureRequest",
+      handler: wrapHandler(
+        map.BitcoinThresholdSigner?.ThresholdSignatureRequest,
+        bitcoinThresholdSignerThresholdSignatureRequest
+      )
+    },
+    {
+      name: "BitcoinThresholdSigner.ThresholdSignatureFailed",
+      handler: wrapHandler(
+        map.BitcoinThresholdSigner?.ThresholdSignatureFailed,
+        bitcoinThresholdSignerThresholdSignatureFailed
+      )
+    },
+    {
+      name: "BitcoinThresholdSigner.ThresholdSignatureSuccess",
+      handler: wrapHandler(
+        map.BitcoinThresholdSigner?.ThresholdSignatureSuccess,
+        bitcoinThresholdSignerThresholdSignatureSuccess
+      )
+    },
+    {
+      name: "BitcoinThresholdSigner.ThresholdDispatchComplete",
+      handler: wrapHandler(
+        map.BitcoinThresholdSigner?.ThresholdDispatchComplete,
+        bitcoinThresholdSignerThresholdDispatchComplete
+      )
+    },
+    {
+      name: "BitcoinThresholdSigner.RetryRequested",
+      handler: wrapHandler(
+        map.BitcoinThresholdSigner?.RetryRequested,
+        bitcoinThresholdSignerRetryRequested
+      )
+    },
+    {
+      name: "BitcoinThresholdSigner.FailureReportProcessed",
+      handler: wrapHandler(
+        map.BitcoinThresholdSigner?.FailureReportProcessed,
+        bitcoinThresholdSignerFailureReportProcessed
+      )
+    },
+    {
+      name: "BitcoinThresholdSigner.SignersUnavailable",
+      handler: wrapHandler(
+        map.BitcoinThresholdSigner?.SignersUnavailable,
+        bitcoinThresholdSignerSignersUnavailable
+      )
+    },
+    {
+      name: "BitcoinThresholdSigner.CurrentKeyUnavailable",
+      handler: wrapHandler(
+        map.BitcoinThresholdSigner?.CurrentKeyUnavailable,
+        bitcoinThresholdSignerCurrentKeyUnavailable
+      )
+    },
+    {
+      name: "BitcoinThresholdSigner.ThresholdSignatureResponseTimeoutUpdated",
+      handler: wrapHandler(
+        map.BitcoinThresholdSigner?.ThresholdSignatureResponseTimeoutUpdated,
+        bitcoinThresholdSignerThresholdSignatureResponseTimeoutUpdated
+      )
+    },
+    {
+      name: "EthereumBroadcaster.TransactionBroadcastRequest",
+      handler: wrapHandler(
+        map.EthereumBroadcaster?.TransactionBroadcastRequest,
+        ethereumBroadcasterTransactionBroadcastRequest
+      )
+    },
+    {
+      name: "EthereumBroadcaster.BroadcastRetryScheduled",
+      handler: wrapHandler(
+        map.EthereumBroadcaster?.BroadcastRetryScheduled,
+        ethereumBroadcasterBroadcastRetryScheduled
+      )
+    },
+    {
+      name: "EthereumBroadcaster.BroadcastAttemptTimeout",
+      handler: wrapHandler(
+        map.EthereumBroadcaster?.BroadcastAttemptTimeout,
+        ethereumBroadcasterBroadcastAttemptTimeout
+      )
+    },
+    {
+      name: "EthereumBroadcaster.BroadcastAborted",
+      handler: wrapHandler(
+        map.EthereumBroadcaster?.BroadcastAborted,
+        ethereumBroadcasterBroadcastAborted
+      )
+    },
+    {
+      name: "EthereumBroadcaster.BroadcastSuccess",
+      handler: wrapHandler(
+        map.EthereumBroadcaster?.BroadcastSuccess,
+        ethereumBroadcasterBroadcastSuccess
+      )
+    },
+    {
+      name: "EthereumBroadcaster.ThresholdSignatureInvalid",
+      handler: wrapHandler(
+        map.EthereumBroadcaster?.ThresholdSignatureInvalid,
+        ethereumBroadcasterThresholdSignatureInvalid
+      )
+    },
+    {
+      name: "EthereumBroadcaster.BroadcastCallbackExecuted",
+      handler: wrapHandler(
+        map.EthereumBroadcaster?.BroadcastCallbackExecuted,
+        ethereumBroadcasterBroadcastCallbackExecuted
+      )
+    },
+    {
+      name: "EthereumBroadcaster.TransactionFeeDeficitRecorded",
+      handler: wrapHandler(
+        map.EthereumBroadcaster?.TransactionFeeDeficitRecorded,
+        ethereumBroadcasterTransactionFeeDeficitRecorded
+      )
+    },
+    {
+      name: "EthereumBroadcaster.TransactionFeeDeficitRefused",
+      handler: wrapHandler(
+        map.EthereumBroadcaster?.TransactionFeeDeficitRefused,
+        ethereumBroadcasterTransactionFeeDeficitRefused
+      )
+    },
+    {
+      name: "PolkadotBroadcaster.TransactionBroadcastRequest",
+      handler: wrapHandler(
+        map.PolkadotBroadcaster?.TransactionBroadcastRequest,
+        polkadotBroadcasterTransactionBroadcastRequest
+      )
+    },
+    {
+      name: "PolkadotBroadcaster.BroadcastRetryScheduled",
+      handler: wrapHandler(
+        map.PolkadotBroadcaster?.BroadcastRetryScheduled,
+        polkadotBroadcasterBroadcastRetryScheduled
+      )
+    },
+    {
+      name: "PolkadotBroadcaster.BroadcastAttemptTimeout",
+      handler: wrapHandler(
+        map.PolkadotBroadcaster?.BroadcastAttemptTimeout,
+        polkadotBroadcasterBroadcastAttemptTimeout
+      )
+    },
+    {
+      name: "PolkadotBroadcaster.BroadcastAborted",
+      handler: wrapHandler(
+        map.PolkadotBroadcaster?.BroadcastAborted,
+        polkadotBroadcasterBroadcastAborted
+      )
+    },
+    {
+      name: "PolkadotBroadcaster.BroadcastSuccess",
+      handler: wrapHandler(
+        map.PolkadotBroadcaster?.BroadcastSuccess,
+        polkadotBroadcasterBroadcastSuccess
+      )
+    },
+    {
+      name: "PolkadotBroadcaster.ThresholdSignatureInvalid",
+      handler: wrapHandler(
+        map.PolkadotBroadcaster?.ThresholdSignatureInvalid,
+        polkadotBroadcasterThresholdSignatureInvalid
+      )
+    },
+    {
+      name: "PolkadotBroadcaster.BroadcastCallbackExecuted",
+      handler: wrapHandler(
+        map.PolkadotBroadcaster?.BroadcastCallbackExecuted,
+        polkadotBroadcasterBroadcastCallbackExecuted
+      )
+    },
+    {
+      name: "PolkadotBroadcaster.TransactionFeeDeficitRecorded",
+      handler: wrapHandler(
+        map.PolkadotBroadcaster?.TransactionFeeDeficitRecorded,
+        polkadotBroadcasterTransactionFeeDeficitRecorded
+      )
+    },
+    {
+      name: "PolkadotBroadcaster.TransactionFeeDeficitRefused",
+      handler: wrapHandler(
+        map.PolkadotBroadcaster?.TransactionFeeDeficitRefused,
+        polkadotBroadcasterTransactionFeeDeficitRefused
+      )
+    },
+    {
+      name: "BitcoinBroadcaster.TransactionBroadcastRequest",
+      handler: wrapHandler(
+        map.BitcoinBroadcaster?.TransactionBroadcastRequest,
+        bitcoinBroadcasterTransactionBroadcastRequest
+      )
+    },
+    {
+      name: "BitcoinBroadcaster.BroadcastRetryScheduled",
+      handler: wrapHandler(
+        map.BitcoinBroadcaster?.BroadcastRetryScheduled,
+        bitcoinBroadcasterBroadcastRetryScheduled
+      )
+    },
+    {
+      name: "BitcoinBroadcaster.BroadcastAttemptTimeout",
+      handler: wrapHandler(
+        map.BitcoinBroadcaster?.BroadcastAttemptTimeout,
+        bitcoinBroadcasterBroadcastAttemptTimeout
+      )
+    },
+    {
+      name: "BitcoinBroadcaster.BroadcastAborted",
+      handler: wrapHandler(
+        map.BitcoinBroadcaster?.BroadcastAborted,
+        bitcoinBroadcasterBroadcastAborted
+      )
+    },
+    {
+      name: "BitcoinBroadcaster.BroadcastSuccess",
+      handler: wrapHandler(
+        map.BitcoinBroadcaster?.BroadcastSuccess,
+        bitcoinBroadcasterBroadcastSuccess
+      )
+    },
+    {
+      name: "BitcoinBroadcaster.ThresholdSignatureInvalid",
+      handler: wrapHandler(
+        map.BitcoinBroadcaster?.ThresholdSignatureInvalid,
+        bitcoinBroadcasterThresholdSignatureInvalid
+      )
+    },
+    {
+      name: "BitcoinBroadcaster.BroadcastCallbackExecuted",
+      handler: wrapHandler(
+        map.BitcoinBroadcaster?.BroadcastCallbackExecuted,
+        bitcoinBroadcasterBroadcastCallbackExecuted
+      )
+    },
+    {
+      name: "BitcoinBroadcaster.TransactionFeeDeficitRecorded",
+      handler: wrapHandler(
+        map.BitcoinBroadcaster?.TransactionFeeDeficitRecorded,
+        bitcoinBroadcasterTransactionFeeDeficitRecorded
+      )
+    },
+    {
+      name: "BitcoinBroadcaster.TransactionFeeDeficitRefused",
+      handler: wrapHandler(
+        map.BitcoinBroadcaster?.TransactionFeeDeficitRefused,
+        bitcoinBroadcasterTransactionFeeDeficitRefused
+      )
+    },
+    {
+      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.MinimumSwapAmountSet",
+      handler: wrapHandler(map.Swapping?.MinimumSwapAmountSet, swappingMinimumSwapAmountSet)
+    },
+    {
+      name: "Swapping.SwapAmountTooLow",
+      handler: wrapHandler(map.Swapping?.SwapAmountTooLow, swappingSwapAmountTooLow)
+    },
+    {
+      name: "Swapping.CcmFailed",
+      handler: wrapHandler(map.Swapping?.CcmFailed, swappingCcmFailed)
+    },
+    {
+      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: "EthereumIngressEgress.DepositReceived",
+      handler: wrapHandler(
+        map.EthereumIngressEgress?.DepositReceived,
+        ethereumIngressEgressDepositReceived
+      )
+    },
+    {
+      name: "EthereumIngressEgress.AssetEgressStatusChanged",
+      handler: wrapHandler(
+        map.EthereumIngressEgress?.AssetEgressStatusChanged,
+        ethereumIngressEgressAssetEgressStatusChanged
+      )
+    },
+    {
+      name: "EthereumIngressEgress.EgressScheduled",
+      handler: wrapHandler(
+        map.EthereumIngressEgress?.EgressScheduled,
+        ethereumIngressEgressEgressScheduled
+      )
+    },
+    {
+      name: "EthereumIngressEgress.CcmBroadcastRequested",
+      handler: wrapHandler(
+        map.EthereumIngressEgress?.CcmBroadcastRequested,
+        ethereumIngressEgressCcmBroadcastRequested
+      )
+    },
+    {
+      name: "EthereumIngressEgress.CcmEgressInvalid",
+      handler: wrapHandler(
+        map.EthereumIngressEgress?.CcmEgressInvalid,
+        ethereumIngressEgressCcmEgressInvalid
+      )
+    },
+    {
+      name: "EthereumIngressEgress.DepositFetchesScheduled",
+      handler: wrapHandler(
+        map.EthereumIngressEgress?.DepositFetchesScheduled,
+        ethereumIngressEgressDepositFetchesScheduled
+      )
+    },
+    {
+      name: "EthereumIngressEgress.BatchBroadcastRequested",
+      handler: wrapHandler(
+        map.EthereumIngressEgress?.BatchBroadcastRequested,
+        ethereumIngressEgressBatchBroadcastRequested
+      )
+    },
+    {
+      name: "EthereumIngressEgress.MinimumDepositSet",
+      handler: wrapHandler(
+        map.EthereumIngressEgress?.MinimumDepositSet,
+        ethereumIngressEgressMinimumDepositSet
+      )
+    },
+    {
+      name: "EthereumIngressEgress.DepositIgnored",
+      handler: wrapHandler(
+        map.EthereumIngressEgress?.DepositIgnored,
+        ethereumIngressEgressDepositIgnored
+      )
+    },
+    {
+      name: "EthereumIngressEgress.VaultTransferFailed",
+      handler: wrapHandler(
+        map.EthereumIngressEgress?.VaultTransferFailed,
+        ethereumIngressEgressVaultTransferFailed
+      )
+    },
+    {
+      name: "EthereumIngressEgress.DepositWitnessRejected",
+      handler: wrapHandler(
+        map.EthereumIngressEgress?.DepositWitnessRejected,
+        ethereumIngressEgressDepositWitnessRejected
+      )
+    },
+    {
+      name: "PolkadotIngressEgress.DepositReceived",
+      handler: wrapHandler(
+        map.PolkadotIngressEgress?.DepositReceived,
+        polkadotIngressEgressDepositReceived
+      )
+    },
+    {
+      name: "PolkadotIngressEgress.AssetEgressStatusChanged",
+      handler: wrapHandler(
+        map.PolkadotIngressEgress?.AssetEgressStatusChanged,
+        polkadotIngressEgressAssetEgressStatusChanged
+      )
+    },
+    {
+      name: "PolkadotIngressEgress.EgressScheduled",
+      handler: wrapHandler(
+        map.PolkadotIngressEgress?.EgressScheduled,
+        polkadotIngressEgressEgressScheduled
+      )
+    },
+    {
+      name: "PolkadotIngressEgress.CcmBroadcastRequested",
+      handler: wrapHandler(
+        map.PolkadotIngressEgress?.CcmBroadcastRequested,
+        polkadotIngressEgressCcmBroadcastRequested
+      )
+    },
+    {
+      name: "PolkadotIngressEgress.CcmEgressInvalid",
+      handler: wrapHandler(
+        map.PolkadotIngressEgress?.CcmEgressInvalid,
+        polkadotIngressEgressCcmEgressInvalid
+      )
+    },
+    {
+      name: "PolkadotIngressEgress.DepositFetchesScheduled",
+      handler: wrapHandler(
+        map.PolkadotIngressEgress?.DepositFetchesScheduled,
+        polkadotIngressEgressDepositFetchesScheduled
+      )
+    },
+    {
+      name: "PolkadotIngressEgress.BatchBroadcastRequested",
+      handler: wrapHandler(
+        map.PolkadotIngressEgress?.BatchBroadcastRequested,
+        polkadotIngressEgressBatchBroadcastRequested
+      )
+    },
+    {
+      name: "PolkadotIngressEgress.MinimumDepositSet",
+      handler: wrapHandler(
+        map.PolkadotIngressEgress?.MinimumDepositSet,
+        polkadotIngressEgressMinimumDepositSet
+      )
+    },
+    {
+      name: "PolkadotIngressEgress.DepositIgnored",
+      handler: wrapHandler(
+        map.PolkadotIngressEgress?.DepositIgnored,
+        polkadotIngressEgressDepositIgnored
+      )
+    },
+    {
+      name: "PolkadotIngressEgress.VaultTransferFailed",
+      handler: wrapHandler(
+        map.PolkadotIngressEgress?.VaultTransferFailed,
+        polkadotIngressEgressVaultTransferFailed
+      )
+    },
+    {
+      name: "PolkadotIngressEgress.DepositWitnessRejected",
+      handler: wrapHandler(
+        map.PolkadotIngressEgress?.DepositWitnessRejected,
+        polkadotIngressEgressDepositWitnessRejected
+      )
+    },
+    {
+      name: "BitcoinIngressEgress.DepositReceived",
+      handler: wrapHandler(
+        map.BitcoinIngressEgress?.DepositReceived,
+        bitcoinIngressEgressDepositReceived
+      )
+    },
+    {
+      name: "BitcoinIngressEgress.AssetEgressStatusChanged",
+      handler: wrapHandler(
+        map.BitcoinIngressEgress?.AssetEgressStatusChanged,
+        bitcoinIngressEgressAssetEgressStatusChanged
+      )
+    },
+    {
+      name: "BitcoinIngressEgress.EgressScheduled",
+      handler: wrapHandler(
+        map.BitcoinIngressEgress?.EgressScheduled,
+        bitcoinIngressEgressEgressScheduled
+      )
+    },
+    {
+      name: "BitcoinIngressEgress.CcmBroadcastRequested",
+      handler: wrapHandler(
+        map.BitcoinIngressEgress?.CcmBroadcastRequested,
+        bitcoinIngressEgressCcmBroadcastRequested
+      )
+    },
+    {
+      name: "BitcoinIngressEgress.CcmEgressInvalid",
+      handler: wrapHandler(
+        map.BitcoinIngressEgress?.CcmEgressInvalid,
+        bitcoinIngressEgressCcmEgressInvalid
+      )
+    },
+    {
+      name: "BitcoinIngressEgress.DepositFetchesScheduled",
+      handler: wrapHandler(
+        map.BitcoinIngressEgress?.DepositFetchesScheduled,
+        bitcoinIngressEgressDepositFetchesScheduled
+      )
+    },
+    {
+      name: "BitcoinIngressEgress.BatchBroadcastRequested",
+      handler: wrapHandler(
+        map.BitcoinIngressEgress?.BatchBroadcastRequested,
+        bitcoinIngressEgressBatchBroadcastRequested
+      )
+    },
+    {
+      name: "BitcoinIngressEgress.MinimumDepositSet",
+      handler: wrapHandler(
+        map.BitcoinIngressEgress?.MinimumDepositSet,
+        bitcoinIngressEgressMinimumDepositSet
+      )
+    },
+    {
+      name: "BitcoinIngressEgress.DepositIgnored",
+      handler: wrapHandler(
+        map.BitcoinIngressEgress?.DepositIgnored,
+        bitcoinIngressEgressDepositIgnored
+      )
+    },
+    {
+      name: "BitcoinIngressEgress.VaultTransferFailed",
+      handler: wrapHandler(
+        map.BitcoinIngressEgress?.VaultTransferFailed,
+        bitcoinIngressEgressVaultTransferFailed
+      )
+    },
+    {
+      name: "BitcoinIngressEgress.DepositWitnessRejected",
+      handler: wrapHandler(
+        map.BitcoinIngressEgress?.DepositWitnessRejected,
+        bitcoinIngressEgressDepositWitnessRejected
+      )
+    },
+    {
+      name: "LiquidityPools.UpdatedBuyInterval",
+      handler: wrapHandler(
+        map.LiquidityPools?.UpdatedBuyInterval,
+        liquidityPoolsUpdatedBuyInterval
+      )
+    },
+    {
+      name: "LiquidityPools.PoolStateUpdated",
+      handler: wrapHandler(map.LiquidityPools?.PoolStateUpdated, liquidityPoolsPoolStateUpdated)
+    },
+    {
+      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.NetworkFeeTaken",
+      handler: wrapHandler(map.LiquidityPools?.NetworkFeeTaken, liquidityPoolsNetworkFeeTaken)
+    },
+    {
+      name: "LiquidityPools.AssetSwapped",
+      handler: wrapHandler(map.LiquidityPools?.AssetSwapped, liquidityPoolsAssetSwapped)
+    },
+    {
+      name: "LiquidityPools.PoolFeeSet",
+      handler: wrapHandler(map.LiquidityPools?.PoolFeeSet, liquidityPoolsPoolFeeSet)
+    }
+  ].filter((h) => h.handler !== void 0)
+});
+export {
+  handleEvents
+};