@sentio/sdk 2.52.0-rc.1 → 2.52.0-rc.2

package/src/aptos/builtin/0x1.ts

@@ -525,19 +525,19 @@ export class coin extends AptosBaseProcessor {
     return this;
   }
 
-  onEventPairCreation(
-    func: (event: coin.PairCreationInstance, ctx: AptosContext) => void,
+  onEventDepositEvent(
+    func: (event: coin.DepositEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): coin {
-    this.onMoveEvent(func, { type: "coin::PairCreation" }, fetchConfig);
+    this.onMoveEvent(func, { type: "coin::DepositEvent" }, fetchConfig);
     return this;
   }
 
-  onEventDepositEvent(
-    func: (event: coin.DepositEventInstance, ctx: AptosContext) => void,
+  onEventPairCreation(
+    func: (event: coin.PairCreationInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): coin {
-    this.onMoveEvent(func, { type: "coin::DepositEvent" }, fetchConfig);
+    this.onMoveEvent(func, { type: "coin::PairCreation" }, fetchConfig);
     return this;
   }
 
@@ -1908,19 +1908,19 @@ export class block extends AptosBaseProcessor {
     return this;
   }
 
-  onEventUpdateEpochInterval(
-    func: (event: block.UpdateEpochIntervalInstance, ctx: AptosContext) => void,
+  onEventNewBlockEvent(
+    func: (event: block.NewBlockEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): block {
-    this.onMoveEvent(func, { type: "block::UpdateEpochInterval" }, fetchConfig);
+    this.onMoveEvent(func, { type: "block::NewBlockEvent" }, fetchConfig);
     return this;
   }
 
-  onEventNewBlockEvent(
-    func: (event: block.NewBlockEventInstance, ctx: AptosContext) => void,
+  onEventUpdateEpochInterval(
+    func: (event: block.UpdateEpochIntervalInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): block {
-    this.onMoveEvent(func, { type: "block::NewBlockEvent" }, fetchConfig);
+    this.onMoveEvent(func, { type: "block::UpdateEpochInterval" }, fetchConfig);
     return this;
   }
 
@@ -2382,136 +2382,104 @@ export class stake extends AptosBaseProcessor {
     return this;
   }
 
-  onEventDistributeRewards(
-    func: (event: stake.DistributeRewardsInstance, ctx: AptosContext) => void,
-    fetchConfig?: Partial<MoveFetchConfig>,
-  ): stake {
-    this.onMoveEvent(func, { type: "stake::DistributeRewards" }, fetchConfig);
-    return this;
-  }
-
-  onEventIncreaseLockup(
-    func: (event: stake.IncreaseLockupInstance, ctx: AptosContext) => void,
-    fetchConfig?: Partial<MoveFetchConfig>,
-  ): stake {
-    this.onMoveEvent(func, { type: "stake::IncreaseLockup" }, fetchConfig);
-    return this;
-  }
-
-  onEventJoinValidatorSet(
-    func: (event: stake.JoinValidatorSetInstance, ctx: AptosContext) => void,
-    fetchConfig?: Partial<MoveFetchConfig>,
-  ): stake {
-    this.onMoveEvent(func, { type: "stake::JoinValidatorSet" }, fetchConfig);
-    return this;
-  }
-
-  onEventLeaveValidatorSet(
-    func: (event: stake.LeaveValidatorSetInstance, ctx: AptosContext) => void,
+  onEventAddStakeEvent(
+    func: (event: stake.AddStakeEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
-    this.onMoveEvent(func, { type: "stake::LeaveValidatorSet" }, fetchConfig);
+    this.onMoveEvent(func, { type: "stake::AddStakeEvent" }, fetchConfig);
     return this;
   }
 
-  onEventReactivateStake(
-    func: (event: stake.ReactivateStakeInstance, ctx: AptosContext) => void,
+  onEventDistributeRewards(
+    func: (event: stake.DistributeRewardsInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
-    this.onMoveEvent(func, { type: "stake::ReactivateStake" }, fetchConfig);
+    this.onMoveEvent(func, { type: "stake::DistributeRewards" }, fetchConfig);
     return this;
   }
 
-  onEventRegisterValidatorCandidate(
+  onEventDistributeRewardsEvent(
     func: (
-      event: stake.RegisterValidatorCandidateInstance,
+      event: stake.DistributeRewardsEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
     this.onMoveEvent(
       func,
-      { type: "stake::RegisterValidatorCandidate" },
+      { type: "stake::DistributeRewardsEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventRotateConsensusKey(
-    func: (event: stake.RotateConsensusKeyInstance, ctx: AptosContext) => void,
+  onEventIncreaseLockup(
+    func: (event: stake.IncreaseLockupInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
-    this.onMoveEvent(func, { type: "stake::RotateConsensusKey" }, fetchConfig);
+    this.onMoveEvent(func, { type: "stake::IncreaseLockup" }, fetchConfig);
     return this;
   }
 
-  onEventSetOperator(
-    func: (event: stake.SetOperatorInstance, ctx: AptosContext) => void,
+  onEventIncreaseLockupEvent(
+    func: (event: stake.IncreaseLockupEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
-    this.onMoveEvent(func, { type: "stake::SetOperator" }, fetchConfig);
+    this.onMoveEvent(func, { type: "stake::IncreaseLockupEvent" }, fetchConfig);
     return this;
   }
 
-  onEventUnlockStake(
-    func: (event: stake.UnlockStakeInstance, ctx: AptosContext) => void,
+  onEventJoinValidatorSet(
+    func: (event: stake.JoinValidatorSetInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
-    this.onMoveEvent(func, { type: "stake::UnlockStake" }, fetchConfig);
+    this.onMoveEvent(func, { type: "stake::JoinValidatorSet" }, fetchConfig);
     return this;
   }
 
-  onEventUpdateNetworkAndFullnodeAddresses(
+  onEventJoinValidatorSetEvent(
     func: (
-      event: stake.UpdateNetworkAndFullnodeAddressesInstance,
+      event: stake.JoinValidatorSetEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
     this.onMoveEvent(
       func,
-      { type: "stake::UpdateNetworkAndFullnodeAddresses" },
+      { type: "stake::JoinValidatorSetEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventWithdrawStake(
-    func: (event: stake.WithdrawStakeInstance, ctx: AptosContext) => void,
+  onEventLeaveValidatorSet(
+    func: (event: stake.LeaveValidatorSetInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
-    this.onMoveEvent(func, { type: "stake::WithdrawStake" }, fetchConfig);
+    this.onMoveEvent(func, { type: "stake::LeaveValidatorSet" }, fetchConfig);
     return this;
   }
 
-  onEventRegisterValidatorCandidateEvent(
+  onEventLeaveValidatorSetEvent(
     func: (
-      event: stake.RegisterValidatorCandidateEventInstance,
+      event: stake.LeaveValidatorSetEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
     this.onMoveEvent(
       func,
-      { type: "stake::RegisterValidatorCandidateEvent" },
+      { type: "stake::LeaveValidatorSetEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventSetOperatorEvent(
-    func: (event: stake.SetOperatorEventInstance, ctx: AptosContext) => void,
-    fetchConfig?: Partial<MoveFetchConfig>,
-  ): stake {
-    this.onMoveEvent(func, { type: "stake::SetOperatorEvent" }, fetchConfig);
-    return this;
-  }
-
-  onEventAddStakeEvent(
-    func: (event: stake.AddStakeEventInstance, ctx: AptosContext) => void,
+  onEventReactivateStake(
+    func: (event: stake.ReactivateStakeInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
-    this.onMoveEvent(func, { type: "stake::AddStakeEvent" }, fetchConfig);
+    this.onMoveEvent(func, { type: "stake::ReactivateStake" }, fetchConfig);
     return this;
   }
 
@@ -2530,71 +2498,80 @@ export class stake extends AptosBaseProcessor {
     return this;
   }
 
-  onEventRotateConsensusKeyEvent(
+  onEventRegisterValidatorCandidate(
     func: (
-      event: stake.RotateConsensusKeyEventInstance,
+      event: stake.RegisterValidatorCandidateInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
     this.onMoveEvent(
       func,
-      { type: "stake::RotateConsensusKeyEvent" },
+      { type: "stake::RegisterValidatorCandidate" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventUpdateNetworkAndFullnodeAddressesEvent(
+  onEventRegisterValidatorCandidateEvent(
     func: (
-      event: stake.UpdateNetworkAndFullnodeAddressesEventInstance,
+      event: stake.RegisterValidatorCandidateEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
     this.onMoveEvent(
       func,
-      { type: "stake::UpdateNetworkAndFullnodeAddressesEvent" },
+      { type: "stake::RegisterValidatorCandidateEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventIncreaseLockupEvent(
-    func: (event: stake.IncreaseLockupEventInstance, ctx: AptosContext) => void,
+  onEventRotateConsensusKey(
+    func: (event: stake.RotateConsensusKeyInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
-    this.onMoveEvent(func, { type: "stake::IncreaseLockupEvent" }, fetchConfig);
+    this.onMoveEvent(func, { type: "stake::RotateConsensusKey" }, fetchConfig);
     return this;
   }
 
-  onEventJoinValidatorSetEvent(
+  onEventRotateConsensusKeyEvent(
     func: (
-      event: stake.JoinValidatorSetEventInstance,
+      event: stake.RotateConsensusKeyEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
     this.onMoveEvent(
       func,
-      { type: "stake::JoinValidatorSetEvent" },
+      { type: "stake::RotateConsensusKeyEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventDistributeRewardsEvent(
-    func: (
-      event: stake.DistributeRewardsEventInstance,
-      ctx: AptosContext,
-    ) => void,
+  onEventSetOperator(
+    func: (event: stake.SetOperatorInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
-    this.onMoveEvent(
-      func,
-      { type: "stake::DistributeRewardsEvent" },
-      fetchConfig,
-    );
+    this.onMoveEvent(func, { type: "stake::SetOperator" }, fetchConfig);
+    return this;
+  }
+
+  onEventSetOperatorEvent(
+    func: (event: stake.SetOperatorEventInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): stake {
+    this.onMoveEvent(func, { type: "stake::SetOperatorEvent" }, fetchConfig);
+    return this;
+  }
+
+  onEventUnlockStake(
+    func: (event: stake.UnlockStakeInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): stake {
+    this.onMoveEvent(func, { type: "stake::UnlockStake" }, fetchConfig);
     return this;
   }
 
@@ -2606,28 +2583,51 @@ export class stake extends AptosBaseProcessor {
     return this;
   }
 
-  onEventWithdrawStakeEvent(
-    func: (event: stake.WithdrawStakeEventInstance, ctx: AptosContext) => void,
+  onEventUpdateNetworkAndFullnodeAddresses(
+    func: (
+      event: stake.UpdateNetworkAndFullnodeAddressesInstance,
+      ctx: AptosContext,
+    ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
-    this.onMoveEvent(func, { type: "stake::WithdrawStakeEvent" }, fetchConfig);
+    this.onMoveEvent(
+      func,
+      { type: "stake::UpdateNetworkAndFullnodeAddresses" },
+      fetchConfig,
+    );
     return this;
   }
 
-  onEventLeaveValidatorSetEvent(
+  onEventUpdateNetworkAndFullnodeAddressesEvent(
     func: (
-      event: stake.LeaveValidatorSetEventInstance,
+      event: stake.UpdateNetworkAndFullnodeAddressesEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
     this.onMoveEvent(
       func,
-      { type: "stake::LeaveValidatorSetEvent" },
+      { type: "stake::UpdateNetworkAndFullnodeAddressesEvent" },
       fetchConfig,
     );
     return this;
   }
+
+  onEventWithdrawStake(
+    func: (event: stake.WithdrawStakeInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): stake {
+    this.onMoveEvent(func, { type: "stake::WithdrawStake" }, fetchConfig);
+    return this;
+  }
+
+  onEventWithdrawStakeEvent(
+    func: (event: stake.WithdrawStakeEventInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): stake {
+    this.onMoveEvent(func, { type: "stake::WithdrawStakeEvent" }, fetchConfig);
+    return this;
+  }
 }
 
 export namespace stake {
@@ -4626,50 +4626,50 @@ export class voting extends AptosBaseProcessor {
     return this;
   }
 
-  onEventRegisterForum(
-    func: (event: voting.RegisterForumInstance, ctx: AptosContext) => void,
+  onEventCreateProposalEvent(
+    func: (
+      event: voting.CreateProposalEventInstance,
+      ctx: AptosContext,
+    ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): voting {
-    this.onMoveEvent(func, { type: "voting::RegisterForum" }, fetchConfig);
+    this.onMoveEvent(
+      func,
+      { type: "voting::CreateProposalEvent" },
+      fetchConfig,
+    );
     return this;
   }
 
-  onEventResolveProposal(
-    func: (event: voting.ResolveProposalInstance, ctx: AptosContext) => void,
+  onEventRegisterForum(
+    func: (event: voting.RegisterForumInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): voting {
-    this.onMoveEvent(func, { type: "voting::ResolveProposal" }, fetchConfig);
+    this.onMoveEvent(func, { type: "voting::RegisterForum" }, fetchConfig);
     return this;
   }
 
-  onEventVote(
-    func: (event: voting.VoteInstance, ctx: AptosContext) => void,
+  onEventRegisterForumEvent(
+    func: (event: voting.RegisterForumEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): voting {
-    this.onMoveEvent(func, { type: "voting::Vote" }, fetchConfig);
+    this.onMoveEvent(func, { type: "voting::RegisterForumEvent" }, fetchConfig);
     return this;
   }
 
-  onEventCreateProposalEvent(
-    func: (
-      event: voting.CreateProposalEventInstance,
-      ctx: AptosContext,
-    ) => void,
+  onEventResolveProposal(
+    func: (event: voting.ResolveProposalInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): voting {
-    this.onMoveEvent(
-      func,
-      { type: "voting::CreateProposalEvent" },
-      fetchConfig,
-    );
+    this.onMoveEvent(func, { type: "voting::ResolveProposal" }, fetchConfig);
     return this;
   }
 
-  onEventRegisterForumEvent(
-    func: (event: voting.RegisterForumEventInstance, ctx: AptosContext) => void,
+  onEventVote(
+    func: (event: voting.VoteInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): voting {
-    this.onMoveEvent(func, { type: "voting::RegisterForumEvent" }, fetchConfig);
+    this.onMoveEvent(func, { type: "voting::Vote" }, fetchConfig);
     return this;
   }
 
@@ -5438,14 +5438,6 @@ export class account extends AptosBaseProcessor {
     return this;
   }
 
-  onEventKeyRotation(
-    func: (event: account.KeyRotationInstance, ctx: AptosContext) => void,
-    fetchConfig?: Partial<MoveFetchConfig>,
-  ): account {
-    this.onMoveEvent(func, { type: "account::KeyRotation" }, fetchConfig);
-    return this;
-  }
-
   onEventCoinRegisterEvent(
     func: (event: account.CoinRegisterEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
@@ -5454,6 +5446,14 @@ export class account extends AptosBaseProcessor {
     return this;
   }
 
+  onEventKeyRotation(
+    func: (event: account.KeyRotationInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): account {
+    this.onMoveEvent(func, { type: "account::KeyRotation" }, fetchConfig);
+    return this;
+  }
+
   onEventKeyRotationEvent(
     func: (event: account.KeyRotationEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
@@ -6810,197 +6810,197 @@ export class vesting extends AptosBaseProcessor {
     return this;
   }
 
-  onEventCreateVestingContract(
+  onEventAdminWithdrawEvent(
     func: (
-      event: vesting.CreateVestingContractInstance,
+      event: vesting.AdminWithdrawEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
     this.onMoveEvent(
       func,
-      { type: "vesting::CreateVestingContract" },
+      { type: "vesting::AdminWithdrawEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventDistribute(
-    func: (event: vesting.DistributeInstance, ctx: AptosContext) => void,
-    fetchConfig?: Partial<MoveFetchConfig>,
-  ): vesting {
-    this.onMoveEvent(func, { type: "vesting::Distribute" }, fetchConfig);
-    return this;
-  }
-
-  onEventResetLockup(
-    func: (event: vesting.ResetLockupInstance, ctx: AptosContext) => void,
+  onEventCreateVestingContract(
+    func: (
+      event: vesting.CreateVestingContractInstance,
+      ctx: AptosContext,
+    ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
-    this.onMoveEvent(func, { type: "vesting::ResetLockup" }, fetchConfig);
+    this.onMoveEvent(
+      func,
+      { type: "vesting::CreateVestingContract" },
+      fetchConfig,
+    );
     return this;
   }
 
-  onEventSetBeneficiary(
-    func: (event: vesting.SetBeneficiaryInstance, ctx: AptosContext) => void,
+  onEventCreateVestingContractEvent(
+    func: (
+      event: vesting.CreateVestingContractEventInstance,
+      ctx: AptosContext,
+    ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
-    this.onMoveEvent(func, { type: "vesting::SetBeneficiary" }, fetchConfig);
+    this.onMoveEvent(
+      func,
+      { type: "vesting::CreateVestingContractEvent" },
+      fetchConfig,
+    );
     return this;
   }
 
-  onEventTerminate(
-    func: (event: vesting.TerminateInstance, ctx: AptosContext) => void,
+  onEventDistribute(
+    func: (event: vesting.DistributeInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
-    this.onMoveEvent(func, { type: "vesting::Terminate" }, fetchConfig);
+    this.onMoveEvent(func, { type: "vesting::Distribute" }, fetchConfig);
     return this;
   }
 
-  onEventUnlockRewards(
-    func: (event: vesting.UnlockRewardsInstance, ctx: AptosContext) => void,
+  onEventDistributeEvent(
+    func: (event: vesting.DistributeEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
-    this.onMoveEvent(func, { type: "vesting::UnlockRewards" }, fetchConfig);
+    this.onMoveEvent(func, { type: "vesting::DistributeEvent" }, fetchConfig);
     return this;
   }
 
-  onEventUpdateOperator(
-    func: (event: vesting.UpdateOperatorInstance, ctx: AptosContext) => void,
+  onEventResetLockup(
+    func: (event: vesting.ResetLockupInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
-    this.onMoveEvent(func, { type: "vesting::UpdateOperator" }, fetchConfig);
+    this.onMoveEvent(func, { type: "vesting::ResetLockup" }, fetchConfig);
     return this;
   }
 
-  onEventUpdateVoter(
-    func: (event: vesting.UpdateVoterInstance, ctx: AptosContext) => void,
+  onEventResetLockupEvent(
+    func: (event: vesting.ResetLockupEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
-    this.onMoveEvent(func, { type: "vesting::UpdateVoter" }, fetchConfig);
+    this.onMoveEvent(func, { type: "vesting::ResetLockupEvent" }, fetchConfig);
     return this;
   }
 
-  onEventVest(
-    func: (event: vesting.VestInstance, ctx: AptosContext) => void,
+  onEventSetBeneficiary(
+    func: (event: vesting.SetBeneficiaryInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
-    this.onMoveEvent(func, { type: "vesting::Vest" }, fetchConfig);
+    this.onMoveEvent(func, { type: "vesting::SetBeneficiary" }, fetchConfig);
     return this;
   }
 
-  onEventCreateVestingContractEvent(
+  onEventSetBeneficiaryEvent(
     func: (
-      event: vesting.CreateVestingContractEventInstance,
+      event: vesting.SetBeneficiaryEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
     this.onMoveEvent(
       func,
-      { type: "vesting::CreateVestingContractEvent" },
+      { type: "vesting::SetBeneficiaryEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventUpdateOperatorEvent(
-    func: (
-      event: vesting.UpdateOperatorEventInstance,
-      ctx: AptosContext,
-    ) => void,
+  onEventTerminate(
+    func: (event: vesting.TerminateInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
-    this.onMoveEvent(
-      func,
-      { type: "vesting::UpdateOperatorEvent" },
-      fetchConfig,
-    );
+    this.onMoveEvent(func, { type: "vesting::Terminate" }, fetchConfig);
     return this;
   }
 
-  onEventUpdateVoterEvent(
-    func: (event: vesting.UpdateVoterEventInstance, ctx: AptosContext) => void,
+  onEventTerminateEvent(
+    func: (event: vesting.TerminateEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
-    this.onMoveEvent(func, { type: "vesting::UpdateVoterEvent" }, fetchConfig);
+    this.onMoveEvent(func, { type: "vesting::TerminateEvent" }, fetchConfig);
     return this;
   }
 
-  onEventResetLockupEvent(
-    func: (event: vesting.ResetLockupEventInstance, ctx: AptosContext) => void,
+  onEventUnlockRewards(
+    func: (event: vesting.UnlockRewardsInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
-    this.onMoveEvent(func, { type: "vesting::ResetLockupEvent" }, fetchConfig);
+    this.onMoveEvent(func, { type: "vesting::UnlockRewards" }, fetchConfig);
     return this;
   }
 
-  onEventSetBeneficiaryEvent(
+  onEventUnlockRewardsEvent(
     func: (
-      event: vesting.SetBeneficiaryEventInstance,
+      event: vesting.UnlockRewardsEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
     this.onMoveEvent(
       func,
-      { type: "vesting::SetBeneficiaryEvent" },
+      { type: "vesting::UnlockRewardsEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventUnlockRewardsEvent(
+  onEventUpdateOperator(
+    func: (event: vesting.UpdateOperatorInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): vesting {
+    this.onMoveEvent(func, { type: "vesting::UpdateOperator" }, fetchConfig);
+    return this;
+  }
+
+  onEventUpdateOperatorEvent(
     func: (
-      event: vesting.UnlockRewardsEventInstance,
+      event: vesting.UpdateOperatorEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
     this.onMoveEvent(
       func,
-      { type: "vesting::UnlockRewardsEvent" },
+      { type: "vesting::UpdateOperatorEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventVestEvent(
-    func: (event: vesting.VestEventInstance, ctx: AptosContext) => void,
+  onEventUpdateVoter(
+    func: (event: vesting.UpdateVoterInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
-    this.onMoveEvent(func, { type: "vesting::VestEvent" }, fetchConfig);
+    this.onMoveEvent(func, { type: "vesting::UpdateVoter" }, fetchConfig);
     return this;
   }
 
-  onEventDistributeEvent(
-    func: (event: vesting.DistributeEventInstance, ctx: AptosContext) => void,
+  onEventUpdateVoterEvent(
+    func: (event: vesting.UpdateVoterEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
-    this.onMoveEvent(func, { type: "vesting::DistributeEvent" }, fetchConfig);
+    this.onMoveEvent(func, { type: "vesting::UpdateVoterEvent" }, fetchConfig);
     return this;
   }
 
-  onEventTerminateEvent(
-    func: (event: vesting.TerminateEventInstance, ctx: AptosContext) => void,
+  onEventVest(
+    func: (event: vesting.VestInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
-    this.onMoveEvent(func, { type: "vesting::TerminateEvent" }, fetchConfig);
+    this.onMoveEvent(func, { type: "vesting::Vest" }, fetchConfig);
     return this;
   }
 
-  onEventAdminWithdrawEvent(
-    func: (
-      event: vesting.AdminWithdrawEventInstance,
-      ctx: AptosContext,
-    ) => void,
+  onEventVestEvent(
+    func: (event: vesting.VestEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
-    this.onMoveEvent(
-      func,
-      { type: "vesting::AdminWithdrawEvent" },
-      fetchConfig,
-    );
+    this.onMoveEvent(func, { type: "vesting::VestEvent" }, fetchConfig);
     return this;
   }
 }
@@ -11497,22 +11497,6 @@ export class fungible_asset extends AptosBaseProcessor {
     return this;
   }
 
-  onEventFrozen(
-    func: (event: fungible_asset.FrozenInstance, ctx: AptosContext) => void,
-    fetchConfig?: Partial<MoveFetchConfig>,
-  ): fungible_asset {
-    this.onMoveEvent(func, { type: "fungible_asset::Frozen" }, fetchConfig);
-    return this;
-  }
-
-  onEventWithdraw(
-    func: (event: fungible_asset.WithdrawInstance, ctx: AptosContext) => void,
-    fetchConfig?: Partial<MoveFetchConfig>,
-  ): fungible_asset {
-    this.onMoveEvent(func, { type: "fungible_asset::Withdraw" }, fetchConfig);
-    return this;
-  }
-
   onEventDepositEvent(
     func: (
       event: fungible_asset.DepositEventInstance,
@@ -11528,31 +11512,47 @@ export class fungible_asset extends AptosBaseProcessor {
     return this;
   }
 
-  onEventWithdrawEvent(
+  onEventFrozen(
+    func: (event: fungible_asset.FrozenInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): fungible_asset {
+    this.onMoveEvent(func, { type: "fungible_asset::Frozen" }, fetchConfig);
+    return this;
+  }
+
+  onEventFrozenEvent(
     func: (
-      event: fungible_asset.WithdrawEventInstance,
+      event: fungible_asset.FrozenEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): fungible_asset {
     this.onMoveEvent(
       func,
-      { type: "fungible_asset::WithdrawEvent" },
+      { type: "fungible_asset::FrozenEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventFrozenEvent(
+  onEventWithdraw(
+    func: (event: fungible_asset.WithdrawInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): fungible_asset {
+    this.onMoveEvent(func, { type: "fungible_asset::Withdraw" }, fetchConfig);
+    return this;
+  }
+
+  onEventWithdrawEvent(
     func: (
-      event: fungible_asset.FrozenEventInstance,
+      event: fungible_asset.WithdrawEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): fungible_asset {
     this.onMoveEvent(
       func,
-      { type: "fungible_asset::FrozenEvent" },
+      { type: "fungible_asset::WithdrawEvent" },
       fetchConfig,
     );
     return this;
@@ -12737,6 +12737,21 @@ export class delegation_pool extends AptosBaseProcessor {
     return this;
   }
 
+  onEventAddStakeEvent(
+    func: (
+      event: delegation_pool.AddStakeEventInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): delegation_pool {
+    this.onMoveEvent(
+      func,
+      { type: "delegation_pool::AddStakeEvent" },
+      fetchConfig,
+    );
+    return this;
+  }
+
   onEventAllowlistDelegator(
     func: (
       event: delegation_pool.AllowlistDelegatorInstance,
@@ -12782,6 +12797,21 @@ export class delegation_pool extends AptosBaseProcessor {
     return this;
   }
 
+  onEventCreateProposalEvent(
+    func: (
+      event: delegation_pool.CreateProposalEventInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): delegation_pool {
+    this.onMoveEvent(
+      func,
+      { type: "delegation_pool::CreateProposalEvent" },
+      fetchConfig,
+    );
+    return this;
+  }
+
   onEventDelegateVotingPower(
     func: (
       event: delegation_pool.DelegateVotingPowerInstance,
@@ -12797,6 +12827,21 @@ export class delegation_pool extends AptosBaseProcessor {
     return this;
   }
 
+  onEventDelegateVotingPowerEvent(
+    func: (
+      event: delegation_pool.DelegateVotingPowerEventInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): delegation_pool {
+    this.onMoveEvent(
+      func,
+      { type: "delegation_pool::DelegateVotingPowerEvent" },
+      fetchConfig,
+    );
+    return this;
+  }
+
   onEventDisableDelegatorsAllowlisting(
     func: (
       event: delegation_pool.DisableDelegatorsAllowlistingInstance,
@@ -12887,99 +12932,61 @@ export class delegation_pool extends AptosBaseProcessor {
     return this;
   }
 
-  onEventRemoveDelegatorFromAllowlist(
+  onEventReactivateStakeEvent(
     func: (
-      event: delegation_pool.RemoveDelegatorFromAllowlistInstance,
+      event: delegation_pool.ReactivateStakeEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): delegation_pool {
     this.onMoveEvent(
       func,
-      { type: "delegation_pool::RemoveDelegatorFromAllowlist" },
+      { type: "delegation_pool::ReactivateStakeEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventSetBeneficiaryForOperator(
-    func: (
-      event: delegation_pool.SetBeneficiaryForOperatorInstance,
-      ctx: AptosContext,
-    ) => void,
-    fetchConfig?: Partial<MoveFetchConfig>,
-  ): delegation_pool {
-    this.onMoveEvent(
-      func,
-      { type: "delegation_pool::SetBeneficiaryForOperator" },
-      fetchConfig,
-    );
-    return this;
-  }
-
-  onEventUnlockStake(
-    func: (
-      event: delegation_pool.UnlockStakeInstance,
-      ctx: AptosContext,
-    ) => void,
-    fetchConfig?: Partial<MoveFetchConfig>,
-  ): delegation_pool {
-    this.onMoveEvent(
-      func,
-      { type: "delegation_pool::UnlockStake" },
-      fetchConfig,
-    );
-    return this;
-  }
-
-  onEventVote(
-    func: (event: delegation_pool.VoteInstance, ctx: AptosContext) => void,
-    fetchConfig?: Partial<MoveFetchConfig>,
-  ): delegation_pool {
-    this.onMoveEvent(func, { type: "delegation_pool::Vote" }, fetchConfig);
-    return this;
-  }
-
-  onEventWithdrawStake(
+  onEventRemoveDelegatorFromAllowlist(
     func: (
-      event: delegation_pool.WithdrawStakeInstance,
+      event: delegation_pool.RemoveDelegatorFromAllowlistInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): delegation_pool {
     this.onMoveEvent(
       func,
-      { type: "delegation_pool::WithdrawStake" },
+      { type: "delegation_pool::RemoveDelegatorFromAllowlist" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventAddStakeEvent(
+  onEventSetBeneficiaryForOperator(
     func: (
-      event: delegation_pool.AddStakeEventInstance,
+      event: delegation_pool.SetBeneficiaryForOperatorInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): delegation_pool {
     this.onMoveEvent(
       func,
-      { type: "delegation_pool::AddStakeEvent" },
+      { type: "delegation_pool::SetBeneficiaryForOperator" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventReactivateStakeEvent(
+  onEventUnlockStake(
     func: (
-      event: delegation_pool.ReactivateStakeEventInstance,
+      event: delegation_pool.UnlockStakeInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): delegation_pool {
     this.onMoveEvent(
       func,
-      { type: "delegation_pool::ReactivateStakeEvent" },
+      { type: "delegation_pool::UnlockStake" },
       fetchConfig,
     );
     return this;
@@ -13000,18 +13007,11 @@ export class delegation_pool extends AptosBaseProcessor {
     return this;
   }
 
-  onEventWithdrawStakeEvent(
-    func: (
-      event: delegation_pool.WithdrawStakeEventInstance,
-      ctx: AptosContext,
-    ) => void,
+  onEventVote(
+    func: (event: delegation_pool.VoteInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): delegation_pool {
-    this.onMoveEvent(
-      func,
-      { type: "delegation_pool::WithdrawStakeEvent" },
-      fetchConfig,
-    );
+    this.onMoveEvent(func, { type: "delegation_pool::Vote" }, fetchConfig);
     return this;
   }
 
@@ -13023,31 +13023,31 @@ export class delegation_pool extends AptosBaseProcessor {
     return this;
   }
 
-  onEventCreateProposalEvent(
+  onEventWithdrawStake(
     func: (
-      event: delegation_pool.CreateProposalEventInstance,
+      event: delegation_pool.WithdrawStakeInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): delegation_pool {
     this.onMoveEvent(
       func,
-      { type: "delegation_pool::CreateProposalEvent" },
+      { type: "delegation_pool::WithdrawStake" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventDelegateVotingPowerEvent(
+  onEventWithdrawStakeEvent(
     func: (
-      event: delegation_pool.DelegateVotingPowerEventInstance,
+      event: delegation_pool.WithdrawStakeEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): delegation_pool {
     this.onMoveEvent(
       func,
-      { type: "delegation_pool::DelegateVotingPowerEvent" },
+      { type: "delegation_pool::WithdrawStakeEvent" },
       fetchConfig,
     );
     return this;
@@ -15472,39 +15472,31 @@ export class aptos_governance extends AptosBaseProcessor {
     return this;
   }
 
-  onEventUpdateConfig(
+  onEventCreateProposalEvent(
     func: (
-      event: aptos_governance.UpdateConfigInstance,
+      event: aptos_governance.CreateProposalEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): aptos_governance {
     this.onMoveEvent(
       func,
-      { type: "aptos_governance::UpdateConfig" },
+      { type: "aptos_governance::CreateProposalEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventVote(
-    func: (event: aptos_governance.VoteInstance, ctx: AptosContext) => void,
-    fetchConfig?: Partial<MoveFetchConfig>,
-  ): aptos_governance {
-    this.onMoveEvent(func, { type: "aptos_governance::Vote" }, fetchConfig);
-    return this;
-  }
-
-  onEventCreateProposalEvent(
+  onEventUpdateConfig(
     func: (
-      event: aptos_governance.CreateProposalEventInstance,
+      event: aptos_governance.UpdateConfigInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): aptos_governance {
     this.onMoveEvent(
       func,
-      { type: "aptos_governance::CreateProposalEvent" },
+      { type: "aptos_governance::UpdateConfig" },
       fetchConfig,
     );
     return this;
@@ -15525,6 +15517,14 @@ export class aptos_governance extends AptosBaseProcessor {
     return this;
   }
 
+  onEventVote(
+    func: (event: aptos_governance.VoteInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): aptos_governance {
+    this.onMoveEvent(func, { type: "aptos_governance::Vote" }, fetchConfig);
+    return this;
+  }
+
   onEventVoteEvent(
     func: (
       event: aptos_governance.VoteEventInstance,
@@ -17017,129 +17017,121 @@ export class multisig_account extends AptosBaseProcessor {
     return this;
   }
 
-  onEventCreateTransaction(
+  onEventAddOwnersEvent(
     func: (
-      event: multisig_account.CreateTransactionInstance,
+      event: multisig_account.AddOwnersEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::CreateTransaction" },
+      { type: "multisig_account::AddOwnersEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventExecuteRejectedTransaction(
+  onEventCreateTransaction(
     func: (
-      event: multisig_account.ExecuteRejectedTransactionInstance,
+      event: multisig_account.CreateTransactionInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::ExecuteRejectedTransaction" },
+      { type: "multisig_account::CreateTransaction" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventMetadataUpdated(
+  onEventCreateTransactionEvent(
     func: (
-      event: multisig_account.MetadataUpdatedInstance,
+      event: multisig_account.CreateTransactionEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::MetadataUpdated" },
+      { type: "multisig_account::CreateTransactionEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventRemoveOwners(
+  onEventExecuteRejectedTransaction(
     func: (
-      event: multisig_account.RemoveOwnersInstance,
+      event: multisig_account.ExecuteRejectedTransactionInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::RemoveOwners" },
+      { type: "multisig_account::ExecuteRejectedTransaction" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventTransactionExecutionFailed(
+  onEventExecuteRejectedTransactionEvent(
     func: (
-      event: multisig_account.TransactionExecutionFailedInstance,
+      event: multisig_account.ExecuteRejectedTransactionEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::TransactionExecutionFailed" },
+      { type: "multisig_account::ExecuteRejectedTransactionEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventTransactionExecutionSucceeded(
+  onEventMetadataUpdated(
     func: (
-      event: multisig_account.TransactionExecutionSucceededInstance,
+      event: multisig_account.MetadataUpdatedInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::TransactionExecutionSucceeded" },
+      { type: "multisig_account::MetadataUpdated" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventUpdateSignaturesRequired(
+  onEventMetadataUpdatedEvent(
     func: (
-      event: multisig_account.UpdateSignaturesRequiredInstance,
+      event: multisig_account.MetadataUpdatedEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::UpdateSignaturesRequired" },
+      { type: "multisig_account::MetadataUpdatedEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventVote(
-    func: (event: multisig_account.VoteInstance, ctx: AptosContext) => void,
-    fetchConfig?: Partial<MoveFetchConfig>,
-  ): multisig_account {
-    this.onMoveEvent(func, { type: "multisig_account::Vote" }, fetchConfig);
-    return this;
-  }
-
-  onEventAddOwnersEvent(
+  onEventRemoveOwners(
     func: (
-      event: multisig_account.AddOwnersEventInstance,
+      event: multisig_account.RemoveOwnersInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::AddOwnersEvent" },
+      { type: "multisig_account::RemoveOwners" },
       fetchConfig,
     );
     return this;
@@ -17160,106 +17152,114 @@ export class multisig_account extends AptosBaseProcessor {
     return this;
   }
 
-  onEventUpdateSignaturesRequiredEvent(
+  onEventTransactionExecutionFailed(
     func: (
-      event: multisig_account.UpdateSignaturesRequiredEventInstance,
+      event: multisig_account.TransactionExecutionFailedInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::UpdateSignaturesRequiredEvent" },
+      { type: "multisig_account::TransactionExecutionFailed" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventCreateTransactionEvent(
+  onEventTransactionExecutionFailedEvent(
     func: (
-      event: multisig_account.CreateTransactionEventInstance,
+      event: multisig_account.TransactionExecutionFailedEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::CreateTransactionEvent" },
+      { type: "multisig_account::TransactionExecutionFailedEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventVoteEvent(
+  onEventTransactionExecutionSucceeded(
     func: (
-      event: multisig_account.VoteEventInstance,
+      event: multisig_account.TransactionExecutionSucceededInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::VoteEvent" },
+      { type: "multisig_account::TransactionExecutionSucceeded" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventExecuteRejectedTransactionEvent(
+  onEventTransactionExecutionSucceededEvent(
     func: (
-      event: multisig_account.ExecuteRejectedTransactionEventInstance,
+      event: multisig_account.TransactionExecutionSucceededEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::ExecuteRejectedTransactionEvent" },
+      { type: "multisig_account::TransactionExecutionSucceededEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventTransactionExecutionSucceededEvent(
+  onEventUpdateSignaturesRequired(
     func: (
-      event: multisig_account.TransactionExecutionSucceededEventInstance,
+      event: multisig_account.UpdateSignaturesRequiredInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::TransactionExecutionSucceededEvent" },
+      { type: "multisig_account::UpdateSignaturesRequired" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventTransactionExecutionFailedEvent(
+  onEventUpdateSignaturesRequiredEvent(
     func: (
-      event: multisig_account.TransactionExecutionFailedEventInstance,
+      event: multisig_account.UpdateSignaturesRequiredEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::TransactionExecutionFailedEvent" },
+      { type: "multisig_account::UpdateSignaturesRequiredEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventMetadataUpdatedEvent(
+  onEventVote(
+    func: (event: multisig_account.VoteInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): multisig_account {
+    this.onMoveEvent(func, { type: "multisig_account::Vote" }, fetchConfig);
+    return this;
+  }
+
+  onEventVoteEvent(
     func: (
-      event: multisig_account.MetadataUpdatedEventInstance,
+      event: multisig_account.VoteEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::MetadataUpdatedEvent" },
+      { type: "multisig_account::VoteEvent" },
       fetchConfig,
     );
     return this;
@@ -19479,6 +19479,21 @@ export class staking_contract extends AptosBaseProcessor {
     return this;
   }
 
+  onEventAddDistributionEvent(
+    func: (
+      event: staking_contract.AddDistributionEventInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): staking_contract {
+    this.onMoveEvent(
+      func,
+      { type: "staking_contract::AddDistributionEvent" },
+      fetchConfig,
+    );
+    return this;
+  }
+
   onEventAddStake(
     func: (event: staking_contract.AddStakeInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
@@ -19487,286 +19502,286 @@ export class staking_contract extends AptosBaseProcessor {
     return this;
   }
 
-  onEventCreateStakingContract(
+  onEventAddStakeEvent(
     func: (
-      event: staking_contract.CreateStakingContractInstance,
+      event: staking_contract.AddStakeEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::CreateStakingContract" },
+      { type: "staking_contract::AddStakeEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventDistribute(
+  onEventCreateStakingContract(
     func: (
-      event: staking_contract.DistributeInstance,
+      event: staking_contract.CreateStakingContractInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::Distribute" },
+      { type: "staking_contract::CreateStakingContract" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventRequestCommission(
+  onEventCreateStakingContractEvent(
     func: (
-      event: staking_contract.RequestCommissionInstance,
+      event: staking_contract.CreateStakingContractEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::RequestCommission" },
+      { type: "staking_contract::CreateStakingContractEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventResetLockup(
+  onEventDistribute(
     func: (
-      event: staking_contract.ResetLockupInstance,
+      event: staking_contract.DistributeInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::ResetLockup" },
+      { type: "staking_contract::Distribute" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventSetBeneficiaryForOperator(
+  onEventDistributeEvent(
     func: (
-      event: staking_contract.SetBeneficiaryForOperatorInstance,
+      event: staking_contract.DistributeEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::SetBeneficiaryForOperator" },
+      { type: "staking_contract::DistributeEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventSwitchOperator(
+  onEventRequestCommission(
     func: (
-      event: staking_contract.SwitchOperatorInstance,
+      event: staking_contract.RequestCommissionInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::SwitchOperator" },
+      { type: "staking_contract::RequestCommission" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventUnlockStake(
+  onEventRequestCommissionEvent(
     func: (
-      event: staking_contract.UnlockStakeInstance,
+      event: staking_contract.RequestCommissionEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::UnlockStake" },
+      { type: "staking_contract::RequestCommissionEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventUpdateCommission(
+  onEventResetLockup(
     func: (
-      event: staking_contract.UpdateCommissionInstance,
+      event: staking_contract.ResetLockupInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::UpdateCommission" },
+      { type: "staking_contract::ResetLockup" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventUpdateVoter(
+  onEventResetLockupEvent(
     func: (
-      event: staking_contract.UpdateVoterInstance,
+      event: staking_contract.ResetLockupEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::UpdateVoter" },
+      { type: "staking_contract::ResetLockupEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventUpdateCommissionEvent(
+  onEventSetBeneficiaryForOperator(
     func: (
-      event: staking_contract.UpdateCommissionEventInstance,
+      event: staking_contract.SetBeneficiaryForOperatorInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::UpdateCommissionEvent" },
+      { type: "staking_contract::SetBeneficiaryForOperator" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventCreateStakingContractEvent(
+  onEventStakingGroupUpdateCommissionEvent(
     func: (
-      event: staking_contract.CreateStakingContractEventInstance,
+      event: staking_contract.StakingGroupUpdateCommissionEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::CreateStakingContractEvent" },
+      { type: "staking_contract::StakingGroupUpdateCommissionEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventUpdateVoterEvent(
+  onEventSwitchOperator(
     func: (
-      event: staking_contract.UpdateVoterEventInstance,
+      event: staking_contract.SwitchOperatorInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::UpdateVoterEvent" },
+      { type: "staking_contract::SwitchOperator" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventResetLockupEvent(
+  onEventSwitchOperatorEvent(
     func: (
-      event: staking_contract.ResetLockupEventInstance,
+      event: staking_contract.SwitchOperatorEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::ResetLockupEvent" },
+      { type: "staking_contract::SwitchOperatorEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventAddStakeEvent(
+  onEventUnlockStake(
     func: (
-      event: staking_contract.AddStakeEventInstance,
+      event: staking_contract.UnlockStakeInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::AddStakeEvent" },
+      { type: "staking_contract::UnlockStake" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventRequestCommissionEvent(
+  onEventUnlockStakeEvent(
     func: (
-      event: staking_contract.RequestCommissionEventInstance,
+      event: staking_contract.UnlockStakeEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::RequestCommissionEvent" },
+      { type: "staking_contract::UnlockStakeEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventUnlockStakeEvent(
+  onEventUpdateCommission(
     func: (
-      event: staking_contract.UnlockStakeEventInstance,
+      event: staking_contract.UpdateCommissionInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::UnlockStakeEvent" },
+      { type: "staking_contract::UpdateCommission" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventSwitchOperatorEvent(
+  onEventUpdateCommissionEvent(
     func: (
-      event: staking_contract.SwitchOperatorEventInstance,
+      event: staking_contract.UpdateCommissionEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::SwitchOperatorEvent" },
+      { type: "staking_contract::UpdateCommissionEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventAddDistributionEvent(
+  onEventUpdateVoter(
     func: (
-      event: staking_contract.AddDistributionEventInstance,
+      event: staking_contract.UpdateVoterInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::AddDistributionEvent" },
+      { type: "staking_contract::UpdateVoter" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventDistributeEvent(
+  onEventUpdateVoterEvent(
     func: (
-      event: staking_contract.DistributeEventInstance,
+      event: staking_contract.UpdateVoterEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::DistributeEvent" },
+      { type: "staking_contract::UpdateVoterEvent" },
       fetchConfig,
     );
     return this;
@@ -20153,6 +20168,12 @@ export namespace staking_contract {
     }
   }
 
+  export interface StakingGroupUpdateCommissionEventInstance
+    extends TypedEventInstance<StakingGroupUpdateCommissionEvent> {
+    data_decoded: StakingGroupUpdateCommissionEvent;
+    type_arguments: [];
+  }
+
   export interface Store {
     staking_contracts: simple_map.SimpleMap<
       MoveAddressType,