@sentio/sdk 2.26.1-rc.1 → 2.26.1-rc.3

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

@@ -20,6 +20,28 @@ import {
   AptosContext,
 } from "@sentio/sdk/aptos";
 
+export class acl extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("acl", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): acl {
+    return new acl({ ...acl.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventACL(
+    func: (event: acl.ACLInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): acl {
+    this.onMoveEvent(func, { type: "acl::ACL" }, fetchConfig);
+    return this;
+  }
+}
+
 export namespace acl {
   export interface ACL {
     list: Address[];
@@ -34,6 +56,33 @@ export namespace acl {
       return TYPE.apply();
     }
   }
+
+  export interface ACLInstance extends TypedEventInstance<ACL> {
+    data_decoded: ACL;
+    type_arguments: [];
+  }
+}
+
+export class any_ extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("any", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): any_ {
+    return new any_({ ...any_.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventAny(
+    func: (event: any_.AnyInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): any_ {
+    this.onMoveEvent(func, { type: "any::Any" }, fetchConfig);
+    return this;
+  }
 }
 
 export namespace any_ {
@@ -51,6 +100,11 @@ export namespace any_ {
       return TYPE.apply();
     }
   }
+
+  export interface AnyInstance extends TypedEventInstance<Any> {
+    data_decoded: Any;
+    type_arguments: [];
+  }
 }
 
 export namespace bcs {}
@@ -83,6 +137,46 @@ export class code extends AptosBaseProcessor {
     );
     return this;
   }
+
+  onEventModuleMetadata(
+    func: (event: code.ModuleMetadataInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): code {
+    this.onMoveEvent(func, { type: "code::ModuleMetadata" }, fetchConfig);
+    return this;
+  }
+
+  onEventPackageDep(
+    func: (event: code.PackageDepInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): code {
+    this.onMoveEvent(func, { type: "code::PackageDep" }, fetchConfig);
+    return this;
+  }
+
+  onEventPackageMetadata(
+    func: (event: code.PackageMetadataInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): code {
+    this.onMoveEvent(func, { type: "code::PackageMetadata" }, fetchConfig);
+    return this;
+  }
+
+  onEventPackageRegistry(
+    func: (event: code.PackageRegistryInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): code {
+    this.onMoveEvent(func, { type: "code::PackageRegistry" }, fetchConfig);
+    return this;
+  }
+
+  onEventUpgradePolicy(
+    func: (event: code.UpgradePolicyInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): code {
+    this.onMoveEvent(func, { type: "code::UpgradePolicy" }, fetchConfig);
+    return this;
+  }
 }
 
 export namespace code {
@@ -118,6 +212,12 @@ export namespace code {
     }
   }
 
+  export interface ModuleMetadataInstance
+    extends TypedEventInstance<ModuleMetadata> {
+    data_decoded: ModuleMetadata;
+    type_arguments: [];
+  }
+
   export interface PackageDep {
     account: Address;
     package_name: string;
@@ -133,6 +233,11 @@ export namespace code {
     }
   }
 
+  export interface PackageDepInstance extends TypedEventInstance<PackageDep> {
+    data_decoded: PackageDep;
+    type_arguments: [];
+  }
+
   export interface PackageMetadata {
     name: string;
     upgrade_policy: code.UpgradePolicy;
@@ -156,6 +261,12 @@ export namespace code {
     }
   }
 
+  export interface PackageMetadataInstance
+    extends TypedEventInstance<PackageMetadata> {
+    data_decoded: PackageMetadata;
+    type_arguments: [];
+  }
+
   export interface PackageRegistry {
     packages: code.PackageMetadata[];
   }
@@ -172,6 +283,12 @@ export namespace code {
     }
   }
 
+  export interface PackageRegistryInstance
+    extends TypedEventInstance<PackageRegistry> {
+    data_decoded: PackageRegistry;
+    type_arguments: [];
+  }
+
   export interface UpgradePolicy {
     policy: number;
   }
@@ -186,6 +303,12 @@ export namespace code {
     }
   }
 
+  export interface UpgradePolicyInstance
+    extends TypedEventInstance<UpgradePolicy> {
+    data_decoded: UpgradePolicy;
+    type_arguments: [];
+  }
+
   export interface PublishPackageTxnPayload
     extends TypedFunctionPayload<[string, string[]]> {
     arguments_decoded: [string, string[]];
@@ -493,6 +616,36 @@ export namespace coin {
   }
 }
 
+export class guid extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("guid", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): guid {
+    return new guid({ ...guid.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventGUID(
+    func: (event: guid.GUIDInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): guid {
+    this.onMoveEvent(func, { type: "guid::GUID" }, fetchConfig);
+    return this;
+  }
+
+  onEventID(
+    func: (event: guid.IDInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): guid {
+    this.onMoveEvent(func, { type: "guid::ID" }, fetchConfig);
+    return this;
+  }
+}
+
 export namespace guid {
   export interface GUID {
     id: guid.ID;
@@ -508,6 +661,11 @@ export namespace guid {
     }
   }
 
+  export interface GUIDInstance extends TypedEventInstance<GUID> {
+    data_decoded: GUID;
+    type_arguments: [];
+  }
+
   export interface ID {
     creation_num: bigint;
     addr: Address;
@@ -522,6 +680,11 @@ export namespace guid {
       return TYPE.apply();
     }
   }
+
+  export interface IDInstance extends TypedEventInstance<ID> {
+    data_decoded: ID;
+    type_arguments: [];
+  }
 }
 
 export namespace hash {}
@@ -881,150 +1044,181 @@ export class stake extends AptosBaseProcessor {
     return this;
   }
 
-  onEventRegisterValidatorCandidateEvent(
+  onEventAddStakeEvent(
+    func: (event: stake.AddStakeEventInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): stake {
+    this.onMoveEvent(func, { type: "stake::AddStakeEvent" }, fetchConfig);
+    return this;
+  }
+
+  onEventDistributeRewardsEvent(
     func: (
-      event: stake.RegisterValidatorCandidateEventInstance,
+      event: stake.DistributeRewardsEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
     this.onMoveEvent(
       func,
-      { type: "stake::RegisterValidatorCandidateEvent" },
+      { type: "stake::DistributeRewardsEvent" },
       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,
+  onEventIncreaseLockupEvent(
+    func: (event: stake.IncreaseLockupEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
-    this.onMoveEvent(func, { type: "stake::AddStakeEvent" }, fetchConfig);
+    this.onMoveEvent(func, { type: "stake::IncreaseLockupEvent" }, fetchConfig);
     return this;
   }
 
-  onEventReactivateStakeEvent(
+  onEventIndividualValidatorPerformance(
     func: (
-      event: stake.ReactivateStakeEventInstance,
+      event: stake.IndividualValidatorPerformanceInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
     this.onMoveEvent(
       func,
-      { type: "stake::ReactivateStakeEvent" },
+      { type: "stake::IndividualValidatorPerformance" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventRotateConsensusKeyEvent(
+  onEventJoinValidatorSetEvent(
     func: (
-      event: stake.RotateConsensusKeyEventInstance,
+      event: stake.JoinValidatorSetEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
     this.onMoveEvent(
       func,
-      { type: "stake::RotateConsensusKeyEvent" },
+      { type: "stake::JoinValidatorSetEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventUpdateNetworkAndFullnodeAddressesEvent(
+  onEventLeaveValidatorSetEvent(
     func: (
-      event: stake.UpdateNetworkAndFullnodeAddressesEventInstance,
+      event: stake.LeaveValidatorSetEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
     this.onMoveEvent(
       func,
-      { type: "stake::UpdateNetworkAndFullnodeAddressesEvent" },
+      { type: "stake::LeaveValidatorSetEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventIncreaseLockupEvent(
-    func: (event: stake.IncreaseLockupEventInstance, ctx: AptosContext) => void,
+  onEventReactivateStakeEvent(
+    func: (
+      event: stake.ReactivateStakeEventInstance,
+      ctx: AptosContext,
+    ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
-    this.onMoveEvent(func, { type: "stake::IncreaseLockupEvent" }, fetchConfig);
+    this.onMoveEvent(
+      func,
+      { type: "stake::ReactivateStakeEvent" },
+      fetchConfig,
+    );
     return this;
   }
 
-  onEventJoinValidatorSetEvent(
+  onEventRegisterValidatorCandidateEvent(
     func: (
-      event: stake.JoinValidatorSetEventInstance,
+      event: stake.RegisterValidatorCandidateEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
     this.onMoveEvent(
       func,
-      { type: "stake::JoinValidatorSetEvent" },
+      { type: "stake::RegisterValidatorCandidateEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventDistributeRewardsEvent(
+  onEventRotateConsensusKeyEvent(
     func: (
-      event: stake.DistributeRewardsEventInstance,
+      event: stake.RotateConsensusKeyEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
     this.onMoveEvent(
       func,
-      { type: "stake::DistributeRewardsEvent" },
+      { type: "stake::RotateConsensusKeyEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventUnlockStakeEvent(
-    func: (event: stake.UnlockStakeEventInstance, ctx: AptosContext) => void,
+  onEventSetOperatorEvent(
+    func: (event: stake.SetOperatorEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
-    this.onMoveEvent(func, { type: "stake::UnlockStakeEvent" }, fetchConfig);
+    this.onMoveEvent(func, { type: "stake::SetOperatorEvent" }, fetchConfig);
     return this;
   }
 
-  onEventWithdrawStakeEvent(
-    func: (event: stake.WithdrawStakeEventInstance, ctx: AptosContext) => void,
+  onEventUnlockStakeEvent(
+    func: (event: stake.UnlockStakeEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): stake {
-    this.onMoveEvent(func, { type: "stake::WithdrawStakeEvent" }, fetchConfig);
+    this.onMoveEvent(func, { type: "stake::UnlockStakeEvent" }, 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;
   }
+
+  onEventValidatorConfig(
+    func: (event: stake.ValidatorConfigInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): stake {
+    this.onMoveEvent(func, { type: "stake::ValidatorConfig" }, fetchConfig);
+    return this;
+  }
+
+  onEventValidatorInfo(
+    func: (event: stake.ValidatorInfoInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): stake {
+    this.onMoveEvent(func, { type: "stake::ValidatorInfo" }, 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 {
@@ -1145,6 +1339,12 @@ export namespace stake {
     }
   }
 
+  export interface IndividualValidatorPerformanceInstance
+    extends TypedEventInstance<IndividualValidatorPerformance> {
+    data_decoded: IndividualValidatorPerformance;
+    type_arguments: [];
+  }
+
   export interface JoinValidatorSetEvent {
     pool_address: Address;
   }
@@ -1399,6 +1599,12 @@ export namespace stake {
     }
   }
 
+  export interface ValidatorConfigInstance
+    extends TypedEventInstance<ValidatorConfig> {
+    data_decoded: ValidatorConfig;
+    type_arguments: [];
+  }
+
   export interface ValidatorFees {
     fees_table: table.Table<Address, coin.Coin<aptos_coin.AptosCoin>>;
   }
@@ -1429,6 +1635,12 @@ export namespace stake {
     }
   }
 
+  export interface ValidatorInfoInstance
+    extends TypedEventInstance<ValidatorInfo> {
+    data_decoded: ValidatorInfo;
+    type_arguments: [];
+  }
+
   export interface ValidatorPerformance {
     validators: stake.IndividualValidatorPerformance[];
   }
@@ -1561,6 +1773,28 @@ export namespace stake {
   }
 }
 
+export class table extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("table", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): table {
+    return new table({ ...table.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventBox(
+    func: (event: table.BoxInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): table {
+    this.onMoveEvent(func, { type: "table::Box" }, fetchConfig);
+    return this;
+  }
+}
+
 export namespace table {
   export interface Box<T0> {
     val: T0;
@@ -1578,6 +1812,11 @@ export namespace table {
     }
   }
 
+  export interface BoxInstance extends TypedEventInstance<Box<any>> {
+    data_decoded: Box<any>;
+    type_arguments: [string];
+  }
+
   export interface Table<T0, T1> {
     handle: Address;
   }
@@ -1659,6 +1898,38 @@ export class object_ extends AptosBaseProcessor {
     return this;
   }
 
+  onEventDeleteRef(
+    func: (event: object_.DeleteRefInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): object_ {
+    this.onMoveEvent(func, { type: "object::DeleteRef" }, fetchConfig);
+    return this;
+  }
+
+  onEventDeriveRef(
+    func: (event: object_.DeriveRefInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): object_ {
+    this.onMoveEvent(func, { type: "object::DeriveRef" }, fetchConfig);
+    return this;
+  }
+
+  onEventExtendRef(
+    func: (event: object_.ExtendRefInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): object_ {
+    this.onMoveEvent(func, { type: "object::ExtendRef" }, fetchConfig);
+    return this;
+  }
+
+  onEventObject(
+    func: (event: object_.ObjectInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): object_ {
+    this.onMoveEvent(func, { type: "object::Object" }, fetchConfig);
+    return this;
+  }
+
   onEventTransferEvent(
     func: (event: object_.TransferEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
@@ -1666,6 +1937,14 @@ export class object_ extends AptosBaseProcessor {
     this.onMoveEvent(func, { type: "object::TransferEvent" }, fetchConfig);
     return this;
   }
+
+  onEventTransferRef(
+    func: (event: object_.TransferRefInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): object_ {
+    this.onMoveEvent(func, { type: "object::TransferRef" }, fetchConfig);
+    return this;
+  }
 }
 
 export namespace object_ {
@@ -1698,6 +1977,11 @@ export namespace object_ {
     }
   }
 
+  export interface DeleteRefInstance extends TypedEventInstance<DeleteRef> {
+    data_decoded: DeleteRef;
+    type_arguments: [];
+  }
+
   export interface DeriveRef {
     self: Address;
   }
@@ -1712,6 +1996,11 @@ export namespace object_ {
     }
   }
 
+  export interface DeriveRefInstance extends TypedEventInstance<DeriveRef> {
+    data_decoded: DeriveRef;
+    type_arguments: [];
+  }
+
   export interface ExtendRef {
     self: Address;
   }
@@ -1726,6 +2015,11 @@ export namespace object_ {
     }
   }
 
+  export interface ExtendRefInstance extends TypedEventInstance<ExtendRef> {
+    data_decoded: ExtendRef;
+    type_arguments: [];
+  }
+
   export interface LinearTransferRef {
     self: Address;
     owner: Address;
@@ -1759,6 +2053,11 @@ export namespace object_ {
     }
   }
 
+  export interface ObjectInstance extends TypedEventInstance<Object<any>> {
+    data_decoded: Object<any>;
+    type_arguments: [string];
+  }
+
   export interface ObjectCore {
     guid_creation_num: bigint;
     owner: Address;
@@ -1826,6 +2125,11 @@ export namespace object_ {
     }
   }
 
+  export interface TransferRefInstance extends TypedEventInstance<TransferRef> {
+    data_decoded: TransferRef;
+    type_arguments: [];
+  }
+
   export interface TransferPayload<T0 = any>
     extends TypedFunctionPayload<[object_.Object<T0>, Address]> {
     arguments_decoded: [object_.Object<T0>, Address];
@@ -1845,6 +2149,28 @@ export namespace object_ {
   }
 }
 
+export class option extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("option", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): option {
+    return new option({ ...option.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventOption(
+    func: (event: option.OptionInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): option {
+    this.onMoveEvent(func, { type: "option::Option" }, fetchConfig);
+    return this;
+  }
+}
+
 export namespace option {
   export interface Option<T0> {
     vec: T0[] | string;
@@ -1861,10 +2187,37 @@ export namespace option {
       return TYPE.apply(arg0);
     }
   }
+
+  export interface OptionInstance extends TypedEventInstance<Option<any>> {
+    data_decoded: Option<any>;
+    type_arguments: [string];
+  }
 }
 
 export namespace signer {}
 
+export class string_ extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("string", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): string_ {
+    return new string_({ ...string_.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventString(
+    func: (event: string_.StringInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): string_ {
+    this.onMoveEvent(func, { type: "string::String" }, fetchConfig);
+    return this;
+  }
+}
+
 export namespace string_ {
   export interface String {
     bytes: string;
@@ -1879,6 +2232,11 @@ export namespace string_ {
       return TYPE.apply();
     }
   }
+
+  export interface StringInstance extends TypedEventInstance<String> {
+    data_decoded: String;
+    type_arguments: [];
+  }
 }
 
 export namespace vector {}
@@ -2275,6 +2633,29 @@ export class account extends AptosBaseProcessor {
     this.onMoveEvent(func, { type: "account::KeyRotationEvent" }, fetchConfig);
     return this;
   }
+
+  onEventRotationCapability(
+    func: (
+      event: account.RotationCapabilityInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): account {
+    this.onMoveEvent(
+      func,
+      { type: "account::RotationCapability" },
+      fetchConfig,
+    );
+    return this;
+  }
+
+  onEventSignerCapability(
+    func: (event: account.SignerCapabilityInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): account {
+    this.onMoveEvent(func, { type: "account::SignerCapability" }, fetchConfig);
+    return this;
+  }
 }
 
 export namespace account {
@@ -2393,6 +2774,12 @@ export namespace account {
     }
   }
 
+  export interface RotationCapabilityInstance
+    extends TypedEventInstance<RotationCapability> {
+    data_decoded: RotationCapability;
+    type_arguments: [];
+  }
+
   export interface RotationCapabilityOfferProofChallenge {
     sequence_number: bigint;
     recipient_address: Address;
@@ -2466,6 +2853,12 @@ export namespace account {
     }
   }
 
+  export interface SignerCapabilityInstance
+    extends TypedEventInstance<SignerCapability> {
+    data_decoded: SignerCapability;
+    type_arguments: [];
+  }
+
   export interface SignerCapabilityOfferProofChallenge {
     sequence_number: bigint;
     recipient_address: Address;
@@ -2554,6 +2947,58 @@ export namespace account {
   }
 }
 
+export class ed25519 extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("ed25519", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): ed25519 {
+    return new ed25519({ ...ed25519.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventSignature(
+    func: (event: ed25519.SignatureInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): ed25519 {
+    this.onMoveEvent(func, { type: "ed25519::Signature" }, fetchConfig);
+    return this;
+  }
+
+  onEventUnvalidatedPublicKey(
+    func: (
+      event: ed25519.UnvalidatedPublicKeyInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): ed25519 {
+    this.onMoveEvent(
+      func,
+      { type: "ed25519::UnvalidatedPublicKey" },
+      fetchConfig,
+    );
+    return this;
+  }
+
+  onEventValidatedPublicKey(
+    func: (
+      event: ed25519.ValidatedPublicKeyInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): ed25519 {
+    this.onMoveEvent(
+      func,
+      { type: "ed25519::ValidatedPublicKey" },
+      fetchConfig,
+    );
+    return this;
+  }
+}
+
 export namespace ed25519 {
   export interface Signature {
     bytes: string;
@@ -2569,6 +3014,11 @@ export namespace ed25519 {
     }
   }
 
+  export interface SignatureInstance extends TypedEventInstance<Signature> {
+    data_decoded: Signature;
+    type_arguments: [];
+  }
+
   export interface SignedMessage<T0> {
     type_info: type_info.TypeInfo;
     inner: T0;
@@ -2604,6 +3054,12 @@ export namespace ed25519 {
     }
   }
 
+  export interface UnvalidatedPublicKeyInstance
+    extends TypedEventInstance<UnvalidatedPublicKey> {
+    data_decoded: UnvalidatedPublicKey;
+    type_arguments: [];
+  }
+
   export interface ValidatedPublicKey {
     bytes: string;
   }
@@ -2619,6 +3075,12 @@ export namespace ed25519 {
       return TYPE.apply();
     }
   }
+
+  export interface ValidatedPublicKeyInstance
+    extends TypedEventInstance<ValidatedPublicKey> {
+    data_decoded: ValidatedPublicKey;
+    type_arguments: [];
+  }
 }
 
 export namespace genesis {
@@ -3047,41 +3509,41 @@ export class vesting extends AptosBaseProcessor {
     return this;
   }
 
-  onEventCreateVestingContractEvent(
+  onEventAdminWithdrawEvent(
     func: (
-      event: vesting.CreateVestingContractEventInstance,
+      event: vesting.AdminWithdrawEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
     this.onMoveEvent(
       func,
-      { type: "vesting::CreateVestingContractEvent" },
+      { type: "vesting::AdminWithdrawEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventUpdateOperatorEvent(
+  onEventCreateVestingContractEvent(
     func: (
-      event: vesting.UpdateOperatorEventInstance,
+      event: vesting.CreateVestingContractEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
     this.onMoveEvent(
       func,
-      { type: "vesting::UpdateOperatorEvent" },
+      { type: "vesting::CreateVestingContractEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventUpdateVoterEvent(
-    func: (event: vesting.UpdateVoterEventInstance, ctx: AptosContext) => void,
+  onEventDistributeEvent(
+    func: (event: vesting.DistributeEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
-    this.onMoveEvent(func, { type: "vesting::UpdateVoterEvent" }, fetchConfig);
+    this.onMoveEvent(func, { type: "vesting::DistributeEvent" }, fetchConfig);
     return this;
   }
 
@@ -3108,6 +3570,14 @@ export class vesting extends AptosBaseProcessor {
     return this;
   }
 
+  onEventTerminateEvent(
+    func: (event: vesting.TerminateEventInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): vesting {
+    this.onMoveEvent(func, { type: "vesting::TerminateEvent" }, fetchConfig);
+    return this;
+  }
+
   onEventUnlockRewardsEvent(
     func: (
       event: vesting.UnlockRewardsEventInstance,
@@ -3123,42 +3593,42 @@ export class vesting extends AptosBaseProcessor {
     return this;
   }
 
-  onEventVestEvent(
-    func: (event: vesting.VestEventInstance, ctx: AptosContext) => void,
+  onEventUpdateOperatorEvent(
+    func: (
+      event: vesting.UpdateOperatorEventInstance,
+      ctx: AptosContext,
+    ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
-    this.onMoveEvent(func, { type: "vesting::VestEvent" }, fetchConfig);
+    this.onMoveEvent(
+      func,
+      { type: "vesting::UpdateOperatorEvent" },
+      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,
+  onEventVestEvent(
+    func: (event: vesting.VestEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
-    this.onMoveEvent(func, { type: "vesting::TerminateEvent" }, fetchConfig);
+    this.onMoveEvent(func, { type: "vesting::VestEvent" }, fetchConfig);
     return this;
   }
 
-  onEventAdminWithdrawEvent(
-    func: (
-      event: vesting.AdminWithdrawEventInstance,
-      ctx: AptosContext,
-    ) => void,
+  onEventVestingSchedule(
+    func: (event: vesting.VestingScheduleInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): vesting {
-    this.onMoveEvent(
-      func,
-      { type: "vesting::AdminWithdrawEvent" },
-      fetchConfig,
-    );
+    this.onMoveEvent(func, { type: "vesting::VestingSchedule" }, fetchConfig);
     return this;
   }
 }
@@ -3514,6 +3984,12 @@ export namespace vesting {
     }
   }
 
+  export interface VestingScheduleInstance
+    extends TypedEventInstance<VestingSchedule> {
+    data_decoded: VestingSchedule;
+    type_arguments: [];
+  }
+
   export interface AdminWithdrawPayload
     extends TypedFunctionPayload<[Address]> {
     arguments_decoded: [Address];
@@ -3607,6 +4083,89 @@ export namespace vesting {
   }
 }
 
+export class bls12381 extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("bls12381", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): bls12381 {
+    return new bls12381({ ...bls12381.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventAggrOrMultiSignature(
+    func: (
+      event: bls12381.AggrOrMultiSignatureInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): bls12381 {
+    this.onMoveEvent(
+      func,
+      { type: "bls12381::AggrOrMultiSignature" },
+      fetchConfig,
+    );
+    return this;
+  }
+
+  onEventAggrPublicKeysWithPoP(
+    func: (
+      event: bls12381.AggrPublicKeysWithPoPInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): bls12381 {
+    this.onMoveEvent(
+      func,
+      { type: "bls12381::AggrPublicKeysWithPoP" },
+      fetchConfig,
+    );
+    return this;
+  }
+
+  onEventProofOfPossession(
+    func: (
+      event: bls12381.ProofOfPossessionInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): bls12381 {
+    this.onMoveEvent(
+      func,
+      { type: "bls12381::ProofOfPossession" },
+      fetchConfig,
+    );
+    return this;
+  }
+
+  onEventPublicKey(
+    func: (event: bls12381.PublicKeyInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): bls12381 {
+    this.onMoveEvent(func, { type: "bls12381::PublicKey" }, fetchConfig);
+    return this;
+  }
+
+  onEventPublicKeyWithPoP(
+    func: (event: bls12381.PublicKeyWithPoPInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): bls12381 {
+    this.onMoveEvent(func, { type: "bls12381::PublicKeyWithPoP" }, fetchConfig);
+    return this;
+  }
+
+  onEventSignature(
+    func: (event: bls12381.SignatureInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): bls12381 {
+    this.onMoveEvent(func, { type: "bls12381::Signature" }, fetchConfig);
+    return this;
+  }
+}
+
 export namespace bls12381 {
   export interface AggrOrMultiSignature {
     bytes: string;
@@ -3624,6 +4183,12 @@ export namespace bls12381 {
     }
   }
 
+  export interface AggrOrMultiSignatureInstance
+    extends TypedEventInstance<AggrOrMultiSignature> {
+    data_decoded: AggrOrMultiSignature;
+    type_arguments: [];
+  }
+
   export interface AggrPublicKeysWithPoP {
     bytes: string;
   }
@@ -3640,6 +4205,12 @@ export namespace bls12381 {
     }
   }
 
+  export interface AggrPublicKeysWithPoPInstance
+    extends TypedEventInstance<AggrPublicKeysWithPoP> {
+    data_decoded: AggrPublicKeysWithPoP;
+    type_arguments: [];
+  }
+
   export interface ProofOfPossession {
     bytes: string;
   }
@@ -3656,6 +4227,12 @@ export namespace bls12381 {
     }
   }
 
+  export interface ProofOfPossessionInstance
+    extends TypedEventInstance<ProofOfPossession> {
+    data_decoded: ProofOfPossession;
+    type_arguments: [];
+  }
+
   export interface PublicKey {
     bytes: string;
   }
@@ -3670,6 +4247,11 @@ export namespace bls12381 {
     }
   }
 
+  export interface PublicKeyInstance extends TypedEventInstance<PublicKey> {
+    data_decoded: PublicKey;
+    type_arguments: [];
+  }
+
   export interface PublicKeyWithPoP {
     bytes: string;
   }
@@ -3686,6 +4268,12 @@ export namespace bls12381 {
     }
   }
 
+  export interface PublicKeyWithPoPInstance
+    extends TypedEventInstance<PublicKeyWithPoP> {
+    data_decoded: PublicKeyWithPoP;
+    type_arguments: [];
+  }
+
   export interface Signature {
     bytes: string;
   }
@@ -3699,6 +4287,11 @@ export namespace bls12381 {
       return TYPE.apply();
     }
   }
+
+  export interface SignatureInstance extends TypedEventInstance<Signature> {
+    data_decoded: Signature;
+    type_arguments: [];
+  }
 }
 
 export namespace chain_id {
@@ -3756,11 +4349,48 @@ export namespace pool_u64 {
   }
 }
 
-export namespace secp256k1 {
-  export interface ECDSARawPublicKey {
-    bytes: string;
+export class secp256k1 extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("secp256k1", options);
   }
-
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): secp256k1 {
+    return new secp256k1({ ...secp256k1.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventECDSARawPublicKey(
+    func: (
+      event: secp256k1.ECDSARawPublicKeyInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): secp256k1 {
+    this.onMoveEvent(
+      func,
+      { type: "secp256k1::ECDSARawPublicKey" },
+      fetchConfig,
+    );
+    return this;
+  }
+
+  onEventECDSASignature(
+    func: (event: secp256k1.ECDSASignatureInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): secp256k1 {
+    this.onMoveEvent(func, { type: "secp256k1::ECDSASignature" }, fetchConfig);
+    return this;
+  }
+}
+
+export namespace secp256k1 {
+  export interface ECDSARawPublicKey {
+    bytes: string;
+  }
+
   export namespace ECDSARawPublicKey {
     export const TYPE_QNAME = "0x1::secp256k1::ECDSARawPublicKey";
 
@@ -3773,6 +4403,12 @@ export namespace secp256k1 {
     }
   }
 
+  export interface ECDSARawPublicKeyInstance
+    extends TypedEventInstance<ECDSARawPublicKey> {
+    data_decoded: ECDSARawPublicKey;
+    type_arguments: [];
+  }
+
   export interface ECDSASignature {
     bytes: string;
   }
@@ -3786,6 +4422,12 @@ export namespace secp256k1 {
       return TYPE.apply();
     }
   }
+
+  export interface ECDSASignatureInstance
+    extends TypedEventInstance<ECDSASignature> {
+    data_decoded: ECDSASignature;
+    type_arguments: [];
+  }
 }
 
 export namespace timestamp {
@@ -3806,6 +4448,28 @@ export namespace timestamp {
   }
 }
 
+export class type_info extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("type_info", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): type_info {
+    return new type_info({ ...type_info.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventTypeInfo(
+    func: (event: type_info.TypeInfoInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): type_info {
+    this.onMoveEvent(func, { type: "type_info::TypeInfo" }, fetchConfig);
+    return this;
+  }
+}
+
 export namespace type_info {
   export interface TypeInfo {
     account_address: Address;
@@ -3822,6 +4486,11 @@ export namespace type_info {
       return TYPE.apply();
     }
   }
+
+  export interface TypeInfoInstance extends TypedEventInstance<TypeInfo> {
+    data_decoded: TypeInfo;
+    type_arguments: [];
+  }
 }
 
 export namespace aggregator {
@@ -4008,6 +4677,28 @@ export namespace big_vector {
   }
 }
 
+export class bit_vector extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("bit_vector", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): bit_vector {
+    return new bit_vector({ ...bit_vector.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventBitVector(
+    func: (event: bit_vector.BitVectorInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): bit_vector {
+    this.onMoveEvent(func, { type: "bit_vector::BitVector" }, fetchConfig);
+    return this;
+  }
+}
+
 export namespace bit_vector {
   export interface BitVector {
     length: bigint;
@@ -4023,6 +4714,11 @@ export namespace bit_vector {
       return TYPE.apply();
     }
   }
+
+  export interface BitVectorInstance extends TypedEventInstance<BitVector> {
+    data_decoded: BitVector;
+    type_arguments: [];
+  }
 }
 
 export namespace capability {
@@ -4111,6 +4807,36 @@ export namespace comparator {
 
 export namespace math_fixed {}
 
+export class simple_map extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("simple_map", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): simple_map {
+    return new simple_map({ ...simple_map.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventElement(
+    func: (event: simple_map.ElementInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): simple_map {
+    this.onMoveEvent(func, { type: "simple_map::Element" }, fetchConfig);
+    return this;
+  }
+
+  onEventSimpleMap(
+    func: (event: simple_map.SimpleMapInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): simple_map {
+    this.onMoveEvent(func, { type: "simple_map::SimpleMap" }, fetchConfig);
+    return this;
+  }
+}
+
 export namespace simple_map {
   export interface Element<T0, T1> {
     key: T0;
@@ -4130,6 +4856,12 @@ export namespace simple_map {
     }
   }
 
+  export interface ElementInstance
+    extends TypedEventInstance<Element<any, any>> {
+    data_decoded: Element<any, any>;
+    type_arguments: [string, string];
+  }
+
   export interface SimpleMap<T0, T1> {
     data: simple_map.Element<T0, T1>[];
   }
@@ -4146,6 +4878,34 @@ export namespace simple_map {
       return TYPE.apply(arg0, arg1);
     }
   }
+
+  export interface SimpleMapInstance
+    extends TypedEventInstance<SimpleMap<any, any>> {
+    data_decoded: SimpleMap<any, any>;
+    type_arguments: [string, string];
+  }
+}
+
+export class smart_table extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("smart_table", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): smart_table {
+    return new smart_table({ ...smart_table.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventEntry(
+    func: (event: smart_table.EntryInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): smart_table {
+    this.onMoveEvent(func, { type: "smart_table::Entry" }, fetchConfig);
+    return this;
+  }
 }
 
 export namespace smart_table {
@@ -4168,6 +4928,11 @@ export namespace smart_table {
     }
   }
 
+  export interface EntryInstance extends TypedEventInstance<Entry<any, any>> {
+    data_decoded: Entry<any, any>;
+    type_arguments: [string, string];
+  }
+
   export interface SmartTable<T0, T1> {
     buckets: table_with_length.TableWithLength<
       bigint,
@@ -4196,6 +4961,51 @@ export namespace smart_table {
   }
 }
 
+export class storage_gas extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("storage_gas", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): storage_gas {
+    return new storage_gas({ ...storage_gas.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventGasCurve(
+    func: (event: storage_gas.GasCurveInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): storage_gas {
+    this.onMoveEvent(func, { type: "storage_gas::GasCurve" }, fetchConfig);
+    return this;
+  }
+
+  onEventPoint(
+    func: (event: storage_gas.PointInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): storage_gas {
+    this.onMoveEvent(func, { type: "storage_gas::Point" }, fetchConfig);
+    return this;
+  }
+
+  onEventUsageGasConfig(
+    func: (
+      event: storage_gas.UsageGasConfigInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): storage_gas {
+    this.onMoveEvent(
+      func,
+      { type: "storage_gas::UsageGasConfig" },
+      fetchConfig,
+    );
+    return this;
+  }
+}
+
 export namespace storage_gas {
   export interface GasCurve {
     min_gas: bigint;
@@ -4213,6 +5023,11 @@ export namespace storage_gas {
     }
   }
 
+  export interface GasCurveInstance extends TypedEventInstance<GasCurve> {
+    data_decoded: GasCurve;
+    type_arguments: [];
+  }
+
   export interface Point {
     x: bigint;
     y: bigint;
@@ -4228,6 +5043,11 @@ export namespace storage_gas {
     }
   }
 
+  export interface PointInstance extends TypedEventInstance<Point> {
+    data_decoded: Point;
+    type_arguments: [];
+  }
+
   export interface StorageGas {
     per_item_read: bigint;
     per_item_create: bigint;
@@ -4280,6 +5100,12 @@ export namespace storage_gas {
       return TYPE.apply();
     }
   }
+
+  export interface UsageGasConfigInstance
+    extends TypedEventInstance<UsageGasConfig> {
+    data_decoded: UsageGasConfig;
+    type_arguments: [];
+  }
 }
 
 export namespace chain_status {
@@ -4300,6 +5126,28 @@ export namespace chain_status {
   }
 }
 
+export class copyable_any extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("copyable_any", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): copyable_any {
+    return new copyable_any({ ...copyable_any.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventAny(
+    func: (event: copyable_any.AnyInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): copyable_any {
+    this.onMoveEvent(func, { type: "copyable_any::Any" }, fetchConfig);
+    return this;
+  }
+}
+
 export namespace copyable_any {
   export interface Any {
     type_name: string;
@@ -4315,6 +5163,33 @@ export namespace copyable_any {
       return TYPE.apply();
     }
   }
+
+  export interface AnyInstance extends TypedEventInstance<Any> {
+    data_decoded: Any;
+    type_arguments: [];
+  }
+}
+
+export class gas_schedule extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("gas_schedule", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): gas_schedule {
+    return new gas_schedule({ ...gas_schedule.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventGasEntry(
+    func: (event: gas_schedule.GasEntryInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): gas_schedule {
+    this.onMoveEvent(func, { type: "gas_schedule::GasEntry" }, fetchConfig);
+    return this;
+  }
 }
 
 export namespace gas_schedule {
@@ -4333,6 +5208,11 @@ export namespace gas_schedule {
     }
   }
 
+  export interface GasEntryInstance extends TypedEventInstance<GasEntry> {
+    data_decoded: GasEntry;
+    type_arguments: [];
+  }
+
   export interface GasSchedule {
     entries: gas_schedule.GasEntry[];
   }
@@ -4486,6 +5366,43 @@ export namespace managed_coin {
 
 export namespace math_fixed64 {}
 
+export class ristretto255 extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("ristretto255", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): ristretto255 {
+    return new ristretto255({ ...ristretto255.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventCompressedRistretto(
+    func: (
+      event: ristretto255.CompressedRistrettoInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): ristretto255 {
+    this.onMoveEvent(
+      func,
+      { type: "ristretto255::CompressedRistretto" },
+      fetchConfig,
+    );
+    return this;
+  }
+
+  onEventScalar(
+    func: (event: ristretto255.ScalarInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): ristretto255 {
+    this.onMoveEvent(func, { type: "ristretto255::Scalar" }, fetchConfig);
+    return this;
+  }
+}
+
 export namespace ristretto255 {
   export interface CompressedRistretto {
     data: string;
@@ -4503,6 +5420,12 @@ export namespace ristretto255 {
     }
   }
 
+  export interface CompressedRistrettoInstance
+    extends TypedEventInstance<CompressedRistretto> {
+    data_decoded: CompressedRistretto;
+    type_arguments: [];
+  }
+
   export interface RistrettoPoint {
     handle: bigint;
   }
@@ -4530,6 +5453,11 @@ export namespace ristretto255 {
       return TYPE.apply();
     }
   }
+
+  export interface ScalarInstance extends TypedEventInstance<Scalar> {
+    data_decoded: Scalar;
+    type_arguments: [];
+  }
 }
 
 export namespace smart_vector {
@@ -4553,6 +5481,44 @@ export namespace smart_vector {
   }
 }
 
+export class string_utils extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("string_utils", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): string_utils {
+    return new string_utils({ ...string_utils.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventCons(
+    func: (event: string_utils.ConsInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): string_utils {
+    this.onMoveEvent(func, { type: "string_utils::Cons" }, fetchConfig);
+    return this;
+  }
+
+  onEventFakeCons(
+    func: (event: string_utils.FakeConsInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): string_utils {
+    this.onMoveEvent(func, { type: "string_utils::FakeCons" }, fetchConfig);
+    return this;
+  }
+
+  onEventNIL(
+    func: (event: string_utils.NILInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): string_utils {
+    this.onMoveEvent(func, { type: "string_utils::NIL" }, fetchConfig);
+    return this;
+  }
+}
+
 export namespace string_utils {
   export interface Cons<T0, T1> {
     car: T0;
@@ -4572,6 +5538,11 @@ export namespace string_utils {
     }
   }
 
+  export interface ConsInstance extends TypedEventInstance<Cons<any, any>> {
+    data_decoded: Cons<any, any>;
+    type_arguments: [string, string];
+  }
+
   export interface FakeCons<T0, T1> {
     car: T0;
     cdr: T1;
@@ -4590,6 +5561,12 @@ export namespace string_utils {
     }
   }
 
+  export interface FakeConsInstance
+    extends TypedEventInstance<FakeCons<any, any>> {
+    data_decoded: FakeCons<any, any>;
+    type_arguments: [string, string];
+  }
+
   export interface NIL {
     dummy_field: Boolean;
   }
@@ -4603,6 +5580,11 @@ export namespace string_utils {
       return TYPE.apply();
     }
   }
+
+  export interface NILInstance extends TypedEventInstance<NIL> {
+    data_decoded: NIL;
+    type_arguments: [];
+  }
 }
 
 export class aptos_account extends AptosBaseProcessor {
@@ -4816,6 +5798,35 @@ export namespace aptos_account {
 
 export namespace create_signer {}
 
+export class fixed_point32 extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("fixed_point32", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): fixed_point32 {
+    return new fixed_point32({ ...fixed_point32.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventFixedPoint32(
+    func: (
+      event: fixed_point32.FixedPoint32Instance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): fixed_point32 {
+    this.onMoveEvent(
+      func,
+      { type: "fixed_point32::FixedPoint32" },
+      fetchConfig,
+    );
+    return this;
+  }
+}
+
 export namespace fixed_point32 {
   export interface FixedPoint32 {
     value: bigint;
@@ -4830,6 +5841,41 @@ export namespace fixed_point32 {
       return TYPE.apply();
     }
   }
+
+  export interface FixedPoint32Instance
+    extends TypedEventInstance<FixedPoint32> {
+    data_decoded: FixedPoint32;
+    type_arguments: [];
+  }
+}
+
+export class fixed_point64 extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("fixed_point64", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): fixed_point64 {
+    return new fixed_point64({ ...fixed_point64.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventFixedPoint64(
+    func: (
+      event: fixed_point64.FixedPoint64Instance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): fixed_point64 {
+    this.onMoveEvent(
+      func,
+      { type: "fixed_point64::FixedPoint64" },
+      fetchConfig,
+    );
+    return this;
+  }
 }
 
 export namespace fixed_point64 {
@@ -4846,6 +5892,64 @@ export namespace fixed_point64 {
       return TYPE.apply();
     }
   }
+
+  export interface FixedPoint64Instance
+    extends TypedEventInstance<FixedPoint64> {
+    data_decoded: FixedPoint64;
+    type_arguments: [];
+  }
+}
+
+export class multi_ed25519 extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("multi_ed25519", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): multi_ed25519 {
+    return new multi_ed25519({ ...multi_ed25519.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventSignature(
+    func: (event: multi_ed25519.SignatureInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): multi_ed25519 {
+    this.onMoveEvent(func, { type: "multi_ed25519::Signature" }, fetchConfig);
+    return this;
+  }
+
+  onEventUnvalidatedPublicKey(
+    func: (
+      event: multi_ed25519.UnvalidatedPublicKeyInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): multi_ed25519 {
+    this.onMoveEvent(
+      func,
+      { type: "multi_ed25519::UnvalidatedPublicKey" },
+      fetchConfig,
+    );
+    return this;
+  }
+
+  onEventValidatedPublicKey(
+    func: (
+      event: multi_ed25519.ValidatedPublicKeyInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): multi_ed25519 {
+    this.onMoveEvent(
+      func,
+      { type: "multi_ed25519::ValidatedPublicKey" },
+      fetchConfig,
+    );
+    return this;
+  }
 }
 
 export namespace multi_ed25519 {
@@ -4863,6 +5967,11 @@ export namespace multi_ed25519 {
     }
   }
 
+  export interface SignatureInstance extends TypedEventInstance<Signature> {
+    data_decoded: Signature;
+    type_arguments: [];
+  }
+
   export interface UnvalidatedPublicKey {
     bytes: string;
   }
@@ -4879,6 +5988,12 @@ export namespace multi_ed25519 {
     }
   }
 
+  export interface UnvalidatedPublicKeyInstance
+    extends TypedEventInstance<UnvalidatedPublicKey> {
+    data_decoded: UnvalidatedPublicKey;
+    type_arguments: [];
+  }
+
   export interface ValidatedPublicKey {
     bytes: string;
   }
@@ -4894,6 +6009,12 @@ export namespace multi_ed25519 {
       return TYPE.apply();
     }
   }
+
+  export interface ValidatedPublicKeyInstance
+    extends TypedEventInstance<ValidatedPublicKey> {
+    data_decoded: ValidatedPublicKey;
+    type_arguments: [];
+  }
 }
 
 export class staking_proxy extends AptosBaseProcessor {
@@ -5106,6 +6227,28 @@ export namespace staking_proxy {
   }
 }
 
+export class state_storage extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("state_storage", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): state_storage {
+    return new state_storage({ ...state_storage.DEFAULT_OPTIONS, ...options });
+  }
+
+  onEventUsage(
+    func: (event: state_storage.UsageInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): state_storage {
+    this.onMoveEvent(func, { type: "state_storage::Usage" }, fetchConfig);
+    return this;
+  }
+}
+
 export namespace state_storage {
   export interface GasParameter {
     usage: state_storage.Usage;
@@ -5152,6 +6295,11 @@ export namespace state_storage {
       return TYPE.apply();
     }
   }
+
+  export interface UsageInstance extends TypedEventInstance<Usage> {
+    data_decoded: Usage;
+    type_arguments: [];
+  }
 }
 
 export namespace crypto_algebra {
@@ -5204,6 +6352,14 @@ export class fungible_asset extends AptosBaseProcessor {
     return this;
   }
 
+  onEventBurnRef(
+    func: (event: fungible_asset.BurnRefInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): fungible_asset {
+    this.onMoveEvent(func, { type: "fungible_asset::BurnRef" }, fetchConfig);
+    return this;
+  }
+
   onEventDepositEvent(
     func: (
       event: fungible_asset.DepositEventInstance,
@@ -5219,31 +6375,54 @@ export class fungible_asset extends AptosBaseProcessor {
     return this;
   }
 
-  onEventWithdrawEvent(
+  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(
+  onEventMintRef(
+    func: (event: fungible_asset.MintRefInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): fungible_asset {
+    this.onMoveEvent(func, { type: "fungible_asset::MintRef" }, fetchConfig);
+    return this;
+  }
+
+  onEventTransferRef(
     func: (
-      event: fungible_asset.FrozenEventInstance,
+      event: fungible_asset.TransferRefInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): fungible_asset {
     this.onMoveEvent(
       func,
-      { type: "fungible_asset::FrozenEvent" },
+      { type: "fungible_asset::TransferRef" },
+      fetchConfig,
+    );
+    return this;
+  }
+
+  onEventWithdrawEvent(
+    func: (
+      event: fungible_asset.WithdrawEventInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): fungible_asset {
+    this.onMoveEvent(
+      func,
+      { type: "fungible_asset::WithdrawEvent" },
       fetchConfig,
     );
     return this;
@@ -5265,6 +6444,11 @@ export namespace fungible_asset {
     }
   }
 
+  export interface BurnRefInstance extends TypedEventInstance<BurnRef> {
+    data_decoded: BurnRef;
+    type_arguments: [];
+  }
+
   export interface DepositEvent {
     amount: bigint;
   }
@@ -5385,6 +6569,11 @@ export namespace fungible_asset {
     }
   }
 
+  export interface MintRefInstance extends TypedEventInstance<MintRef> {
+    data_decoded: MintRef;
+    type_arguments: [];
+  }
+
   export interface Supply {
     current: bigint;
     maximum: option.Option<bigint>;
@@ -5414,6 +6603,11 @@ export namespace fungible_asset {
     }
   }
 
+  export interface TransferRefInstance extends TypedEventInstance<TransferRef> {
+    data_decoded: TransferRef;
+    type_arguments: [];
+  }
+
   export interface WithdrawEvent {
     amount: bigint;
   }
@@ -5687,103 +6881,163 @@ export class delegation_pool extends AptosBaseProcessor {
     filter?: CallFilter,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): delegation_pool {
-    this.onEntryFunctionCall(
+    this.onEntryFunctionCall(
+      func,
+      {
+        ...filter,
+        function: "delegation_pool::vote",
+      },
+      fetchConfig,
+    );
+    return this;
+  }
+
+  onEntryWithdraw(
+    func: (call: delegation_pool.WithdrawPayload, ctx: AptosContext) => void,
+    filter?: CallFilter,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): delegation_pool {
+    this.onEntryFunctionCall(
+      func,
+      {
+        ...filter,
+        function: "delegation_pool::withdraw",
+      },
+      fetchConfig,
+    );
+    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;
+  }
+
+  onEventCreateProposalEvent(
+    func: (
+      event: delegation_pool.CreateProposalEventInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): delegation_pool {
+    this.onMoveEvent(
+      func,
+      { type: "delegation_pool::CreateProposalEvent" },
+      fetchConfig,
+    );
+    return this;
+  }
+
+  onEventDelegateVotingPowerEvent(
+    func: (
+      event: delegation_pool.DelegateVotingPowerEventInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): delegation_pool {
+    this.onMoveEvent(
       func,
-      {
-        ...filter,
-        function: "delegation_pool::vote",
-      },
+      { type: "delegation_pool::DelegateVotingPowerEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEntryWithdraw(
-    func: (call: delegation_pool.WithdrawPayload, ctx: AptosContext) => void,
-    filter?: CallFilter,
+  onEventDelegatedVotes(
+    func: (
+      event: delegation_pool.DelegatedVotesInstance,
+      ctx: AptosContext,
+    ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): delegation_pool {
-    this.onEntryFunctionCall(
+    this.onMoveEvent(
       func,
-      {
-        ...filter,
-        function: "delegation_pool::withdraw",
-      },
+      { type: "delegation_pool::DelegatedVotes" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventAddStakeEvent(
+  onEventDistributeCommissionEvent(
     func: (
-      event: delegation_pool.AddStakeEventInstance,
+      event: delegation_pool.DistributeCommissionEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): delegation_pool {
     this.onMoveEvent(
       func,
-      { type: "delegation_pool::AddStakeEvent" },
+      { type: "delegation_pool::DistributeCommissionEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventReactivateStakeEvent(
+  onEventObservedLockupCycle(
     func: (
-      event: delegation_pool.ReactivateStakeEventInstance,
+      event: delegation_pool.ObservedLockupCycleInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): delegation_pool {
     this.onMoveEvent(
       func,
-      { type: "delegation_pool::ReactivateStakeEvent" },
+      { type: "delegation_pool::ObservedLockupCycle" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventUnlockStakeEvent(
+  onEventReactivateStakeEvent(
     func: (
-      event: delegation_pool.UnlockStakeEventInstance,
+      event: delegation_pool.ReactivateStakeEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): delegation_pool {
     this.onMoveEvent(
       func,
-      { type: "delegation_pool::UnlockStakeEvent" },
+      { type: "delegation_pool::ReactivateStakeEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventWithdrawStakeEvent(
+  onEventUnlockStakeEvent(
     func: (
-      event: delegation_pool.WithdrawStakeEventInstance,
+      event: delegation_pool.UnlockStakeEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): delegation_pool {
     this.onMoveEvent(
       func,
-      { type: "delegation_pool::WithdrawStakeEvent" },
+      { type: "delegation_pool::UnlockStakeEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventDistributeCommissionEvent(
+  onEventVoteDelegation(
     func: (
-      event: delegation_pool.DistributeCommissionEventInstance,
+      event: delegation_pool.VoteDelegationInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): delegation_pool {
     this.onMoveEvent(
       func,
-      { type: "delegation_pool::DistributeCommissionEvent" },
+      { type: "delegation_pool::VoteDelegation" },
       fetchConfig,
     );
     return this;
@@ -5797,31 +7051,31 @@ export class delegation_pool extends AptosBaseProcessor {
     return this;
   }
 
-  onEventCreateProposalEvent(
+  onEventVotingRecordKey(
     func: (
-      event: delegation_pool.CreateProposalEventInstance,
+      event: delegation_pool.VotingRecordKeyInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): delegation_pool {
     this.onMoveEvent(
       func,
-      { type: "delegation_pool::CreateProposalEvent" },
+      { type: "delegation_pool::VotingRecordKey" },
       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;
@@ -5917,6 +7171,12 @@ export namespace delegation_pool {
     }
   }
 
+  export interface DelegatedVotesInstance
+    extends TypedEventInstance<DelegatedVotes> {
+    data_decoded: DelegatedVotes;
+    type_arguments: [];
+  }
+
   export interface DelegationPool {
     active_shares: pool_u64_unbound.Pool;
     observed_lockup_cycle: delegation_pool.ObservedLockupCycle;
@@ -6033,6 +7293,12 @@ export namespace delegation_pool {
     }
   }
 
+  export interface ObservedLockupCycleInstance
+    extends TypedEventInstance<ObservedLockupCycle> {
+    data_decoded: ObservedLockupCycle;
+    type_arguments: [];
+  }
+
   export interface ReactivateStakeEvent {
     pool_address: Address;
     delegator_address: Address;
@@ -6097,6 +7363,12 @@ export namespace delegation_pool {
     }
   }
 
+  export interface VoteDelegationInstance
+    extends TypedEventInstance<VoteDelegation> {
+    data_decoded: VoteDelegation;
+    type_arguments: [];
+  }
+
   export interface VoteEvent {
     voter: Address;
     proposal_id: bigint;
@@ -6137,6 +7409,12 @@ export namespace delegation_pool {
     }
   }
 
+  export interface VotingRecordKeyInstance
+    extends TypedEventInstance<VotingRecordKey> {
+    data_decoded: VotingRecordKey;
+    type_arguments: [];
+  }
+
   export interface WithdrawStakeEvent {
     pool_address: Address;
     delegator_address: Address;
@@ -6478,6 +7756,21 @@ export class aptos_governance extends AptosBaseProcessor {
     return this;
   }
 
+  onEventRecordKey(
+    func: (
+      event: aptos_governance.RecordKeyInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): aptos_governance {
+    this.onMoveEvent(
+      func,
+      { type: "aptos_governance::RecordKey" },
+      fetchConfig,
+    );
+    return this;
+  }
+
   onEventUpdateConfigEvent(
     func: (
       event: aptos_governance.UpdateConfigEventInstance,
@@ -6619,6 +7912,11 @@ export namespace aptos_governance {
     }
   }
 
+  export interface RecordKeyInstance extends TypedEventInstance<RecordKey> {
+    data_decoded: RecordKey;
+    type_arguments: [];
+  }
+
   export interface UpdateConfigEvent {
     min_voting_threshold: bigint;
     required_proposer_stake: bigint;
@@ -7403,91 +8701,91 @@ export class multisig_account extends AptosBaseProcessor {
     return this;
   }
 
-  onEventRemoveOwnersEvent(
+  onEventCreateTransactionEvent(
     func: (
-      event: multisig_account.RemoveOwnersEventInstance,
+      event: multisig_account.CreateTransactionEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::RemoveOwnersEvent" },
+      { type: "multisig_account::CreateTransactionEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventUpdateSignaturesRequiredEvent(
+  onEventExecuteRejectedTransactionEvent(
     func: (
-      event: multisig_account.UpdateSignaturesRequiredEventInstance,
+      event: multisig_account.ExecuteRejectedTransactionEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::UpdateSignaturesRequiredEvent" },
+      { type: "multisig_account::ExecuteRejectedTransactionEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventCreateTransactionEvent(
+  onEventExecutionError(
     func: (
-      event: multisig_account.CreateTransactionEventInstance,
+      event: multisig_account.ExecutionErrorInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::CreateTransactionEvent" },
+      { type: "multisig_account::ExecutionError" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventVoteEvent(
+  onEventMetadataUpdatedEvent(
     func: (
-      event: multisig_account.VoteEventInstance,
+      event: multisig_account.MetadataUpdatedEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::VoteEvent" },
+      { type: "multisig_account::MetadataUpdatedEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventExecuteRejectedTransactionEvent(
+  onEventMultisigTransaction(
     func: (
-      event: multisig_account.ExecuteRejectedTransactionEventInstance,
+      event: multisig_account.MultisigTransactionInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::ExecuteRejectedTransactionEvent" },
+      { type: "multisig_account::MultisigTransaction" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventTransactionExecutionSucceededEvent(
+  onEventRemoveOwnersEvent(
     func: (
-      event: multisig_account.TransactionExecutionSucceededEventInstance,
+      event: multisig_account.RemoveOwnersEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::TransactionExecutionSucceededEvent" },
+      { type: "multisig_account::RemoveOwnersEvent" },
       fetchConfig,
     );
     return this;
@@ -7508,16 +8806,46 @@ export class multisig_account extends AptosBaseProcessor {
     return this;
   }
 
-  onEventMetadataUpdatedEvent(
+  onEventTransactionExecutionSucceededEvent(
     func: (
-      event: multisig_account.MetadataUpdatedEventInstance,
+      event: multisig_account.TransactionExecutionSucceededEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): multisig_account {
     this.onMoveEvent(
       func,
-      { type: "multisig_account::MetadataUpdatedEvent" },
+      { type: "multisig_account::TransactionExecutionSucceededEvent" },
+      fetchConfig,
+    );
+    return this;
+  }
+
+  onEventUpdateSignaturesRequiredEvent(
+    func: (
+      event: multisig_account.UpdateSignaturesRequiredEventInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): multisig_account {
+    this.onMoveEvent(
+      func,
+      { type: "multisig_account::UpdateSignaturesRequiredEvent" },
+      fetchConfig,
+    );
+    return this;
+  }
+
+  onEventVoteEvent(
+    func: (
+      event: multisig_account.VoteEventInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): multisig_account {
+    this.onMoveEvent(
+      func,
+      { type: "multisig_account::VoteEvent" },
       fetchConfig,
     );
     return this;
@@ -7610,6 +8938,12 @@ export namespace multisig_account {
     }
   }
 
+  export interface ExecutionErrorInstance
+    extends TypedEventInstance<ExecutionError> {
+    data_decoded: ExecutionError;
+    type_arguments: [];
+  }
+
   export interface MetadataUpdatedEvent {
     old_metadata: simple_map.SimpleMap<string, string>;
     new_metadata: simple_map.SimpleMap<string, string>;
@@ -7727,6 +9061,12 @@ export namespace multisig_account {
     }
   }
 
+  export interface MultisigTransactionInstance
+    extends TypedEventInstance<MultisigTransaction> {
+    data_decoded: MultisigTransaction;
+    type_arguments: [];
+  }
+
   export interface RemoveOwnersEvent {
     owners_removed: Address[];
   }
@@ -8340,151 +9680,151 @@ export class staking_contract extends AptosBaseProcessor {
     return this;
   }
 
-  onEventUpdateCommissionEvent(
+  onEventAddDistributionEvent(
     func: (
-      event: staking_contract.UpdateCommissionEventInstance,
+      event: staking_contract.AddDistributionEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::UpdateCommissionEvent" },
+      { type: "staking_contract::AddDistributionEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventCreateStakingContractEvent(
+  onEventAddStakeEvent(
     func: (
-      event: staking_contract.CreateStakingContractEventInstance,
+      event: staking_contract.AddStakeEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::CreateStakingContractEvent" },
+      { type: "staking_contract::AddStakeEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventUpdateVoterEvent(
+  onEventCreateStakingContractEvent(
     func: (
-      event: staking_contract.UpdateVoterEventInstance,
+      event: staking_contract.CreateStakingContractEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::UpdateVoterEvent" },
+      { type: "staking_contract::CreateStakingContractEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventResetLockupEvent(
+  onEventDistributeEvent(
     func: (
-      event: staking_contract.ResetLockupEventInstance,
+      event: staking_contract.DistributeEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::ResetLockupEvent" },
+      { type: "staking_contract::DistributeEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventAddStakeEvent(
+  onEventRequestCommissionEvent(
     func: (
-      event: staking_contract.AddStakeEventInstance,
+      event: staking_contract.RequestCommissionEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::AddStakeEvent" },
+      { type: "staking_contract::RequestCommissionEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventRequestCommissionEvent(
+  onEventResetLockupEvent(
     func: (
-      event: staking_contract.RequestCommissionEventInstance,
+      event: staking_contract.ResetLockupEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::RequestCommissionEvent" },
+      { type: "staking_contract::ResetLockupEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventUnlockStakeEvent(
+  onEventSwitchOperatorEvent(
     func: (
-      event: staking_contract.UnlockStakeEventInstance,
+      event: staking_contract.SwitchOperatorEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::UnlockStakeEvent" },
+      { type: "staking_contract::SwitchOperatorEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventSwitchOperatorEvent(
+  onEventUnlockStakeEvent(
     func: (
-      event: staking_contract.SwitchOperatorEventInstance,
+      event: staking_contract.UnlockStakeEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::SwitchOperatorEvent" },
+      { type: "staking_contract::UnlockStakeEvent" },
       fetchConfig,
     );
     return this;
   }
 
-  onEventAddDistributionEvent(
+  onEventUpdateCommissionEvent(
     func: (
-      event: staking_contract.AddDistributionEventInstance,
+      event: staking_contract.UpdateCommissionEventInstance,
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
   ): staking_contract {
     this.onMoveEvent(
       func,
-      { type: "staking_contract::AddDistributionEvent" },
+      { type: "staking_contract::UpdateCommissionEvent" },
       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;
@@ -8925,6 +10265,38 @@ export namespace aggregator_factory {
   }
 }
 
+export class governance_proposal extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("governance_proposal", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): governance_proposal {
+    return new governance_proposal({
+      ...governance_proposal.DEFAULT_OPTIONS,
+      ...options,
+    });
+  }
+
+  onEventGovernanceProposal(
+    func: (
+      event: governance_proposal.GovernanceProposalInstance,
+      ctx: AptosContext,
+    ) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): governance_proposal {
+    this.onMoveEvent(
+      func,
+      { type: "governance_proposal::GovernanceProposal" },
+      fetchConfig,
+    );
+    return this;
+  }
+}
+
 export namespace governance_proposal {
   export interface GovernanceProposal {
     dummy_field: Boolean;
@@ -8941,6 +10313,12 @@ export namespace governance_proposal {
       return TYPE.apply();
     }
   }
+
+  export interface GovernanceProposalInstance
+    extends TypedEventInstance<GovernanceProposal> {
+    data_decoded: GovernanceProposal;
+    type_arguments: [];
+  }
 }
 
 export namespace optional_aggregator {
@@ -8977,6 +10355,31 @@ export namespace optional_aggregator {
   }
 }
 
+export class transaction_context extends AptosBaseProcessor {
+  constructor(options: AptosBindOptions) {
+    super("transaction_context", options);
+  }
+  static DEFAULT_OPTIONS: AptosBindOptions = {
+    address: "0x1",
+    network: AptosNetwork.MAIN_NET,
+  };
+
+  static bind(options: Partial<AptosBindOptions> = {}): transaction_context {
+    return new transaction_context({
+      ...transaction_context.DEFAULT_OPTIONS,
+      ...options,
+    });
+  }
+
+  onEventAUID(
+    func: (event: transaction_context.AUIDInstance, ctx: AptosContext) => void,
+    fetchConfig?: Partial<MoveFetchConfig>,
+  ): transaction_context {
+    this.onMoveEvent(func, { type: "transaction_context::AUID" }, fetchConfig);
+    return this;
+  }
+}
+
 export namespace transaction_context {
   export interface AUID {
     unique_address: Address;
@@ -8991,6 +10394,11 @@ export namespace transaction_context {
       return TYPE.apply();
     }
   }
+
+  export interface AUIDInstance extends TypedEventInstance<AUID> {
+    data_decoded: AUID;
+    type_arguments: [];
+  }
 }
 
 export class primary_fungible_store extends AptosBaseProcessor {