@sentio/sdk 2.53.3-rc.5 → 2.54.0-rc.10

package/lib/aptos/builtin/0x1.d.ts

@@ -79,6 +79,10 @@ export declare namespace dkg {
     namespace entry { }
     namespace view { }
 }
+export declare namespace mem {
+    namespace entry { }
+    namespace view { }
+}
 export declare class code extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
@@ -169,21 +173,60 @@ export declare class coin extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): coin;
+    onEntryTransfer(func: (call: coin.TransferPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): coin;
     onEntryCreateCoinConversionMap(func: (call: coin.CreateCoinConversionMapPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): coin;
     onEntryCreatePairing(func: (call: coin.CreatePairingPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): coin;
     onEntryFreezeCoinStore(func: (call: coin.FreezeCoinStorePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): coin;
+    onEntryMigrateCoinStoreToFungibleStore(func: (call: coin.MigrateCoinStoreToFungibleStorePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): coin;
     onEntryMigrateToFungibleStore(func: (call: coin.MigrateToFungibleStorePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): coin;
-    onEntryTransfer(func: (call: coin.TransferPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): coin;
     onEntryUnfreezeCoinStore(func: (call: coin.UnfreezeCoinStorePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): coin;
     onEntryUpgradeSupply(func: (call: coin.UpgradeSupplyPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): coin;
+    onEventDepositEvent(func: (event: coin.DepositEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): coin;
+    onEventWithdrawEvent(func: (event: coin.WithdrawEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): coin;
     onEventCoinDeposit(func: (event: coin.CoinDepositInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): coin;
     onEventCoinEventHandleDeletion(func: (event: coin.CoinEventHandleDeletionInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): coin;
     onEventCoinWithdraw(func: (event: coin.CoinWithdrawInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): coin;
-    onEventDepositEvent(func: (event: coin.DepositEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): coin;
     onEventPairCreation(func: (event: coin.PairCreationInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): coin;
-    onEventWithdrawEvent(func: (event: coin.WithdrawEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): coin;
 }
 export declare namespace coin {
+    interface Deposit<T0> {
+        account: MoveAddressType;
+        amount: bigint;
+    }
+    namespace Deposit {
+        const TYPE_QNAME = "0x1::coin::Deposit";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Deposit<T0>>;
+    }
+    interface DepositEvent {
+        amount: bigint;
+    }
+    namespace DepositEvent {
+        const TYPE_QNAME = "0x1::coin::DepositEvent";
+        function type(): TypeDescriptor<DepositEvent>;
+    }
+    interface DepositEventInstance extends TypedEventInstance<DepositEvent> {
+        data_decoded: DepositEvent;
+        type_arguments: [];
+    }
+    interface Withdraw<T0> {
+        account: MoveAddressType;
+        amount: bigint;
+    }
+    namespace Withdraw {
+        const TYPE_QNAME = "0x1::coin::Withdraw";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Withdraw<T0>>;
+    }
+    interface WithdrawEvent {
+        amount: bigint;
+    }
+    namespace WithdrawEvent {
+        const TYPE_QNAME = "0x1::coin::WithdrawEvent";
+        function type(): TypeDescriptor<WithdrawEvent>;
+    }
+    interface WithdrawEventInstance extends TypedEventInstance<WithdrawEvent> {
+        data_decoded: WithdrawEvent;
+        type_arguments: [];
+    }
     interface AggregatableCoin<T0> {
         value: aggregator.Aggregator;
     }
@@ -278,25 +321,6 @@ export declare namespace coin {
         data_decoded: CoinWithdraw;
         type_arguments: [];
     }
-    interface Deposit<T0> {
-        account: MoveAddressType;
-        amount: bigint;
-    }
-    namespace Deposit {
-        const TYPE_QNAME = "0x1::coin::Deposit";
-        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Deposit<T0>>;
-    }
-    interface DepositEvent {
-        amount: bigint;
-    }
-    namespace DepositEvent {
-        const TYPE_QNAME = "0x1::coin::DepositEvent";
-        function type(): TypeDescriptor<DepositEvent>;
-    }
-    interface DepositEventInstance extends TypedEventInstance<DepositEvent> {
-        data_decoded: DepositEvent;
-        type_arguments: [];
-    }
     interface FreezeCapability<T0> {
         dummy_field: boolean;
     }
@@ -367,26 +391,11 @@ export declare namespace coin {
         const TYPE_QNAME = "0x1::coin::TransferRefReceipt";
         function type(): TypeDescriptor<TransferRefReceipt>;
     }
-    interface Withdraw<T0> {
-        account: MoveAddressType;
-        amount: bigint;
-    }
-    namespace Withdraw {
-        const TYPE_QNAME = "0x1::coin::Withdraw";
-        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Withdraw<T0>>;
-    }
-    interface WithdrawEvent {
-        amount: bigint;
-    }
-    namespace WithdrawEvent {
-        const TYPE_QNAME = "0x1::coin::WithdrawEvent";
-        function type(): TypeDescriptor<WithdrawEvent>;
-    }
-    interface WithdrawEventInstance extends TypedEventInstance<WithdrawEvent> {
-        data_decoded: WithdrawEvent;
-        type_arguments: [];
-    }
     namespace entry {
+        function transfer<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function createCoinConversionMap(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [];
@@ -399,13 +408,13 @@ export declare namespace coin {
             typeArguments: [MoveStructId];
             functionArguments: [MoveAddressType, MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function migrateToFungibleStore<T0 = any>(client: Aptos, account: AptosAccount, request: {
+        function migrateCoinStoreToFungibleStore<T0 = any>(client: Aptos, account: AptosAccount, request: {
             typeArguments: [MoveStructId];
-            functionArguments: [];
+            functionArguments: [MoveAddressType[]];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function transfer<T0 = any>(client: Aptos, account: AptosAccount, request: {
+        function migrateToFungibleStore<T0 = any>(client: Aptos, account: AptosAccount, request: {
             typeArguments: [MoveStructId];
-            functionArguments: [MoveAddressType, bigint];
+            functionArguments: [];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function unfreezeCoinStore<T0 = any>(client: Aptos, account: AptosAccount, request: {
             typeArguments: [MoveStructId];
@@ -417,24 +426,33 @@ export declare namespace coin {
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
-        function balance<T0 = any>(client: Aptos, request: {
+        function name<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
-            functionArguments: [MoveAddressType];
-        }, version?: bigint): Promise<[bigint]>;
-        function coinSupply<T0 = any>(client: Aptos, request: {
+        }, version?: bigint): Promise<[string]>;
+        function symbol$<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
-        }, version?: bigint): Promise<[option.Option<bigint>]>;
+        }, version?: bigint): Promise<[string]>;
         function decimals<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
         }, version?: bigint): Promise<[number]>;
-        function isAccountRegistered<T0 = any>(client: Aptos, request: {
+        function balance<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
             functionArguments: [MoveAddressType];
-        }, version?: bigint): Promise<[boolean]>;
+        }, version?: bigint): Promise<[bigint]>;
         function isBalanceAtLeast<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
             functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[boolean]>;
+        function supply<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+        }, version?: bigint): Promise<[option.Option<bigint>]>;
+        function coinSupply<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+        }, version?: bigint): Promise<[option.Option<bigint>]>;
+        function isAccountRegistered<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
         function isCoinInitialized<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
         }, version?: bigint): Promise<[boolean]>;
@@ -442,9 +460,6 @@ export declare namespace coin {
             typeArguments: [MoveStructId];
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[boolean]>;
-        function name<T0 = any>(client: Aptos, request: {
-            typeArguments: [MoveStructId];
-        }, version?: bigint): Promise<[string]>;
         function pairedBurnRefExists<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
         }, version?: bigint): Promise<[boolean]>;
@@ -460,12 +475,10 @@ export declare namespace coin {
         function pairedTransferRefExists<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
         }, version?: bigint): Promise<[boolean]>;
-        function supply<T0 = any>(client: Aptos, request: {
-            typeArguments: [MoveStructId];
-        }, version?: bigint): Promise<[option.Option<bigint>]>;
-        function symbol$<T0 = any>(client: Aptos, request: {
-            typeArguments: [MoveStructId];
-        }, version?: bigint): Promise<[string]>;
+    }
+    interface TransferPayload<T0 = any> extends TypedFunctionPayload<[MoveAddressType, bigint]> {
+        arguments_decoded: [MoveAddressType, bigint];
+        type_arguments: [string];
     }
     interface CreateCoinConversionMapPayload extends TypedFunctionPayload<[]> {
         arguments_decoded: [];
@@ -479,12 +492,12 @@ export declare namespace coin {
         arguments_decoded: [MoveAddressType, MoveAddressType];
         type_arguments: [string];
     }
-    interface MigrateToFungibleStorePayload<T0 = any> extends TypedFunctionPayload<[]> {
-        arguments_decoded: [];
+    interface MigrateCoinStoreToFungibleStorePayload<T0 = any> extends TypedFunctionPayload<[MoveAddressType[]]> {
+        arguments_decoded: [MoveAddressType[]];
         type_arguments: [string];
     }
-    interface TransferPayload<T0 = any> extends TypedFunctionPayload<[MoveAddressType, bigint]> {
-        arguments_decoded: [MoveAddressType, bigint];
+    interface MigrateToFungibleStorePayload<T0 = any> extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
         type_arguments: [string];
     }
     interface UnfreezeCoinStorePayload<T0 = any> extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
@@ -802,6 +815,7 @@ export declare class stake extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): stake;
+    onEntryWithdraw(func: (call: stake.WithdrawPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEntryAddStake(func: (call: stake.AddStakePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEntryIncreaseLockup(func: (call: stake.IncreaseLockupPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEntryInitializeStakeOwner(func: (call: stake.InitializeStakeOwnerPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): stake;
@@ -814,7 +828,6 @@ export declare class stake extends AptosBaseProcessor {
     onEntrySetOperator(func: (call: stake.SetOperatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEntryUnlock(func: (call: stake.UnlockPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEntryUpdateNetworkAndFullnodeAddresses(func: (call: stake.UpdateNetworkAndFullnodeAddressesPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): stake;
-    onEntryWithdraw(func: (call: stake.WithdrawPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEventAddStake(func: (event: stake.AddStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEventAddStakeEvent(func: (event: stake.AddStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEventDistributeRewards(func: (event: stake.DistributeRewardsInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
@@ -1235,6 +1248,10 @@ export declare namespace stake {
         type_arguments: [];
     }
     namespace entry {
+        function withdraw(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function addStake(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [bigint];
@@ -1283,10 +1300,6 @@ export declare namespace stake {
             typeArguments: [];
             functionArguments: [MoveAddressType, string, string];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function withdraw(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [];
-            functionArguments: [bigint];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
         function getCurrentEpochProposalCounts(client: Aptos, request: {
@@ -1323,6 +1336,10 @@ export declare namespace stake {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[boolean]>;
     }
+    interface WithdrawPayload extends TypedFunctionPayload<[bigint]> {
+        arguments_decoded: [bigint];
+        type_arguments: [];
+    }
     interface AddStakePayload extends TypedFunctionPayload<[bigint]> {
         arguments_decoded: [bigint];
         type_arguments: [];
@@ -1371,10 +1388,6 @@ export declare namespace stake {
         arguments_decoded: [MoveAddressType, string, string];
         type_arguments: [];
     }
-    interface WithdrawPayload extends TypedFunctionPayload<[bigint]> {
-        arguments_decoded: [bigint];
-        type_arguments: [];
-    }
 }
 export declare namespace table {
     interface Box<T0> {
@@ -1821,6 +1834,7 @@ export declare class account extends AptosBaseProcessor {
     onEntryRotateAuthenticationKey(func: (call: account.RotateAuthenticationKeyPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): account;
     onEntryRotateAuthenticationKeyCall(func: (call: account.RotateAuthenticationKeyCallPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): account;
     onEntryRotateAuthenticationKeyWithRotationCapability(func: (call: account.RotateAuthenticationKeyWithRotationCapabilityPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): account;
+    onEntrySetOriginatingAddress(func: (call: account.SetOriginatingAddressPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): account;
     onEventCoinRegister(func: (event: account.CoinRegisterInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): account;
     onEventCoinRegisterEvent(func: (event: account.CoinRegisterEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): account;
     onEventKeyRotation(func: (event: account.KeyRotationInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): account;
@@ -1998,6 +2012,10 @@ export declare namespace account {
             typeArguments: [];
             functionArguments: [MoveAddressType, number, string, string];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setOriginatingAddress(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
         function existsAt(client: Aptos, request: {
@@ -2024,6 +2042,9 @@ export declare namespace account {
         function isSignerCapabilityOffered(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[boolean]>;
+        function originatingAddress(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[option.Option<MoveAddressType>]>;
     }
     interface OfferRotationCapabilityPayload extends TypedFunctionPayload<[string, number, string, MoveAddressType]> {
         arguments_decoded: [string, number, string, MoveAddressType];
@@ -2068,6 +2089,10 @@ export declare namespace account {
         arguments_decoded: [MoveAddressType, number, string, string];
         type_arguments: [];
     }
+    interface SetOriginatingAddressPayload extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
 }
 export declare namespace ed25519 {
     interface Signature {
@@ -2198,32 +2223,34 @@ export declare class vesting extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): vesting;
-    onEntryAdminWithdraw(func: (call: vesting.AdminWithdrawPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEntrySetBeneficiaryForOperator(func: (call: vesting.SetBeneficiaryForOperatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEntryUpdateCommissionPercentage(func: (call: vesting.UpdateCommissionPercentagePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEntryDistribute(func: (call: vesting.DistributePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEntryResetLockup(func: (call: vesting.ResetLockupPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEntryUnlockRewards(func: (call: vesting.UnlockRewardsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEntryUpdateVoter(func: (call: vesting.UpdateVoterPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEntryAdminWithdraw(func: (call: vesting.AdminWithdrawPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEntryDistributeMany(func: (call: vesting.DistributeManyPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEntryResetBeneficiary(func: (call: vesting.ResetBeneficiaryPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
-    onEntryResetLockup(func: (call: vesting.ResetLockupPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEntrySetBeneficiary(func: (call: vesting.SetBeneficiaryPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
-    onEntrySetBeneficiaryForOperator(func: (call: vesting.SetBeneficiaryForOperatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEntrySetBeneficiaryResetter(func: (call: vesting.SetBeneficiaryResetterPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEntrySetManagementRole(func: (call: vesting.SetManagementRolePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEntryTerminateVestingContract(func: (call: vesting.TerminateVestingContractPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
-    onEntryUnlockRewards(func: (call: vesting.UnlockRewardsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEntryUnlockRewardsMany(func: (call: vesting.UnlockRewardsManyPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
-    onEntryUpdateCommissionPercentage(func: (call: vesting.UpdateCommissionPercentagePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEntryUpdateOperator(func: (call: vesting.UpdateOperatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEntryUpdateOperatorWithSameCommission(func: (call: vesting.UpdateOperatorWithSameCommissionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
-    onEntryUpdateVoter(func: (call: vesting.UpdateVoterPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEntryVest(func: (call: vesting.VestPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEntryVestMany(func: (call: vesting.VestManyPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
-    onEventAdminWithdraw(func: (event: vesting.AdminWithdrawInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
-    onEventAdminWithdrawEvent(func: (event: vesting.AdminWithdrawEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
-    onEventCreateVestingContract(func: (event: vesting.CreateVestingContractInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
-    onEventCreateVestingContractEvent(func: (event: vesting.CreateVestingContractEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventDistribute(func: (event: vesting.DistributeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventDistributeEvent(func: (event: vesting.DistributeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventResetLockup(func: (event: vesting.ResetLockupInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventResetLockupEvent(func: (event: vesting.ResetLockupEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventUpdateVoter(func: (event: vesting.UpdateVoterInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventUpdateVoterEvent(func: (event: vesting.UpdateVoterEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventAdminWithdraw(func: (event: vesting.AdminWithdrawInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventAdminWithdrawEvent(func: (event: vesting.AdminWithdrawEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventCreateVestingContract(func: (event: vesting.CreateVestingContractInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventCreateVestingContractEvent(func: (event: vesting.CreateVestingContractEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventSetBeneficiary(func: (event: vesting.SetBeneficiaryInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventSetBeneficiaryEvent(func: (event: vesting.SetBeneficiaryEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventTerminate(func: (event: vesting.TerminateInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
@@ -2232,133 +2259,161 @@ export declare class vesting extends AptosBaseProcessor {
     onEventUnlockRewardsEvent(func: (event: vesting.UnlockRewardsEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventUpdateOperator(func: (event: vesting.UpdateOperatorInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventUpdateOperatorEvent(func: (event: vesting.UpdateOperatorEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
-    onEventUpdateVoter(func: (event: vesting.UpdateVoterInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
-    onEventUpdateVoterEvent(func: (event: vesting.UpdateVoterEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventVest(func: (event: vesting.VestInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventVestEvent(func: (event: vesting.VestEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
 }
 export declare namespace vesting {
-    interface AdminStore {
-        vesting_contracts: MoveAddressType[];
-        nonce: bigint;
-        create_events: event.EventHandle<vesting.CreateVestingContractEvent>;
-    }
-    namespace AdminStore {
-        const TYPE_QNAME = "0x1::vesting::AdminStore";
-        function type(): TypeDescriptor<AdminStore>;
-    }
-    interface AdminWithdraw {
+    interface Distribute {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
         amount: bigint;
     }
-    namespace AdminWithdraw {
-        const TYPE_QNAME = "0x1::vesting::AdminWithdraw";
-        function type(): TypeDescriptor<AdminWithdraw>;
+    namespace Distribute {
+        const TYPE_QNAME = "0x1::vesting::Distribute";
+        function type(): TypeDescriptor<Distribute>;
     }
-    interface AdminWithdrawInstance extends TypedEventInstance<AdminWithdraw> {
-        data_decoded: AdminWithdraw;
+    interface DistributeInstance extends TypedEventInstance<Distribute> {
+        data_decoded: Distribute;
         type_arguments: [];
     }
-    interface AdminWithdrawEvent {
+    interface DistributeEvent {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
         amount: bigint;
     }
-    namespace AdminWithdrawEvent {
-        const TYPE_QNAME = "0x1::vesting::AdminWithdrawEvent";
-        function type(): TypeDescriptor<AdminWithdrawEvent>;
+    namespace DistributeEvent {
+        const TYPE_QNAME = "0x1::vesting::DistributeEvent";
+        function type(): TypeDescriptor<DistributeEvent>;
     }
-    interface AdminWithdrawEventInstance extends TypedEventInstance<AdminWithdrawEvent> {
-        data_decoded: AdminWithdrawEvent;
+    interface DistributeEventInstance extends TypedEventInstance<DistributeEvent> {
+        data_decoded: DistributeEvent;
         type_arguments: [];
     }
-    interface CreateVestingContract {
-        operator: MoveAddressType;
-        voter: MoveAddressType;
-        grant_amount: bigint;
-        withdrawal_address: MoveAddressType;
+    interface ResetLockup {
+        admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
         staking_pool_address: MoveAddressType;
-        commission_percentage: bigint;
+        new_lockup_expiration_secs: bigint;
     }
-    namespace CreateVestingContract {
-        const TYPE_QNAME = "0x1::vesting::CreateVestingContract";
-        function type(): TypeDescriptor<CreateVestingContract>;
+    namespace ResetLockup {
+        const TYPE_QNAME = "0x1::vesting::ResetLockup";
+        function type(): TypeDescriptor<ResetLockup>;
     }
-    interface CreateVestingContractInstance extends TypedEventInstance<CreateVestingContract> {
-        data_decoded: CreateVestingContract;
+    interface ResetLockupInstance extends TypedEventInstance<ResetLockup> {
+        data_decoded: ResetLockup;
         type_arguments: [];
     }
-    interface CreateVestingContractEvent {
-        operator: MoveAddressType;
-        voter: MoveAddressType;
-        grant_amount: bigint;
-        withdrawal_address: MoveAddressType;
+    interface ResetLockupEvent {
+        admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
         staking_pool_address: MoveAddressType;
-        commission_percentage: bigint;
+        new_lockup_expiration_secs: bigint;
     }
-    namespace CreateVestingContractEvent {
-        const TYPE_QNAME = "0x1::vesting::CreateVestingContractEvent";
-        function type(): TypeDescriptor<CreateVestingContractEvent>;
+    namespace ResetLockupEvent {
+        const TYPE_QNAME = "0x1::vesting::ResetLockupEvent";
+        function type(): TypeDescriptor<ResetLockupEvent>;
     }
-    interface CreateVestingContractEventInstance extends TypedEventInstance<CreateVestingContractEvent> {
-        data_decoded: CreateVestingContractEvent;
+    interface ResetLockupEventInstance extends TypedEventInstance<ResetLockupEvent> {
+        data_decoded: ResetLockupEvent;
         type_arguments: [];
     }
-    interface Distribute {
+    interface UpdateVoter {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
-        amount: bigint;
+        staking_pool_address: MoveAddressType;
+        old_voter: MoveAddressType;
+        new_voter: MoveAddressType;
     }
-    namespace Distribute {
-        const TYPE_QNAME = "0x1::vesting::Distribute";
-        function type(): TypeDescriptor<Distribute>;
+    namespace UpdateVoter {
+        const TYPE_QNAME = "0x1::vesting::UpdateVoter";
+        function type(): TypeDescriptor<UpdateVoter>;
     }
-    interface DistributeInstance extends TypedEventInstance<Distribute> {
-        data_decoded: Distribute;
+    interface UpdateVoterInstance extends TypedEventInstance<UpdateVoter> {
+        data_decoded: UpdateVoter;
         type_arguments: [];
     }
-    interface DistributeEvent {
+    interface UpdateVoterEvent {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
+        old_voter: MoveAddressType;
+        new_voter: MoveAddressType;
+    }
+    namespace UpdateVoterEvent {
+        const TYPE_QNAME = "0x1::vesting::UpdateVoterEvent";
+        function type(): TypeDescriptor<UpdateVoterEvent>;
+    }
+    interface UpdateVoterEventInstance extends TypedEventInstance<UpdateVoterEvent> {
+        data_decoded: UpdateVoterEvent;
+        type_arguments: [];
+    }
+    interface AdminStore {
+        vesting_contracts: MoveAddressType[];
+        nonce: bigint;
+        create_events: event.EventHandle<vesting.CreateVestingContractEvent>;
+    }
+    namespace AdminStore {
+        const TYPE_QNAME = "0x1::vesting::AdminStore";
+        function type(): TypeDescriptor<AdminStore>;
+    }
+    interface AdminWithdraw {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
         amount: bigint;
     }
-    namespace DistributeEvent {
-        const TYPE_QNAME = "0x1::vesting::DistributeEvent";
-        function type(): TypeDescriptor<DistributeEvent>;
+    namespace AdminWithdraw {
+        const TYPE_QNAME = "0x1::vesting::AdminWithdraw";
+        function type(): TypeDescriptor<AdminWithdraw>;
     }
-    interface DistributeEventInstance extends TypedEventInstance<DistributeEvent> {
-        data_decoded: DistributeEvent;
+    interface AdminWithdrawInstance extends TypedEventInstance<AdminWithdraw> {
+        data_decoded: AdminWithdraw;
         type_arguments: [];
     }
-    interface ResetLockup {
+    interface AdminWithdrawEvent {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
+        amount: bigint;
+    }
+    namespace AdminWithdrawEvent {
+        const TYPE_QNAME = "0x1::vesting::AdminWithdrawEvent";
+        function type(): TypeDescriptor<AdminWithdrawEvent>;
+    }
+    interface AdminWithdrawEventInstance extends TypedEventInstance<AdminWithdrawEvent> {
+        data_decoded: AdminWithdrawEvent;
+        type_arguments: [];
+    }
+    interface CreateVestingContract {
+        operator: MoveAddressType;
+        voter: MoveAddressType;
+        grant_amount: bigint;
+        withdrawal_address: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
         staking_pool_address: MoveAddressType;
-        new_lockup_expiration_secs: bigint;
+        commission_percentage: bigint;
     }
-    namespace ResetLockup {
-        const TYPE_QNAME = "0x1::vesting::ResetLockup";
-        function type(): TypeDescriptor<ResetLockup>;
+    namespace CreateVestingContract {
+        const TYPE_QNAME = "0x1::vesting::CreateVestingContract";
+        function type(): TypeDescriptor<CreateVestingContract>;
     }
-    interface ResetLockupInstance extends TypedEventInstance<ResetLockup> {
-        data_decoded: ResetLockup;
+    interface CreateVestingContractInstance extends TypedEventInstance<CreateVestingContract> {
+        data_decoded: CreateVestingContract;
         type_arguments: [];
     }
-    interface ResetLockupEvent {
-        admin: MoveAddressType;
+    interface CreateVestingContractEvent {
+        operator: MoveAddressType;
+        voter: MoveAddressType;
+        grant_amount: bigint;
+        withdrawal_address: MoveAddressType;
         vesting_contract_address: MoveAddressType;
         staking_pool_address: MoveAddressType;
-        new_lockup_expiration_secs: bigint;
+        commission_percentage: bigint;
     }
-    namespace ResetLockupEvent {
-        const TYPE_QNAME = "0x1::vesting::ResetLockupEvent";
-        function type(): TypeDescriptor<ResetLockupEvent>;
+    namespace CreateVestingContractEvent {
+        const TYPE_QNAME = "0x1::vesting::CreateVestingContractEvent";
+        function type(): TypeDescriptor<CreateVestingContractEvent>;
     }
-    interface ResetLockupEventInstance extends TypedEventInstance<ResetLockupEvent> {
-        data_decoded: ResetLockupEvent;
+    interface CreateVestingContractEventInstance extends TypedEventInstance<CreateVestingContractEvent> {
+        data_decoded: CreateVestingContractEvent;
         type_arguments: [];
     }
     interface SetBeneficiary {
@@ -2485,36 +2540,6 @@ export declare namespace vesting {
         data_decoded: UpdateOperatorEvent;
         type_arguments: [];
     }
-    interface UpdateVoter {
-        admin: MoveAddressType;
-        vesting_contract_address: MoveAddressType;
-        staking_pool_address: MoveAddressType;
-        old_voter: MoveAddressType;
-        new_voter: MoveAddressType;
-    }
-    namespace UpdateVoter {
-        const TYPE_QNAME = "0x1::vesting::UpdateVoter";
-        function type(): TypeDescriptor<UpdateVoter>;
-    }
-    interface UpdateVoterInstance extends TypedEventInstance<UpdateVoter> {
-        data_decoded: UpdateVoter;
-        type_arguments: [];
-    }
-    interface UpdateVoterEvent {
-        admin: MoveAddressType;
-        vesting_contract_address: MoveAddressType;
-        staking_pool_address: MoveAddressType;
-        old_voter: MoveAddressType;
-        new_voter: MoveAddressType;
-    }
-    namespace UpdateVoterEvent {
-        const TYPE_QNAME = "0x1::vesting::UpdateVoterEvent";
-        function type(): TypeDescriptor<UpdateVoterEvent>;
-    }
-    interface UpdateVoterEventInstance extends TypedEventInstance<UpdateVoterEvent> {
-        data_decoded: UpdateVoterEvent;
-        type_arguments: [];
-    }
     interface Vest {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
@@ -2587,33 +2612,45 @@ export declare namespace vesting {
         function type(): TypeDescriptor<VestingSchedule>;
     }
     namespace entry {
-        function adminWithdraw(client: Aptos, account: AptosAccount, request: {
+        function setBeneficiaryForOperator(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateCommissionPercentage(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function distribute(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function distributeMany(client: Aptos, account: AptosAccount, request: {
+        function resetLockup(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
-            functionArguments: [MoveAddressType[]];
+            functionArguments: [MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function resetBeneficiary(client: Aptos, account: AptosAccount, request: {
+        function unlockRewards(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateVoter(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType, MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function resetLockup(client: Aptos, account: AptosAccount, request: {
+        function adminWithdraw(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function setBeneficiary(client: Aptos, account: AptosAccount, request: {
+        function distributeMany(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
-            functionArguments: [MoveAddressType, MoveAddressType, MoveAddressType];
+            functionArguments: [MoveAddressType[]];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function setBeneficiaryForOperator(client: Aptos, account: AptosAccount, request: {
+        function resetBeneficiary(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
-            functionArguments: [MoveAddressType];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setBeneficiary(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType, MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function setBeneficiaryResetter(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
@@ -2627,18 +2664,10 @@ export declare namespace vesting {
             typeArguments: [];
             functionArguments: [MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function unlockRewards(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [];
-            functionArguments: [MoveAddressType];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function unlockRewardsMany(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType[]];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function updateCommissionPercentage(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [];
-            functionArguments: [MoveAddressType, bigint];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function updateOperator(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType, MoveAddressType, bigint];
@@ -2647,10 +2676,6 @@ export declare namespace vesting {
             typeArguments: [];
             functionArguments: [MoveAddressType, MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function updateVoter(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [];
-            functionArguments: [MoveAddressType, MoveAddressType];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function vest(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType];
@@ -2661,25 +2686,19 @@ export declare namespace vesting {
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
-        function accumulatedRewards(client: Aptos, request: {
-            functionArguments: [MoveAddressType, MoveAddressType];
-        }, version?: bigint): Promise<[bigint]>;
-        function beneficiary(client: Aptos, request: {
-            functionArguments: [MoveAddressType, MoveAddressType];
-        }, version?: bigint): Promise<[MoveAddressType]>;
         function operator(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[MoveAddressType]>;
-        function operatorCommissionPercentage(client: Aptos, request: {
-            functionArguments: [MoveAddressType];
-        }, version?: bigint): Promise<[bigint]>;
-        function periodDurationSecs(client: Aptos, request: {
+        function voter(client: Aptos, request: {
             functionArguments: [MoveAddressType];
-        }, version?: bigint): Promise<[bigint]>;
-        function remainingGrant(client: Aptos, request: {
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function shareholder(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function operatorCommissionPercentage(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function shareholder(client: Aptos, request: {
+        function beneficiary(client: Aptos, request: {
             functionArguments: [MoveAddressType, MoveAddressType];
         }, version?: bigint): Promise<[MoveAddressType]>;
         function shareholders(client: Aptos, request: {
@@ -2688,42 +2707,64 @@ export declare namespace vesting {
         function stakePoolAddress(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[MoveAddressType]>;
+        function accumulatedRewards(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function vestingSchedule(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[vesting.VestingSchedule]>;
+        function periodDurationSecs(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function remainingGrant(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
         function totalAccumulatedRewards(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
         function vestingContracts(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[MoveAddressType[]]>;
-        function vestingSchedule(client: Aptos, request: {
-            functionArguments: [MoveAddressType];
-        }, version?: bigint): Promise<[vesting.VestingSchedule]>;
         function vestingStartSecs(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function voter(client: Aptos, request: {
-            functionArguments: [MoveAddressType];
-        }, version?: bigint): Promise<[MoveAddressType]>;
     }
-    interface AdminWithdrawPayload extends TypedFunctionPayload<[MoveAddressType]> {
+    interface SetBeneficiaryForOperatorPayload extends TypedFunctionPayload<[MoveAddressType]> {
         arguments_decoded: [MoveAddressType];
         type_arguments: [];
     }
+    interface UpdateCommissionPercentagePayload extends TypedFunctionPayload<[MoveAddressType, bigint]> {
+        arguments_decoded: [MoveAddressType, bigint];
+        type_arguments: [];
+    }
     interface DistributePayload extends TypedFunctionPayload<[MoveAddressType]> {
         arguments_decoded: [MoveAddressType];
         type_arguments: [];
     }
-    interface DistributeManyPayload extends TypedFunctionPayload<[MoveAddressType[]]> {
-        arguments_decoded: [MoveAddressType[]];
+    interface ResetLockupPayload extends TypedFunctionPayload<[MoveAddressType]> {
+        arguments_decoded: [MoveAddressType];
         type_arguments: [];
     }
-    interface ResetBeneficiaryPayload extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
+    interface UnlockRewardsPayload extends TypedFunctionPayload<[MoveAddressType]> {
+        arguments_decoded: [MoveAddressType];
+        type_arguments: [];
+    }
+    interface UpdateVoterPayload extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
         arguments_decoded: [MoveAddressType, MoveAddressType];
         type_arguments: [];
     }
-    interface ResetLockupPayload extends TypedFunctionPayload<[MoveAddressType]> {
+    interface AdminWithdrawPayload extends TypedFunctionPayload<[MoveAddressType]> {
         arguments_decoded: [MoveAddressType];
         type_arguments: [];
     }
+    interface DistributeManyPayload extends TypedFunctionPayload<[MoveAddressType[]]> {
+        arguments_decoded: [MoveAddressType[]];
+        type_arguments: [];
+    }
+    interface ResetBeneficiaryPayload extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
+        arguments_decoded: [MoveAddressType, MoveAddressType];
+        type_arguments: [];
+    }
     interface SetBeneficiaryPayload extends TypedFunctionPayload<[
         MoveAddressType,
         MoveAddressType,
@@ -2732,10 +2773,6 @@ export declare namespace vesting {
         arguments_decoded: [MoveAddressType, MoveAddressType, MoveAddressType];
         type_arguments: [];
     }
-    interface SetBeneficiaryForOperatorPayload extends TypedFunctionPayload<[MoveAddressType]> {
-        arguments_decoded: [MoveAddressType];
-        type_arguments: [];
-    }
     interface SetBeneficiaryResetterPayload extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
         arguments_decoded: [MoveAddressType, MoveAddressType];
         type_arguments: [];
@@ -2748,18 +2785,10 @@ export declare namespace vesting {
         arguments_decoded: [MoveAddressType];
         type_arguments: [];
     }
-    interface UnlockRewardsPayload extends TypedFunctionPayload<[MoveAddressType]> {
-        arguments_decoded: [MoveAddressType];
-        type_arguments: [];
-    }
     interface UnlockRewardsManyPayload extends TypedFunctionPayload<[MoveAddressType[]]> {
         arguments_decoded: [MoveAddressType[]];
         type_arguments: [];
     }
-    interface UpdateCommissionPercentagePayload extends TypedFunctionPayload<[MoveAddressType, bigint]> {
-        arguments_decoded: [MoveAddressType, bigint];
-        type_arguments: [];
-    }
     interface UpdateOperatorPayload extends TypedFunctionPayload<[MoveAddressType, MoveAddressType, bigint]> {
         arguments_decoded: [MoveAddressType, MoveAddressType, bigint];
         type_arguments: [];
@@ -2768,10 +2797,6 @@ export declare namespace vesting {
         arguments_decoded: [MoveAddressType, MoveAddressType];
         type_arguments: [];
     }
-    interface UpdateVoterPayload extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
-        arguments_decoded: [MoveAddressType, MoveAddressType];
-        type_arguments: [];
-    }
     interface VestPayload extends TypedFunctionPayload<[MoveAddressType]> {
         arguments_decoded: [MoveAddressType];
         type_arguments: [];
@@ -2944,9 +2969,9 @@ export declare class aptos_coin extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): aptos_coin;
+    onEntryMint(func: (call: aptos_coin.MintPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_coin;
     onEntryClaimMintCapability(func: (call: aptos_coin.ClaimMintCapabilityPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_coin;
     onEntryDelegateMintCapability(func: (call: aptos_coin.DelegateMintCapabilityPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_coin;
-    onEntryMint(func: (call: aptos_coin.MintPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_coin;
 }
 export declare namespace aptos_coin {
     interface AptosCoin {
@@ -2978,6 +3003,10 @@ export declare namespace aptos_coin {
         function type(): TypeDescriptor<MintCapStore>;
     }
     namespace entry {
+        function mint(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function claimMintCapability(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [];
@@ -2986,12 +3015,12 @@ export declare namespace aptos_coin {
             typeArguments: [];
             functionArguments: [MoveAddressType, MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function mint(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [];
-            functionArguments: [MoveAddressType, bigint];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view { }
+    interface MintPayload extends TypedFunctionPayload<[MoveAddressType, bigint]> {
+        arguments_decoded: [MoveAddressType, bigint];
+        type_arguments: [];
+    }
     interface ClaimMintCapabilityPayload extends TypedFunctionPayload<[]> {
         arguments_decoded: [];
         type_arguments: [];
@@ -3000,10 +3029,6 @@ export declare namespace aptos_coin {
         arguments_decoded: [MoveAddressType, MoveAddressType];
         type_arguments: [];
     }
-    interface MintPayload extends TypedFunctionPayload<[MoveAddressType, bigint]> {
-        arguments_decoded: [MoveAddressType, bigint];
-        type_arguments: [];
-    }
 }
 export declare namespace aptos_hash {
     namespace entry { }
@@ -3263,11 +3288,11 @@ export declare class managed_coin extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): managed_coin;
-    onEntryBurn(func: (call: managed_coin.BurnPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): managed_coin;
-    onEntryDestroyCaps(func: (call: managed_coin.DestroyCapsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): managed_coin;
     onEntryInitialize(func: (call: managed_coin.InitializePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): managed_coin;
+    onEntryBurn(func: (call: managed_coin.BurnPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): managed_coin;
     onEntryMint(func: (call: managed_coin.MintPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): managed_coin;
     onEntryRegister(func: (call: managed_coin.RegisterPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): managed_coin;
+    onEntryDestroyCaps(func: (call: managed_coin.DestroyCapsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): managed_coin;
 }
 export declare namespace managed_coin {
     interface Capabilities<T0> {
@@ -3280,18 +3305,14 @@ export declare namespace managed_coin {
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Capabilities<T0>>;
     }
     namespace entry {
-        function burn<T0 = any>(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [MoveStructId];
-            functionArguments: [bigint];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function destroyCaps<T0 = any>(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [MoveStructId];
-            functionArguments: [];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function initialize<T0 = any>(client: Aptos, account: AptosAccount, request: {
             typeArguments: [MoveStructId];
             functionArguments: [string, string, number, boolean];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function burn<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function mint<T0 = any>(client: Aptos, account: AptosAccount, request: {
             typeArguments: [MoveStructId];
             functionArguments: [MoveAddressType, bigint];
@@ -3300,20 +3321,20 @@ export declare namespace managed_coin {
             typeArguments: [MoveStructId];
             functionArguments: [];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function destroyCaps<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view { }
-    interface BurnPayload<T0 = any> extends TypedFunctionPayload<[bigint]> {
-        arguments_decoded: [bigint];
-        type_arguments: [string];
-    }
-    interface DestroyCapsPayload<T0 = any> extends TypedFunctionPayload<[]> {
-        arguments_decoded: [];
-        type_arguments: [string];
-    }
     interface InitializePayload<T0 = any> extends TypedFunctionPayload<[string, string, number, boolean]> {
         arguments_decoded: [string, string, number, boolean];
         type_arguments: [string];
     }
+    interface BurnPayload<T0 = any> extends TypedFunctionPayload<[bigint]> {
+        arguments_decoded: [bigint];
+        type_arguments: [string];
+    }
     interface MintPayload<T0 = any> extends TypedFunctionPayload<[MoveAddressType, bigint]> {
         arguments_decoded: [MoveAddressType, bigint];
         type_arguments: [string];
@@ -3322,6 +3343,10 @@ export declare namespace managed_coin {
         arguments_decoded: [];
         type_arguments: [string];
     }
+    interface DestroyCapsPayload<T0 = any> extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [string];
+    }
 }
 export declare namespace math_fixed64 {
     namespace entry { }
@@ -3424,13 +3449,13 @@ export declare class aptos_account extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): aptos_account;
+    onEntryCreateAccount(func: (call: aptos_account.CreateAccountPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
+    onEntryTransfer(func: (call: aptos_account.TransferPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
     onEntryBatchTransfer(func: (call: aptos_account.BatchTransferPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
     onEntryBatchTransferCoins(func: (call: aptos_account.BatchTransferCoinsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
     onEntryBatchTransferFungibleAssets(func: (call: aptos_account.BatchTransferFungibleAssetsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
-    onEntryCreateAccount(func: (call: aptos_account.CreateAccountPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
     onEntryFungibleTransferOnly(func: (call: aptos_account.FungibleTransferOnlyPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
     onEntrySetAllowDirectCoinTransfers(func: (call: aptos_account.SetAllowDirectCoinTransfersPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
-    onEntryTransfer(func: (call: aptos_account.TransferPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
     onEntryTransferCoins(func: (call: aptos_account.TransferCoinsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
     onEntryTransferFungibleAssets(func: (call: aptos_account.TransferFungibleAssetsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
     onEventDirectCoinTransferConfigUpdated(func: (event: aptos_account.DirectCoinTransferConfigUpdatedInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
@@ -3469,6 +3494,14 @@ export declare namespace aptos_account {
         function type(): TypeDescriptor<DirectTransferConfig>;
     }
     namespace entry {
+        function createAccount(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function transfer(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function batchTransfer(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType[], bigint[]];
@@ -3485,10 +3518,6 @@ export declare namespace aptos_account {
                 bigint[]
             ];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function createAccount(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [];
-            functionArguments: [MoveAddressType];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function fungibleTransferOnly(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType, bigint];
@@ -3497,10 +3526,6 @@ export declare namespace aptos_account {
             typeArguments: [];
             functionArguments: [boolean];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function transfer(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [];
-            functionArguments: [MoveAddressType, bigint];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function transferCoins<T0 = any>(client: Aptos, account: AptosAccount, request: {
             typeArguments: [MoveStructId];
             functionArguments: [MoveAddressType, bigint];
@@ -3519,6 +3544,14 @@ export declare namespace aptos_account {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[boolean]>;
     }
+    interface CreateAccountPayload extends TypedFunctionPayload<[MoveAddressType]> {
+        arguments_decoded: [MoveAddressType];
+        type_arguments: [];
+    }
+    interface TransferPayload extends TypedFunctionPayload<[MoveAddressType, bigint]> {
+        arguments_decoded: [MoveAddressType, bigint];
+        type_arguments: [];
+    }
     interface BatchTransferPayload extends TypedFunctionPayload<[MoveAddressType[], bigint[]]> {
         arguments_decoded: [MoveAddressType[], bigint[]];
         type_arguments: [];
@@ -3539,10 +3572,6 @@ export declare namespace aptos_account {
         ];
         type_arguments: [];
     }
-    interface CreateAccountPayload extends TypedFunctionPayload<[MoveAddressType]> {
-        arguments_decoded: [MoveAddressType];
-        type_arguments: [];
-    }
     interface FungibleTransferOnlyPayload extends TypedFunctionPayload<[MoveAddressType, bigint]> {
         arguments_decoded: [MoveAddressType, bigint];
         type_arguments: [];
@@ -3551,10 +3580,6 @@ export declare namespace aptos_account {
         arguments_decoded: [boolean];
         type_arguments: [];
     }
-    interface TransferPayload extends TypedFunctionPayload<[MoveAddressType, bigint]> {
-        arguments_decoded: [MoveAddressType, bigint];
-        type_arguments: [];
-    }
     interface TransferCoinsPayload<T0 = any> extends TypedFunctionPayload<[MoveAddressType, bigint]> {
         arguments_decoded: [MoveAddressType, bigint];
         type_arguments: [string];
@@ -3580,20 +3605,6 @@ export declare namespace bn254_algebra {
         const TYPE_QNAME = "0x1::bn254_algebra::FormatFq12LscLsb";
         function type(): TypeDescriptor<FormatFq12LscLsb>;
     }
-    interface FormatFqLsb {
-        dummy_field: boolean;
-    }
-    namespace FormatFqLsb {
-        const TYPE_QNAME = "0x1::bn254_algebra::FormatFqLsb";
-        function type(): TypeDescriptor<FormatFqLsb>;
-    }
-    interface FormatFqMsb {
-        dummy_field: boolean;
-    }
-    namespace FormatFqMsb {
-        const TYPE_QNAME = "0x1::bn254_algebra::FormatFqMsb";
-        function type(): TypeDescriptor<FormatFqMsb>;
-    }
     interface FormatFrLsb {
         dummy_field: boolean;
     }
@@ -3643,13 +3654,6 @@ export declare namespace bn254_algebra {
         const TYPE_QNAME = "0x1::bn254_algebra::FormatGt";
         function type(): TypeDescriptor<FormatGt>;
     }
-    interface Fq {
-        dummy_field: boolean;
-    }
-    namespace Fq {
-        const TYPE_QNAME = "0x1::bn254_algebra::Fq";
-        function type(): TypeDescriptor<Fq>;
-    }
     interface Fq12 {
         dummy_field: boolean;
     }
@@ -3685,6 +3689,27 @@ export declare namespace bn254_algebra {
         const TYPE_QNAME = "0x1::bn254_algebra::Gt";
         function type(): TypeDescriptor<Gt>;
     }
+    interface FormatFqLsb {
+        dummy_field: boolean;
+    }
+    namespace FormatFqLsb {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatFqLsb";
+        function type(): TypeDescriptor<FormatFqLsb>;
+    }
+    interface FormatFqMsb {
+        dummy_field: boolean;
+    }
+    namespace FormatFqMsb {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatFqMsb";
+        function type(): TypeDescriptor<FormatFqMsb>;
+    }
+    interface Fq {
+        dummy_field: boolean;
+    }
+    namespace Fq {
+        const TYPE_QNAME = "0x1::bn254_algebra::Fq";
+        function type(): TypeDescriptor<Fq>;
+    }
     namespace entry { }
     namespace view { }
 }
@@ -3897,6 +3922,20 @@ export declare class fungible_asset extends AptosBaseProcessor {
     onEventWithdrawEvent(func: (event: fungible_asset.WithdrawEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): fungible_asset;
 }
 export declare namespace fungible_asset {
+    interface TransferRef {
+        metadata: object$.Object<fungible_asset.Metadata>;
+    }
+    namespace TransferRef {
+        const TYPE_QNAME = "0x1::fungible_asset::TransferRef";
+        function type(): TypeDescriptor<TransferRef>;
+    }
+    interface Untransferable {
+        dummy_field: boolean;
+    }
+    namespace Untransferable {
+        const TYPE_QNAME = "0x1::fungible_asset::Untransferable";
+        function type(): TypeDescriptor<Untransferable>;
+    }
     interface BurnRef {
         metadata: object$.Object<fungible_asset.Metadata>;
     }
@@ -4039,20 +4078,6 @@ export declare namespace fungible_asset {
         const TYPE_QNAME = "0x1::fungible_asset::Supply";
         function type(): TypeDescriptor<Supply>;
     }
-    interface TransferRef {
-        metadata: object$.Object<fungible_asset.Metadata>;
-    }
-    namespace TransferRef {
-        const TYPE_QNAME = "0x1::fungible_asset::TransferRef";
-        function type(): TypeDescriptor<TransferRef>;
-    }
-    interface Untransferable {
-        dummy_field: boolean;
-    }
-    namespace Untransferable {
-        const TYPE_QNAME = "0x1::fungible_asset::Untransferable";
-        function type(): TypeDescriptor<Untransferable>;
-    }
     interface Withdraw {
         store: MoveAddressType;
         amount: bigint;
@@ -4087,10 +4112,18 @@ export declare namespace fungible_asset {
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
-        function balance<T0 = any>(client: Aptos, request: {
+        function isUntransferable<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
             functionArguments: [object$.Object<T0>];
-        }, version?: bigint): Promise<[bigint]>;
+        }, version?: bigint): Promise<[boolean]>;
+        function name<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[string]>;
+        function symbol$<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[string]>;
         function decimals<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
             functionArguments: [object$.Object<T0>];
@@ -4099,6 +4132,18 @@ export declare namespace fungible_asset {
             typeArguments: [MoveStructId];
             functionArguments: [object$.Object<T0>];
         }, version?: bigint): Promise<[string]>;
+        function projectUri<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[string]>;
+        function balance<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[bigint]>;
+        function metadata<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[fungible_asset.Metadata]>;
         function isBalanceAtLeast<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
             functionArguments: [object$.Object<T0>, bigint];
@@ -4111,26 +4156,10 @@ export declare namespace fungible_asset {
             typeArguments: [MoveStructId];
             functionArguments: [object$.Object<T0>];
         }, version?: bigint): Promise<[boolean]>;
-        function isUntransferable<T0 = any>(client: Aptos, request: {
-            typeArguments: [MoveStructId];
-            functionArguments: [object$.Object<T0>];
-        }, version?: bigint): Promise<[boolean]>;
         function maximum<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
             functionArguments: [object$.Object<T0>];
         }, version?: bigint): Promise<[option.Option<bigint>]>;
-        function metadata<T0 = any>(client: Aptos, request: {
-            typeArguments: [MoveStructId];
-            functionArguments: [object$.Object<T0>];
-        }, version?: bigint): Promise<[fungible_asset.Metadata]>;
-        function name<T0 = any>(client: Aptos, request: {
-            typeArguments: [MoveStructId];
-            functionArguments: [object$.Object<T0>];
-        }, version?: bigint): Promise<[string]>;
-        function projectUri<T0 = any>(client: Aptos, request: {
-            typeArguments: [MoveStructId];
-            functionArguments: [object$.Object<T0>];
-        }, version?: bigint): Promise<[string]>;
         function storeExists(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[boolean]>;
@@ -4142,10 +4171,6 @@ export declare namespace fungible_asset {
             typeArguments: [MoveStructId];
             functionArguments: [object$.Object<T0>];
         }, version?: bigint): Promise<[option.Option<bigint>]>;
-        function symbol$<T0 = any>(client: Aptos, request: {
-            typeArguments: [MoveStructId];
-            functionArguments: [object$.Object<T0>];
-        }, version?: bigint): Promise<[string]>;
     }
     interface TransferPayload<T0 = any> extends TypedFunctionPayload<[
         object$.Object<T0>,
@@ -4194,31 +4219,39 @@ export declare class delegation_pool extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): delegation_pool;
+    onEntryWithdraw(func: (call: delegation_pool.WithdrawPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEntryCreateProposal(func: (call: delegation_pool.CreateProposalPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEntryVote(func: (call: delegation_pool.VotePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntryAddStake(func: (call: delegation_pool.AddStakePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEntryReactivateStake(func: (call: delegation_pool.ReactivateStakePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEntrySetDelegatedVoter(func: (call: delegation_pool.SetDelegatedVoterPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEntrySetOperator(func: (call: delegation_pool.SetOperatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEntryUnlock(func: (call: delegation_pool.UnlockPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntryAllowlistDelegator(func: (call: delegation_pool.AllowlistDelegatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
-    onEntryCreateProposal(func: (call: delegation_pool.CreateProposalPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntryDelegateVotingPower(func: (call: delegation_pool.DelegateVotingPowerPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntryDisableDelegatorsAllowlisting(func: (call: delegation_pool.DisableDelegatorsAllowlistingPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntryEnableDelegatorsAllowlisting(func: (call: delegation_pool.EnableDelegatorsAllowlistingPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntryEnablePartialGovernanceVoting(func: (call: delegation_pool.EnablePartialGovernanceVotingPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntryEvictDelegator(func: (call: delegation_pool.EvictDelegatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntryInitializeDelegationPool(func: (call: delegation_pool.InitializeDelegationPoolPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
-    onEntryReactivateStake(func: (call: delegation_pool.ReactivateStakePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntryRemoveDelegatorFromAllowlist(func: (call: delegation_pool.RemoveDelegatorFromAllowlistPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntrySetBeneficiaryForOperator(func: (call: delegation_pool.SetBeneficiaryForOperatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
-    onEntrySetDelegatedVoter(func: (call: delegation_pool.SetDelegatedVoterPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
-    onEntrySetOperator(func: (call: delegation_pool.SetOperatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntrySynchronizeDelegationPool(func: (call: delegation_pool.SynchronizeDelegationPoolPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
-    onEntryUnlock(func: (call: delegation_pool.UnlockPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntryUpdateCommissionPercentage(func: (call: delegation_pool.UpdateCommissionPercentagePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
-    onEntryVote(func: (call: delegation_pool.VotePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
-    onEntryWithdraw(func: (call: delegation_pool.WithdrawPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventCreateProposal(func: (event: delegation_pool.CreateProposalInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventCreateProposalEvent(func: (event: delegation_pool.CreateProposalEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventVote(func: (event: delegation_pool.VoteInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventVoteEvent(func: (event: delegation_pool.VoteEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventAddStake(func: (event: delegation_pool.AddStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventAddStakeEvent(func: (event: delegation_pool.AddStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventReactivateStake(func: (event: delegation_pool.ReactivateStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventReactivateStakeEvent(func: (event: delegation_pool.ReactivateStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventUnlockStake(func: (event: delegation_pool.UnlockStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventUnlockStakeEvent(func: (event: delegation_pool.UnlockStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventWithdrawStake(func: (event: delegation_pool.WithdrawStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventWithdrawStakeEvent(func: (event: delegation_pool.WithdrawStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventAllowlistDelegator(func: (event: delegation_pool.AllowlistDelegatorInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventCommissionPercentageChange(func: (event: delegation_pool.CommissionPercentageChangeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
-    onEventCreateProposal(func: (event: delegation_pool.CreateProposalInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
-    onEventCreateProposalEvent(func: (event: delegation_pool.CreateProposalEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventDelegateVotingPower(func: (event: delegation_pool.DelegateVotingPowerInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventDelegateVotingPowerEvent(func: (event: delegation_pool.DelegateVotingPowerEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventDisableDelegatorsAllowlisting(func: (event: delegation_pool.DisableDelegatorsAllowlistingInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
@@ -4226,31 +4259,79 @@ export declare class delegation_pool extends AptosBaseProcessor {
     onEventDistributeCommissionEvent(func: (event: delegation_pool.DistributeCommissionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventEnableDelegatorsAllowlisting(func: (event: delegation_pool.EnableDelegatorsAllowlistingInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventEvictDelegator(func: (event: delegation_pool.EvictDelegatorInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
-    onEventReactivateStake(func: (event: delegation_pool.ReactivateStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
-    onEventReactivateStakeEvent(func: (event: delegation_pool.ReactivateStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventRemoveDelegatorFromAllowlist(func: (event: delegation_pool.RemoveDelegatorFromAllowlistInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventSetBeneficiaryForOperator(func: (event: delegation_pool.SetBeneficiaryForOperatorInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
-    onEventUnlockStake(func: (event: delegation_pool.UnlockStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
-    onEventUnlockStakeEvent(func: (event: delegation_pool.UnlockStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
-    onEventVote(func: (event: delegation_pool.VoteInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
-    onEventVoteEvent(func: (event: delegation_pool.VoteEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
-    onEventWithdrawStake(func: (event: delegation_pool.WithdrawStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
-    onEventWithdrawStakeEvent(func: (event: delegation_pool.WithdrawStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
 }
 export declare namespace delegation_pool {
-    interface AddStake {
-        pool_address: MoveAddressType;
-        delegator_address: MoveAddressType;
-        amount_added: bigint;
-        add_stake_fee: bigint;
+    interface CreateProposal {
+        proposal_id: bigint;
+        voter: MoveAddressType;
+        delegation_pool: MoveAddressType;
     }
-    namespace AddStake {
-        const TYPE_QNAME = "0x1::delegation_pool::AddStake";
-        function type(): TypeDescriptor<AddStake>;
+    namespace CreateProposal {
+        const TYPE_QNAME = "0x1::delegation_pool::CreateProposal";
+        function type(): TypeDescriptor<CreateProposal>;
     }
-    interface AddStakeInstance extends TypedEventInstance<AddStake> {
-        data_decoded: AddStake;
-        type_arguments: [];
+    interface CreateProposalInstance extends TypedEventInstance<CreateProposal> {
+        data_decoded: CreateProposal;
+        type_arguments: [];
+    }
+    interface CreateProposalEvent {
+        proposal_id: bigint;
+        voter: MoveAddressType;
+        delegation_pool: MoveAddressType;
+    }
+    namespace CreateProposalEvent {
+        const TYPE_QNAME = "0x1::delegation_pool::CreateProposalEvent";
+        function type(): TypeDescriptor<CreateProposalEvent>;
+    }
+    interface CreateProposalEventInstance extends TypedEventInstance<CreateProposalEvent> {
+        data_decoded: CreateProposalEvent;
+        type_arguments: [];
+    }
+    interface Vote {
+        voter: MoveAddressType;
+        proposal_id: bigint;
+        delegation_pool: MoveAddressType;
+        num_votes: bigint;
+        should_pass: boolean;
+    }
+    namespace Vote {
+        const TYPE_QNAME = "0x1::delegation_pool::Vote";
+        function type(): TypeDescriptor<Vote>;
+    }
+    interface VoteInstance extends TypedEventInstance<Vote> {
+        data_decoded: Vote;
+        type_arguments: [];
+    }
+    interface VoteEvent {
+        voter: MoveAddressType;
+        proposal_id: bigint;
+        delegation_pool: MoveAddressType;
+        num_votes: bigint;
+        should_pass: boolean;
+    }
+    namespace VoteEvent {
+        const TYPE_QNAME = "0x1::delegation_pool::VoteEvent";
+        function type(): TypeDescriptor<VoteEvent>;
+    }
+    interface VoteEventInstance extends TypedEventInstance<VoteEvent> {
+        data_decoded: VoteEvent;
+        type_arguments: [];
+    }
+    interface AddStake {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+        amount_added: bigint;
+        add_stake_fee: bigint;
+    }
+    namespace AddStake {
+        const TYPE_QNAME = "0x1::delegation_pool::AddStake";
+        function type(): TypeDescriptor<AddStake>;
+    }
+    interface AddStakeInstance extends TypedEventInstance<AddStake> {
+        data_decoded: AddStake;
+        type_arguments: [];
     }
     interface AddStakeEvent {
         pool_address: MoveAddressType;
@@ -4266,6 +4347,84 @@ export declare namespace delegation_pool {
         data_decoded: AddStakeEvent;
         type_arguments: [];
     }
+    interface ReactivateStake {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+        amount_reactivated: bigint;
+    }
+    namespace ReactivateStake {
+        const TYPE_QNAME = "0x1::delegation_pool::ReactivateStake";
+        function type(): TypeDescriptor<ReactivateStake>;
+    }
+    interface ReactivateStakeInstance extends TypedEventInstance<ReactivateStake> {
+        data_decoded: ReactivateStake;
+        type_arguments: [];
+    }
+    interface ReactivateStakeEvent {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+        amount_reactivated: bigint;
+    }
+    namespace ReactivateStakeEvent {
+        const TYPE_QNAME = "0x1::delegation_pool::ReactivateStakeEvent";
+        function type(): TypeDescriptor<ReactivateStakeEvent>;
+    }
+    interface ReactivateStakeEventInstance extends TypedEventInstance<ReactivateStakeEvent> {
+        data_decoded: ReactivateStakeEvent;
+        type_arguments: [];
+    }
+    interface UnlockStake {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+        amount_unlocked: bigint;
+    }
+    namespace UnlockStake {
+        const TYPE_QNAME = "0x1::delegation_pool::UnlockStake";
+        function type(): TypeDescriptor<UnlockStake>;
+    }
+    interface UnlockStakeInstance extends TypedEventInstance<UnlockStake> {
+        data_decoded: UnlockStake;
+        type_arguments: [];
+    }
+    interface UnlockStakeEvent {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+        amount_unlocked: bigint;
+    }
+    namespace UnlockStakeEvent {
+        const TYPE_QNAME = "0x1::delegation_pool::UnlockStakeEvent";
+        function type(): TypeDescriptor<UnlockStakeEvent>;
+    }
+    interface UnlockStakeEventInstance extends TypedEventInstance<UnlockStakeEvent> {
+        data_decoded: UnlockStakeEvent;
+        type_arguments: [];
+    }
+    interface WithdrawStake {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+        amount_withdrawn: bigint;
+    }
+    namespace WithdrawStake {
+        const TYPE_QNAME = "0x1::delegation_pool::WithdrawStake";
+        function type(): TypeDescriptor<WithdrawStake>;
+    }
+    interface WithdrawStakeInstance extends TypedEventInstance<WithdrawStake> {
+        data_decoded: WithdrawStake;
+        type_arguments: [];
+    }
+    interface WithdrawStakeEvent {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+        amount_withdrawn: bigint;
+    }
+    namespace WithdrawStakeEvent {
+        const TYPE_QNAME = "0x1::delegation_pool::WithdrawStakeEvent";
+        function type(): TypeDescriptor<WithdrawStakeEvent>;
+    }
+    interface WithdrawStakeEventInstance extends TypedEventInstance<WithdrawStakeEvent> {
+        data_decoded: WithdrawStakeEvent;
+        type_arguments: [];
+    }
     interface AllowlistDelegator {
         pool_address: MoveAddressType;
         delegator_address: MoveAddressType;
@@ -4298,32 +4457,6 @@ export declare namespace delegation_pool {
         data_decoded: CommissionPercentageChange;
         type_arguments: [];
     }
-    interface CreateProposal {
-        proposal_id: bigint;
-        voter: MoveAddressType;
-        delegation_pool: MoveAddressType;
-    }
-    namespace CreateProposal {
-        const TYPE_QNAME = "0x1::delegation_pool::CreateProposal";
-        function type(): TypeDescriptor<CreateProposal>;
-    }
-    interface CreateProposalInstance extends TypedEventInstance<CreateProposal> {
-        data_decoded: CreateProposal;
-        type_arguments: [];
-    }
-    interface CreateProposalEvent {
-        proposal_id: bigint;
-        voter: MoveAddressType;
-        delegation_pool: MoveAddressType;
-    }
-    namespace CreateProposalEvent {
-        const TYPE_QNAME = "0x1::delegation_pool::CreateProposalEvent";
-        function type(): TypeDescriptor<CreateProposalEvent>;
-    }
-    interface CreateProposalEventInstance extends TypedEventInstance<CreateProposalEvent> {
-        data_decoded: CreateProposalEvent;
-        type_arguments: [];
-    }
     interface DelegateVotingPower {
         pool_address: MoveAddressType;
         delegator: MoveAddressType;
@@ -4483,32 +4616,6 @@ export declare namespace delegation_pool {
         const TYPE_QNAME = "0x1::delegation_pool::ObservedLockupCycle";
         function type(): TypeDescriptor<ObservedLockupCycle>;
     }
-    interface ReactivateStake {
-        pool_address: MoveAddressType;
-        delegator_address: MoveAddressType;
-        amount_reactivated: bigint;
-    }
-    namespace ReactivateStake {
-        const TYPE_QNAME = "0x1::delegation_pool::ReactivateStake";
-        function type(): TypeDescriptor<ReactivateStake>;
-    }
-    interface ReactivateStakeInstance extends TypedEventInstance<ReactivateStake> {
-        data_decoded: ReactivateStake;
-        type_arguments: [];
-    }
-    interface ReactivateStakeEvent {
-        pool_address: MoveAddressType;
-        delegator_address: MoveAddressType;
-        amount_reactivated: bigint;
-    }
-    namespace ReactivateStakeEvent {
-        const TYPE_QNAME = "0x1::delegation_pool::ReactivateStakeEvent";
-        function type(): TypeDescriptor<ReactivateStakeEvent>;
-    }
-    interface ReactivateStakeEventInstance extends TypedEventInstance<ReactivateStakeEvent> {
-        data_decoded: ReactivateStakeEvent;
-        type_arguments: [];
-    }
     interface RemoveDelegatorFromAllowlist {
         pool_address: MoveAddressType;
         delegator_address: MoveAddressType;
@@ -4534,47 +4641,6 @@ export declare namespace delegation_pool {
         data_decoded: SetBeneficiaryForOperator;
         type_arguments: [];
     }
-    interface UnlockStake {
-        pool_address: MoveAddressType;
-        delegator_address: MoveAddressType;
-        amount_unlocked: bigint;
-    }
-    namespace UnlockStake {
-        const TYPE_QNAME = "0x1::delegation_pool::UnlockStake";
-        function type(): TypeDescriptor<UnlockStake>;
-    }
-    interface UnlockStakeInstance extends TypedEventInstance<UnlockStake> {
-        data_decoded: UnlockStake;
-        type_arguments: [];
-    }
-    interface UnlockStakeEvent {
-        pool_address: MoveAddressType;
-        delegator_address: MoveAddressType;
-        amount_unlocked: bigint;
-    }
-    namespace UnlockStakeEvent {
-        const TYPE_QNAME = "0x1::delegation_pool::UnlockStakeEvent";
-        function type(): TypeDescriptor<UnlockStakeEvent>;
-    }
-    interface UnlockStakeEventInstance extends TypedEventInstance<UnlockStakeEvent> {
-        data_decoded: UnlockStakeEvent;
-        type_arguments: [];
-    }
-    interface Vote {
-        voter: MoveAddressType;
-        proposal_id: bigint;
-        delegation_pool: MoveAddressType;
-        num_votes: bigint;
-        should_pass: boolean;
-    }
-    namespace Vote {
-        const TYPE_QNAME = "0x1::delegation_pool::Vote";
-        function type(): TypeDescriptor<Vote>;
-    }
-    interface VoteInstance extends TypedEventInstance<Vote> {
-        data_decoded: Vote;
-        type_arguments: [];
-    }
     interface VoteDelegation {
         voter: MoveAddressType;
         pending_voter: MoveAddressType;
@@ -4584,21 +4650,6 @@ export declare namespace delegation_pool {
         const TYPE_QNAME = "0x1::delegation_pool::VoteDelegation";
         function type(): TypeDescriptor<VoteDelegation>;
     }
-    interface VoteEvent {
-        voter: MoveAddressType;
-        proposal_id: bigint;
-        delegation_pool: MoveAddressType;
-        num_votes: bigint;
-        should_pass: boolean;
-    }
-    namespace VoteEvent {
-        const TYPE_QNAME = "0x1::delegation_pool::VoteEvent";
-        function type(): TypeDescriptor<VoteEvent>;
-    }
-    interface VoteEventInstance extends TypedEventInstance<VoteEvent> {
-        data_decoded: VoteEvent;
-        type_arguments: [];
-    }
     interface VotingRecordKey {
         voter: MoveAddressType;
         proposal_id: bigint;
@@ -4607,44 +4658,42 @@ export declare namespace delegation_pool {
         const TYPE_QNAME = "0x1::delegation_pool::VotingRecordKey";
         function type(): TypeDescriptor<VotingRecordKey>;
     }
-    interface WithdrawStake {
-        pool_address: MoveAddressType;
-        delegator_address: MoveAddressType;
-        amount_withdrawn: bigint;
-    }
-    namespace WithdrawStake {
-        const TYPE_QNAME = "0x1::delegation_pool::WithdrawStake";
-        function type(): TypeDescriptor<WithdrawStake>;
-    }
-    interface WithdrawStakeInstance extends TypedEventInstance<WithdrawStake> {
-        data_decoded: WithdrawStake;
-        type_arguments: [];
-    }
-    interface WithdrawStakeEvent {
-        pool_address: MoveAddressType;
-        delegator_address: MoveAddressType;
-        amount_withdrawn: bigint;
-    }
-    namespace WithdrawStakeEvent {
-        const TYPE_QNAME = "0x1::delegation_pool::WithdrawStakeEvent";
-        function type(): TypeDescriptor<WithdrawStakeEvent>;
-    }
-    interface WithdrawStakeEventInstance extends TypedEventInstance<WithdrawStakeEvent> {
-        data_decoded: WithdrawStakeEvent;
-        type_arguments: [];
-    }
     namespace entry {
+        function withdraw(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createProposal(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, string, string, boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function vote(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint, bigint, boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function addStake(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType, bigint];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function allowlistDelegator(client: Aptos, account: AptosAccount, request: {
+        function reactivateStake(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setDelegatedVoter(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function createProposal(client: Aptos, account: AptosAccount, request: {
+        function setOperator(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
-            functionArguments: [MoveAddressType, string, string, string, boolean];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function unlock(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function allowlistDelegator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function delegateVotingPower(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
@@ -4670,10 +4719,6 @@ export declare namespace delegation_pool {
             typeArguments: [];
             functionArguments: [bigint, string];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function reactivateStake(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [];
-            functionArguments: [MoveAddressType, bigint];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function removeDelegatorFromAllowlist(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType];
@@ -4682,36 +4727,25 @@ export declare namespace delegation_pool {
             typeArguments: [];
             functionArguments: [MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function setDelegatedVoter(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [];
-            functionArguments: [MoveAddressType];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function setOperator(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [];
-            functionArguments: [MoveAddressType];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function synchronizeDelegationPool(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function unlock(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [];
-            functionArguments: [MoveAddressType, bigint];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function updateCommissionPercentage(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [bigint];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function vote(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [];
-            functionArguments: [MoveAddressType, bigint, bigint, boolean];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function withdraw(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [];
-            functionArguments: [MoveAddressType, bigint];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
+        function partialGovernanceVotingEnabled(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+        function getOwnedPoolAddress(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function getStake(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[bigint, bigint, bigint]>;
         function allowlistingEnabled(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[boolean]>;
@@ -4751,15 +4785,12 @@ export declare namespace delegation_pool {
         function getExpectedStakePoolAddress(client: Aptos, request: {
             functionArguments: [MoveAddressType, string];
         }, version?: bigint): Promise<[MoveAddressType]>;
-        function getOwnedPoolAddress(client: Aptos, request: {
-            functionArguments: [MoveAddressType];
-        }, version?: bigint): Promise<[MoveAddressType]>;
         function getPendingWithdrawal(client: Aptos, request: {
             functionArguments: [MoveAddressType, MoveAddressType];
         }, version?: bigint): Promise<[boolean, bigint]>;
-        function getStake(client: Aptos, request: {
-            functionArguments: [MoveAddressType, MoveAddressType];
-        }, version?: bigint): Promise<[bigint, bigint, bigint]>;
+        function operatorCommissionPercentage(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
         function isNextCommissionPercentageEffective(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[boolean]>;
@@ -4767,38 +4798,56 @@ export declare namespace delegation_pool {
         function observedLockupCycle(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function operatorCommissionPercentage(client: Aptos, request: {
-            functionArguments: [MoveAddressType];
-        }, version?: bigint): Promise<[bigint]>;
         function operatorCommissionPercentageNextLockupCycle(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
         function ownerCapExists(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[boolean]>;
-        function partialGovernanceVotingEnabled(client: Aptos, request: {
-            functionArguments: [MoveAddressType];
-        }, version?: bigint): Promise<[boolean]>;
         function shareholdersCountActivePool(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
     }
+    interface WithdrawPayload extends TypedFunctionPayload<[MoveAddressType, bigint]> {
+        arguments_decoded: [MoveAddressType, bigint];
+        type_arguments: [];
+    }
+    interface CreateProposalPayload extends TypedFunctionPayload<[
+        MoveAddressType,
+        string,
+        string,
+        string,
+        boolean
+    ]> {
+        arguments_decoded: [MoveAddressType, string, string, string, boolean];
+        type_arguments: [];
+    }
+    interface VotePayload extends TypedFunctionPayload<[MoveAddressType, bigint, bigint, boolean]> {
+        arguments_decoded: [MoveAddressType, bigint, bigint, boolean];
+        type_arguments: [];
+    }
     interface AddStakePayload extends TypedFunctionPayload<[MoveAddressType, bigint]> {
         arguments_decoded: [MoveAddressType, bigint];
         type_arguments: [];
     }
-    interface AllowlistDelegatorPayload extends TypedFunctionPayload<[MoveAddressType]> {
+    interface ReactivateStakePayload extends TypedFunctionPayload<[MoveAddressType, bigint]> {
+        arguments_decoded: [MoveAddressType, bigint];
+        type_arguments: [];
+    }
+    interface SetDelegatedVoterPayload extends TypedFunctionPayload<[MoveAddressType]> {
         arguments_decoded: [MoveAddressType];
         type_arguments: [];
     }
-    interface CreateProposalPayload extends TypedFunctionPayload<[
-        MoveAddressType,
-        string,
-        string,
-        string,
-        boolean
-    ]> {
-        arguments_decoded: [MoveAddressType, string, string, string, boolean];
+    interface SetOperatorPayload extends TypedFunctionPayload<[MoveAddressType]> {
+        arguments_decoded: [MoveAddressType];
+        type_arguments: [];
+    }
+    interface UnlockPayload extends TypedFunctionPayload<[MoveAddressType, bigint]> {
+        arguments_decoded: [MoveAddressType, bigint];
+        type_arguments: [];
+    }
+    interface AllowlistDelegatorPayload extends TypedFunctionPayload<[MoveAddressType]> {
+        arguments_decoded: [MoveAddressType];
         type_arguments: [];
     }
     interface DelegateVotingPowerPayload extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
@@ -4825,10 +4874,6 @@ export declare namespace delegation_pool {
         arguments_decoded: [bigint, string];
         type_arguments: [];
     }
-    interface ReactivateStakePayload extends TypedFunctionPayload<[MoveAddressType, bigint]> {
-        arguments_decoded: [MoveAddressType, bigint];
-        type_arguments: [];
-    }
     interface RemoveDelegatorFromAllowlistPayload extends TypedFunctionPayload<[MoveAddressType]> {
         arguments_decoded: [MoveAddressType];
         type_arguments: [];
@@ -4837,34 +4882,14 @@ export declare namespace delegation_pool {
         arguments_decoded: [MoveAddressType];
         type_arguments: [];
     }
-    interface SetDelegatedVoterPayload extends TypedFunctionPayload<[MoveAddressType]> {
-        arguments_decoded: [MoveAddressType];
-        type_arguments: [];
-    }
-    interface SetOperatorPayload extends TypedFunctionPayload<[MoveAddressType]> {
-        arguments_decoded: [MoveAddressType];
-        type_arguments: [];
-    }
     interface SynchronizeDelegationPoolPayload extends TypedFunctionPayload<[MoveAddressType]> {
         arguments_decoded: [MoveAddressType];
         type_arguments: [];
     }
-    interface UnlockPayload extends TypedFunctionPayload<[MoveAddressType, bigint]> {
-        arguments_decoded: [MoveAddressType, bigint];
-        type_arguments: [];
-    }
     interface UpdateCommissionPercentagePayload extends TypedFunctionPayload<[bigint]> {
         arguments_decoded: [bigint];
         type_arguments: [];
     }
-    interface VotePayload extends TypedFunctionPayload<[MoveAddressType, bigint, bigint, boolean]> {
-        arguments_decoded: [MoveAddressType, bigint, bigint, boolean];
-        type_arguments: [];
-    }
-    interface WithdrawPayload extends TypedFunctionPayload<[MoveAddressType, bigint]> {
-        arguments_decoded: [MoveAddressType, bigint];
-        type_arguments: [];
-    }
 }
 export declare namespace keyless_account {
     interface Configuration {
@@ -4881,6 +4906,13 @@ export declare namespace keyless_account {
         const TYPE_QNAME = "0x1::keyless_account::Configuration";
         function type(): TypeDescriptor<Configuration>;
     }
+    interface Group {
+        dummy_field: boolean;
+    }
+    namespace Group {
+        const TYPE_QNAME = "0x1::keyless_account::Group";
+        function type(): TypeDescriptor<Group>;
+    }
     interface Groth16VerificationKey {
         alpha_g1: string;
         beta_g2: string;
@@ -4892,13 +4924,6 @@ export declare namespace keyless_account {
         const TYPE_QNAME = "0x1::keyless_account::Groth16VerificationKey";
         function type(): TypeDescriptor<Groth16VerificationKey>;
     }
-    interface Group {
-        dummy_field: boolean;
-    }
-    namespace Group {
-        const TYPE_QNAME = "0x1::keyless_account::Group";
-        function type(): TypeDescriptor<Group>;
-    }
     namespace entry { }
     namespace view { }
 }
@@ -5020,31 +5045,24 @@ export declare class aptos_governance extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): aptos_governance;
+    onEntryCreateProposal(func: (call: aptos_governance.CreateProposalPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
+    onEntryCreateProposalV2(func: (call: aptos_governance.CreateProposalV2Payload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
+    onEntryVote(func: (call: aptos_governance.VotePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
+    onEntryReconfigure(func: (call: aptos_governance.ReconfigurePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
     onEntryAddApprovedScriptHashScript(func: (call: aptos_governance.AddApprovedScriptHashScriptPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
     onEntryBatchPartialVote(func: (call: aptos_governance.BatchPartialVotePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
     onEntryBatchVote(func: (call: aptos_governance.BatchVotePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
-    onEntryCreateProposal(func: (call: aptos_governance.CreateProposalPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
-    onEntryCreateProposalV2(func: (call: aptos_governance.CreateProposalV2Payload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
     onEntryForceEndEpoch(func: (call: aptos_governance.ForceEndEpochPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
     onEntryForceEndEpochTestOnly(func: (call: aptos_governance.ForceEndEpochTestOnlyPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
     onEntryPartialVote(func: (call: aptos_governance.PartialVotePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
-    onEntryReconfigure(func: (call: aptos_governance.ReconfigurePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
-    onEntryVote(func: (call: aptos_governance.VotePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
     onEventCreateProposal(func: (event: aptos_governance.CreateProposalInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
     onEventCreateProposalEvent(func: (event: aptos_governance.CreateProposalEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
-    onEventUpdateConfig(func: (event: aptos_governance.UpdateConfigInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
-    onEventUpdateConfigEvent(func: (event: aptos_governance.UpdateConfigEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
     onEventVote(func: (event: aptos_governance.VoteInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
     onEventVoteEvent(func: (event: aptos_governance.VoteEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
+    onEventUpdateConfig(func: (event: aptos_governance.UpdateConfigInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
+    onEventUpdateConfigEvent(func: (event: aptos_governance.UpdateConfigEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
 }
 export declare namespace aptos_governance {
-    interface ApprovedExecutionHashes {
-        hashes: simple_map.SimpleMap<bigint, string>;
-    }
-    namespace ApprovedExecutionHashes {
-        const TYPE_QNAME = "0x1::aptos_governance::ApprovedExecutionHashes";
-        function type(): TypeDescriptor<ApprovedExecutionHashes>;
-    }
     interface CreateProposal {
         proposer: MoveAddressType;
         stake_pool: MoveAddressType;
@@ -5075,6 +5093,43 @@ export declare namespace aptos_governance {
         data_decoded: CreateProposalEvent;
         type_arguments: [];
     }
+    interface Vote {
+        proposal_id: bigint;
+        voter: MoveAddressType;
+        stake_pool: MoveAddressType;
+        num_votes: bigint;
+        should_pass: boolean;
+    }
+    namespace Vote {
+        const TYPE_QNAME = "0x1::aptos_governance::Vote";
+        function type(): TypeDescriptor<Vote>;
+    }
+    interface VoteInstance extends TypedEventInstance<Vote> {
+        data_decoded: Vote;
+        type_arguments: [];
+    }
+    interface VoteEvent {
+        proposal_id: bigint;
+        voter: MoveAddressType;
+        stake_pool: MoveAddressType;
+        num_votes: bigint;
+        should_pass: boolean;
+    }
+    namespace VoteEvent {
+        const TYPE_QNAME = "0x1::aptos_governance::VoteEvent";
+        function type(): TypeDescriptor<VoteEvent>;
+    }
+    interface VoteEventInstance extends TypedEventInstance<VoteEvent> {
+        data_decoded: VoteEvent;
+        type_arguments: [];
+    }
+    interface ApprovedExecutionHashes {
+        hashes: simple_map.SimpleMap<bigint, string>;
+    }
+    namespace ApprovedExecutionHashes {
+        const TYPE_QNAME = "0x1::aptos_governance::ApprovedExecutionHashes";
+        function type(): TypeDescriptor<ApprovedExecutionHashes>;
+    }
     interface GovernanceConfig {
         min_voting_threshold: bigint;
         required_proposer_stake: bigint;
@@ -5134,36 +5189,6 @@ export declare namespace aptos_governance {
         data_decoded: UpdateConfigEvent;
         type_arguments: [];
     }
-    interface Vote {
-        proposal_id: bigint;
-        voter: MoveAddressType;
-        stake_pool: MoveAddressType;
-        num_votes: bigint;
-        should_pass: boolean;
-    }
-    namespace Vote {
-        const TYPE_QNAME = "0x1::aptos_governance::Vote";
-        function type(): TypeDescriptor<Vote>;
-    }
-    interface VoteInstance extends TypedEventInstance<Vote> {
-        data_decoded: Vote;
-        type_arguments: [];
-    }
-    interface VoteEvent {
-        proposal_id: bigint;
-        voter: MoveAddressType;
-        stake_pool: MoveAddressType;
-        num_votes: bigint;
-        should_pass: boolean;
-    }
-    namespace VoteEvent {
-        const TYPE_QNAME = "0x1::aptos_governance::VoteEvent";
-        function type(): TypeDescriptor<VoteEvent>;
-    }
-    interface VoteEventInstance extends TypedEventInstance<VoteEvent> {
-        data_decoded: VoteEvent;
-        type_arguments: [];
-    }
     interface VotingRecords {
         votes: table.Table<aptos_governance.RecordKey, boolean>;
     }
@@ -5179,6 +5204,22 @@ export declare namespace aptos_governance {
         function type(): TypeDescriptor<VotingRecordsV2>;
     }
     namespace entry {
+        function createProposal(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, string, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createProposalV2(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, string, string, boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function vote(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint, boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function reconfigure(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function addApprovedScriptHashScript(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [bigint];
@@ -5191,14 +5232,6 @@ export declare namespace aptos_governance {
             typeArguments: [];
             functionArguments: [MoveAddressType[], bigint, boolean];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function createProposal(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [];
-            functionArguments: [MoveAddressType, string, string, string];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function createProposalV2(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [];
-            functionArguments: [MoveAddressType, string, string, string, boolean];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function forceEndEpoch(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [];
@@ -5211,41 +5244,21 @@ export declare namespace aptos_governance {
             typeArguments: [];
             functionArguments: [MoveAddressType, bigint, bigint, boolean];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function reconfigure(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [];
-            functionArguments: [];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function vote(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [];
-            functionArguments: [MoveAddressType, bigint, boolean];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
+        function getVotingPower(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
         function getMinVotingThreshold(client: Aptos, version?: bigint): Promise<[bigint]>;
         function getRemainingVotingPower(client: Aptos, request: {
             functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[bigint]>;
         function getRequiredProposerStake(client: Aptos, version?: bigint): Promise<[bigint]>;
         function getVotingDurationSecs(client: Aptos, version?: bigint): Promise<[bigint]>;
-        function getVotingPower(client: Aptos, request: {
-            functionArguments: [MoveAddressType];
-        }, version?: bigint): Promise<[bigint]>;
         function hasEntirelyVoted(client: Aptos, request: {
             functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[boolean]>;
     }
-    interface AddApprovedScriptHashScriptPayload extends TypedFunctionPayload<[bigint]> {
-        arguments_decoded: [bigint];
-        type_arguments: [];
-    }
-    interface BatchPartialVotePayload extends TypedFunctionPayload<[MoveAddressType[], bigint, bigint, boolean]> {
-        arguments_decoded: [MoveAddressType[], bigint, bigint, boolean];
-        type_arguments: [];
-    }
-    interface BatchVotePayload extends TypedFunctionPayload<[MoveAddressType[], bigint, boolean]> {
-        arguments_decoded: [MoveAddressType[], bigint, boolean];
-        type_arguments: [];
-    }
     interface CreateProposalPayload extends TypedFunctionPayload<[MoveAddressType, string, string, string]> {
         arguments_decoded: [MoveAddressType, string, string, string];
         type_arguments: [];
@@ -5260,24 +5273,36 @@ export declare namespace aptos_governance {
         arguments_decoded: [MoveAddressType, string, string, string, boolean];
         type_arguments: [];
     }
-    interface ForceEndEpochPayload extends TypedFunctionPayload<[]> {
-        arguments_decoded: [];
+    interface VotePayload extends TypedFunctionPayload<[MoveAddressType, bigint, boolean]> {
+        arguments_decoded: [MoveAddressType, bigint, boolean];
         type_arguments: [];
     }
-    interface ForceEndEpochTestOnlyPayload extends TypedFunctionPayload<[]> {
+    interface ReconfigurePayload extends TypedFunctionPayload<[]> {
         arguments_decoded: [];
         type_arguments: [];
     }
-    interface PartialVotePayload extends TypedFunctionPayload<[MoveAddressType, bigint, bigint, boolean]> {
-        arguments_decoded: [MoveAddressType, bigint, bigint, boolean];
+    interface AddApprovedScriptHashScriptPayload extends TypedFunctionPayload<[bigint]> {
+        arguments_decoded: [bigint];
         type_arguments: [];
     }
-    interface ReconfigurePayload extends TypedFunctionPayload<[]> {
+    interface BatchPartialVotePayload extends TypedFunctionPayload<[MoveAddressType[], bigint, bigint, boolean]> {
+        arguments_decoded: [MoveAddressType[], bigint, bigint, boolean];
+        type_arguments: [];
+    }
+    interface BatchVotePayload extends TypedFunctionPayload<[MoveAddressType[], bigint, boolean]> {
+        arguments_decoded: [MoveAddressType[], bigint, boolean];
+        type_arguments: [];
+    }
+    interface ForceEndEpochPayload extends TypedFunctionPayload<[]> {
         arguments_decoded: [];
         type_arguments: [];
     }
-    interface VotePayload extends TypedFunctionPayload<[MoveAddressType, bigint, boolean]> {
-        arguments_decoded: [MoveAddressType, bigint, boolean];
+    interface ForceEndEpochTestOnlyPayload extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
+    interface PartialVotePayload extends TypedFunctionPayload<[MoveAddressType, bigint, bigint, boolean]> {
+        arguments_decoded: [MoveAddressType, bigint, bigint, boolean];
         type_arguments: [];
     }
 }
@@ -5416,11 +5441,11 @@ export declare class multisig_account extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): multisig_account;
+    onEntryCreate(func: (call: multisig_account.CreatePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryAddOwner(func: (call: multisig_account.AddOwnerPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryAddOwners(func: (call: multisig_account.AddOwnersPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryAddOwnersAndUpdateSignaturesRequired(func: (call: multisig_account.AddOwnersAndUpdateSignaturesRequiredPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryApproveTransaction(func: (call: multisig_account.ApproveTransactionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
-    onEntryCreate(func: (call: multisig_account.CreatePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryCreateTransaction(func: (call: multisig_account.CreateTransactionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryCreateTransactionWithHash(func: (call: multisig_account.CreateTransactionWithHashPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryCreateWithExistingAccount(func: (call: multisig_account.CreateWithExistingAccountPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
@@ -5442,6 +5467,8 @@ export declare class multisig_account extends AptosBaseProcessor {
     onEntryVoteTransaction(func: (call: multisig_account.VoteTransactionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryVoteTransactions(func: (call: multisig_account.VoteTransactionsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryVoteTransanction(func: (call: multisig_account.VoteTransanctionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEventVote(func: (event: multisig_account.VoteInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEventVoteEvent(func: (event: multisig_account.VoteEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEventAddOwners(func: (event: multisig_account.AddOwnersInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEventAddOwnersEvent(func: (event: multisig_account.AddOwnersEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEventCreateTransaction(func: (event: multisig_account.CreateTransactionInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
@@ -5458,10 +5485,35 @@ export declare class multisig_account extends AptosBaseProcessor {
     onEventTransactionExecutionSucceededEvent(func: (event: multisig_account.TransactionExecutionSucceededEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEventUpdateSignaturesRequired(func: (event: multisig_account.UpdateSignaturesRequiredInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEventUpdateSignaturesRequiredEvent(func: (event: multisig_account.UpdateSignaturesRequiredEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
-    onEventVote(func: (event: multisig_account.VoteInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
-    onEventVoteEvent(func: (event: multisig_account.VoteEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
 }
 export declare namespace multisig_account {
+    interface Vote {
+        multisig_account: MoveAddressType;
+        owner: MoveAddressType;
+        sequence_number: bigint;
+        approved: boolean;
+    }
+    namespace Vote {
+        const TYPE_QNAME = "0x1::multisig_account::Vote";
+        function type(): TypeDescriptor<Vote>;
+    }
+    interface VoteInstance extends TypedEventInstance<Vote> {
+        data_decoded: Vote;
+        type_arguments: [];
+    }
+    interface VoteEvent {
+        owner: MoveAddressType;
+        sequence_number: bigint;
+        approved: boolean;
+    }
+    namespace VoteEvent {
+        const TYPE_QNAME = "0x1::multisig_account::VoteEvent";
+        function type(): TypeDescriptor<VoteEvent>;
+    }
+    interface VoteEventInstance extends TypedEventInstance<VoteEvent> {
+        data_decoded: VoteEvent;
+        type_arguments: [];
+    }
     interface AddOwners {
         multisig_account: MoveAddressType;
         owners_added: MoveAddressType[];
@@ -5736,34 +5788,11 @@ export declare namespace multisig_account {
         data_decoded: UpdateSignaturesRequiredEvent;
         type_arguments: [];
     }
-    interface Vote {
-        multisig_account: MoveAddressType;
-        owner: MoveAddressType;
-        sequence_number: bigint;
-        approved: boolean;
-    }
-    namespace Vote {
-        const TYPE_QNAME = "0x1::multisig_account::Vote";
-        function type(): TypeDescriptor<Vote>;
-    }
-    interface VoteInstance extends TypedEventInstance<Vote> {
-        data_decoded: Vote;
-        type_arguments: [];
-    }
-    interface VoteEvent {
-        owner: MoveAddressType;
-        sequence_number: bigint;
-        approved: boolean;
-    }
-    namespace VoteEvent {
-        const TYPE_QNAME = "0x1::multisig_account::VoteEvent";
-        function type(): TypeDescriptor<VoteEvent>;
-    }
-    interface VoteEventInstance extends TypedEventInstance<VoteEvent> {
-        data_decoded: VoteEvent;
-        type_arguments: [];
-    }
     namespace entry {
+        function create(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint, string[], string[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function addOwner(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType];
@@ -5780,10 +5809,6 @@ export declare namespace multisig_account {
             typeArguments: [];
             functionArguments: [MoveAddressType, bigint];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function create(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [];
-            functionArguments: [bigint, string[], string[]];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function createTransaction(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType, string];
@@ -5888,6 +5913,15 @@ export declare namespace multisig_account {
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
+        function isOwner(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+        function metadata(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[simple_map.SimpleMap<string, string>]>;
+        function vote(client: Aptos, request: {
+            functionArguments: [MoveAddressType, bigint, MoveAddressType];
+        }, version?: bigint): Promise<[boolean, boolean]>;
         function availableTransactionQueueCapacity(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
@@ -5903,6 +5937,12 @@ export declare namespace multisig_account {
         function canReject(client: Aptos, request: {
             functionArguments: [MoveAddressType, MoveAddressType, bigint];
         }, version?: bigint): Promise<[boolean]>;
+        function numSignaturesRequired(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function owners(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType[]]>;
         function getNextMultisigAccountAddress(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[MoveAddressType]>;
@@ -5915,27 +5955,16 @@ export declare namespace multisig_account {
         function getTransaction(client: Aptos, request: {
             functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[multisig_account.MultisigTransaction]>;
-        function isOwner(client: Aptos, request: {
-            functionArguments: [MoveAddressType, MoveAddressType];
-        }, version?: bigint): Promise<[boolean]>;
         function lastResolvedSequenceNumber(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function metadata(client: Aptos, request: {
-            functionArguments: [MoveAddressType];
-        }, version?: bigint): Promise<[simple_map.SimpleMap<string, string>]>;
         function nextSequenceNumber(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function numSignaturesRequired(client: Aptos, request: {
-            functionArguments: [MoveAddressType];
-        }, version?: bigint): Promise<[bigint]>;
-        function owners(client: Aptos, request: {
-            functionArguments: [MoveAddressType];
-        }, version?: bigint): Promise<[MoveAddressType[]]>;
-        function vote(client: Aptos, request: {
-            functionArguments: [MoveAddressType, bigint, MoveAddressType];
-        }, version?: bigint): Promise<[boolean, boolean]>;
+    }
+    interface CreatePayload extends TypedFunctionPayload<[bigint, string[], string[]]> {
+        arguments_decoded: [bigint, string[], string[]];
+        type_arguments: [];
     }
     interface AddOwnerPayload extends TypedFunctionPayload<[MoveAddressType]> {
         arguments_decoded: [MoveAddressType];
@@ -5953,10 +5982,6 @@ export declare namespace multisig_account {
         arguments_decoded: [MoveAddressType, bigint];
         type_arguments: [];
     }
-    interface CreatePayload extends TypedFunctionPayload<[bigint, string[], string[]]> {
-        arguments_decoded: [bigint, string[], string[]];
-        type_arguments: [];
-    }
     interface CreateTransactionPayload extends TypedFunctionPayload<[MoveAddressType, string]> {
         arguments_decoded: [MoveAddressType, string];
         type_arguments: [];
@@ -6165,21 +6190,24 @@ export declare class staking_contract extends AptosBaseProcessor {
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): staking_contract;
     onEntryAddStake(func: (call: staking_contract.AddStakePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEntrySetBeneficiaryForOperator(func: (call: staking_contract.SetBeneficiaryForOperatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEntryCreateStakingContract(func: (call: staking_contract.CreateStakingContractPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEntryDistribute(func: (call: staking_contract.DistributePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEntryRequestCommission(func: (call: staking_contract.RequestCommissionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEntryResetLockup(func: (call: staking_contract.ResetLockupPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
-    onEntrySetBeneficiaryForOperator(func: (call: staking_contract.SetBeneficiaryForOperatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEntrySwitchOperator(func: (call: staking_contract.SwitchOperatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEntrySwitchOperatorWithSameCommission(func: (call: staking_contract.SwitchOperatorWithSameCommissionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEntryUnlockRewards(func: (call: staking_contract.UnlockRewardsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEntryUnlockStake(func: (call: staking_contract.UnlockStakePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEntryUpdateCommision(func: (call: staking_contract.UpdateCommisionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEntryUpdateVoter(func: (call: staking_contract.UpdateVoterPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
-    onEventAddDistribution(func: (event: staking_contract.AddDistributionInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
-    onEventAddDistributionEvent(func: (event: staking_contract.AddDistributionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventAddStake(func: (event: staking_contract.AddStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventAddStakeEvent(func: (event: staking_contract.AddStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventUnlockStake(func: (event: staking_contract.UnlockStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventUnlockStakeEvent(func: (event: staking_contract.UnlockStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventSetBeneficiaryForOperator(func: (event: staking_contract.SetBeneficiaryForOperatorInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventAddDistribution(func: (event: staking_contract.AddDistributionInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventAddDistributionEvent(func: (event: staking_contract.AddDistributionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventCreateStakingContract(func: (event: staking_contract.CreateStakingContractInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventCreateStakingContractEvent(func: (event: staking_contract.CreateStakingContractEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventDistribute(func: (event: staking_contract.DistributeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
@@ -6188,68 +6216,67 @@ export declare class staking_contract extends AptosBaseProcessor {
     onEventRequestCommissionEvent(func: (event: staking_contract.RequestCommissionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventResetLockup(func: (event: staking_contract.ResetLockupInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventResetLockupEvent(func: (event: staking_contract.ResetLockupEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
-    onEventSetBeneficiaryForOperator(func: (event: staking_contract.SetBeneficiaryForOperatorInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventStakingGroupUpdateCommissionEvent(func: (event: staking_contract.StakingGroupUpdateCommissionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventSwitchOperator(func: (event: staking_contract.SwitchOperatorInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventSwitchOperatorEvent(func: (event: staking_contract.SwitchOperatorEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
-    onEventUnlockStake(func: (event: staking_contract.UnlockStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
-    onEventUnlockStakeEvent(func: (event: staking_contract.UnlockStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventUpdateCommission(func: (event: staking_contract.UpdateCommissionInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventUpdateCommissionEvent(func: (event: staking_contract.UpdateCommissionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventUpdateVoter(func: (event: staking_contract.UpdateVoterInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventUpdateVoterEvent(func: (event: staking_contract.UpdateVoterEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
 }
 export declare namespace staking_contract {
-    interface AddDistribution {
+    interface AddStake {
         operator: MoveAddressType;
         pool_address: MoveAddressType;
         amount: bigint;
     }
-    namespace AddDistribution {
-        const TYPE_QNAME = "0x1::staking_contract::AddDistribution";
-        function type(): TypeDescriptor<AddDistribution>;
+    namespace AddStake {
+        const TYPE_QNAME = "0x1::staking_contract::AddStake";
+        function type(): TypeDescriptor<AddStake>;
     }
-    interface AddDistributionInstance extends TypedEventInstance<AddDistribution> {
-        data_decoded: AddDistribution;
+    interface AddStakeInstance extends TypedEventInstance<AddStake> {
+        data_decoded: AddStake;
         type_arguments: [];
     }
-    interface AddDistributionEvent {
+    interface AddStakeEvent {
         operator: MoveAddressType;
         pool_address: MoveAddressType;
         amount: bigint;
     }
-    namespace AddDistributionEvent {
-        const TYPE_QNAME = "0x1::staking_contract::AddDistributionEvent";
-        function type(): TypeDescriptor<AddDistributionEvent>;
+    namespace AddStakeEvent {
+        const TYPE_QNAME = "0x1::staking_contract::AddStakeEvent";
+        function type(): TypeDescriptor<AddStakeEvent>;
     }
-    interface AddDistributionEventInstance extends TypedEventInstance<AddDistributionEvent> {
-        data_decoded: AddDistributionEvent;
+    interface AddStakeEventInstance extends TypedEventInstance<AddStakeEvent> {
+        data_decoded: AddStakeEvent;
         type_arguments: [];
     }
-    interface AddStake {
+    interface UnlockStake {
         operator: MoveAddressType;
         pool_address: MoveAddressType;
         amount: bigint;
+        commission_paid: bigint;
     }
-    namespace AddStake {
-        const TYPE_QNAME = "0x1::staking_contract::AddStake";
-        function type(): TypeDescriptor<AddStake>;
+    namespace UnlockStake {
+        const TYPE_QNAME = "0x1::staking_contract::UnlockStake";
+        function type(): TypeDescriptor<UnlockStake>;
     }
-    interface AddStakeInstance extends TypedEventInstance<AddStake> {
-        data_decoded: AddStake;
+    interface UnlockStakeInstance extends TypedEventInstance<UnlockStake> {
+        data_decoded: UnlockStake;
         type_arguments: [];
     }
-    interface AddStakeEvent {
+    interface UnlockStakeEvent {
         operator: MoveAddressType;
         pool_address: MoveAddressType;
         amount: bigint;
+        commission_paid: bigint;
     }
-    namespace AddStakeEvent {
-        const TYPE_QNAME = "0x1::staking_contract::AddStakeEvent";
-        function type(): TypeDescriptor<AddStakeEvent>;
+    namespace UnlockStakeEvent {
+        const TYPE_QNAME = "0x1::staking_contract::UnlockStakeEvent";
+        function type(): TypeDescriptor<UnlockStakeEvent>;
     }
-    interface AddStakeEventInstance extends TypedEventInstance<AddStakeEvent> {
-        data_decoded: AddStakeEvent;
+    interface UnlockStakeEventInstance extends TypedEventInstance<UnlockStakeEvent> {
+        data_decoded: UnlockStakeEvent;
         type_arguments: [];
     }
     interface BeneficiaryForOperator {
@@ -6259,6 +6286,45 @@ export declare namespace staking_contract {
         const TYPE_QNAME = "0x1::staking_contract::BeneficiaryForOperator";
         function type(): TypeDescriptor<BeneficiaryForOperator>;
     }
+    interface SetBeneficiaryForOperator {
+        operator: MoveAddressType;
+        old_beneficiary: MoveAddressType;
+        new_beneficiary: MoveAddressType;
+    }
+    namespace SetBeneficiaryForOperator {
+        const TYPE_QNAME = "0x1::staking_contract::SetBeneficiaryForOperator";
+        function type(): TypeDescriptor<SetBeneficiaryForOperator>;
+    }
+    interface SetBeneficiaryForOperatorInstance extends TypedEventInstance<SetBeneficiaryForOperator> {
+        data_decoded: SetBeneficiaryForOperator;
+        type_arguments: [];
+    }
+    interface AddDistribution {
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
+        amount: bigint;
+    }
+    namespace AddDistribution {
+        const TYPE_QNAME = "0x1::staking_contract::AddDistribution";
+        function type(): TypeDescriptor<AddDistribution>;
+    }
+    interface AddDistributionInstance extends TypedEventInstance<AddDistribution> {
+        data_decoded: AddDistribution;
+        type_arguments: [];
+    }
+    interface AddDistributionEvent {
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
+        amount: bigint;
+    }
+    namespace AddDistributionEvent {
+        const TYPE_QNAME = "0x1::staking_contract::AddDistributionEvent";
+        function type(): TypeDescriptor<AddDistributionEvent>;
+    }
+    interface AddDistributionEventInstance extends TypedEventInstance<AddDistributionEvent> {
+        data_decoded: AddDistributionEvent;
+        type_arguments: [];
+    }
     interface CreateStakingContract {
         operator: MoveAddressType;
         voter: MoveAddressType;
@@ -6369,19 +6435,6 @@ export declare namespace staking_contract {
         data_decoded: ResetLockupEvent;
         type_arguments: [];
     }
-    interface SetBeneficiaryForOperator {
-        operator: MoveAddressType;
-        old_beneficiary: MoveAddressType;
-        new_beneficiary: MoveAddressType;
-    }
-    namespace SetBeneficiaryForOperator {
-        const TYPE_QNAME = "0x1::staking_contract::SetBeneficiaryForOperator";
-        function type(): TypeDescriptor<SetBeneficiaryForOperator>;
-    }
-    interface SetBeneficiaryForOperatorInstance extends TypedEventInstance<SetBeneficiaryForOperator> {
-        data_decoded: SetBeneficiaryForOperator;
-        type_arguments: [];
-    }
     interface StakingContract {
         principal: bigint;
         pool_address: MoveAddressType;
@@ -6454,34 +6507,6 @@ export declare namespace staking_contract {
         data_decoded: SwitchOperatorEvent;
         type_arguments: [];
     }
-    interface UnlockStake {
-        operator: MoveAddressType;
-        pool_address: MoveAddressType;
-        amount: bigint;
-        commission_paid: bigint;
-    }
-    namespace UnlockStake {
-        const TYPE_QNAME = "0x1::staking_contract::UnlockStake";
-        function type(): TypeDescriptor<UnlockStake>;
-    }
-    interface UnlockStakeInstance extends TypedEventInstance<UnlockStake> {
-        data_decoded: UnlockStake;
-        type_arguments: [];
-    }
-    interface UnlockStakeEvent {
-        operator: MoveAddressType;
-        pool_address: MoveAddressType;
-        amount: bigint;
-        commission_paid: bigint;
-    }
-    namespace UnlockStakeEvent {
-        const TYPE_QNAME = "0x1::staking_contract::UnlockStakeEvent";
-        function type(): TypeDescriptor<UnlockStakeEvent>;
-    }
-    interface UnlockStakeEventInstance extends TypedEventInstance<UnlockStakeEvent> {
-        data_decoded: UnlockStakeEvent;
-        type_arguments: [];
-    }
     interface UpdateCommission {
         staker: MoveAddressType;
         operator: MoveAddressType;
@@ -6543,6 +6568,10 @@ export declare namespace staking_contract {
             typeArguments: [];
             functionArguments: [MoveAddressType, bigint];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setBeneficiaryForOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function createStakingContract(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [
@@ -6565,10 +6594,6 @@ export declare namespace staking_contract {
             typeArguments: [];
             functionArguments: [MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function setBeneficiaryForOperator(client: Aptos, account: AptosAccount, request: {
-            typeArguments: [];
-            functionArguments: [MoveAddressType];
-        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function switchOperator(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType, MoveAddressType, bigint];
@@ -6598,12 +6623,12 @@ export declare namespace staking_contract {
         function beneficiaryForOperator(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[MoveAddressType]>;
-        function commissionPercentage(client: Aptos, request: {
-            functionArguments: [MoveAddressType, MoveAddressType];
-        }, version?: bigint): Promise<[bigint]>;
         function getExpectedStakePoolAddress(client: Aptos, request: {
             functionArguments: [MoveAddressType, MoveAddressType, string];
         }, version?: bigint): Promise<[MoveAddressType]>;
+        function commissionPercentage(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
         function lastRecordedPrincipal(client: Aptos, request: {
             functionArguments: [MoveAddressType, MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
@@ -6624,6 +6649,10 @@ export declare namespace staking_contract {
         arguments_decoded: [MoveAddressType, bigint];
         type_arguments: [];
     }
+    interface SetBeneficiaryForOperatorPayload extends TypedFunctionPayload<[MoveAddressType]> {
+        arguments_decoded: [MoveAddressType];
+        type_arguments: [];
+    }
     interface CreateStakingContractPayload extends TypedFunctionPayload<[
         MoveAddressType,
         MoveAddressType,
@@ -6652,10 +6681,6 @@ export declare namespace staking_contract {
         arguments_decoded: [MoveAddressType];
         type_arguments: [];
     }
-    interface SetBeneficiaryForOperatorPayload extends TypedFunctionPayload<[MoveAddressType]> {
-        arguments_decoded: [MoveAddressType];
-        type_arguments: [];
-    }
     interface SwitchOperatorPayload extends TypedFunctionPayload<[MoveAddressType, MoveAddressType, bigint]> {
         arguments_decoded: [MoveAddressType, MoveAddressType, bigint];
         type_arguments: [];
@@ -6819,13 +6844,6 @@ export declare namespace jwk_consensus_config {
         const TYPE_QNAME = "0x1::jwk_consensus_config::ConfigV1";
         function type(): TypeDescriptor<ConfigV1>;
     }
-    interface JWKConsensusConfig {
-        variant: copyable_any.Any;
-    }
-    namespace JWKConsensusConfig {
-        const TYPE_QNAME = "0x1::jwk_consensus_config::JWKConsensusConfig";
-        function type(): TypeDescriptor<JWKConsensusConfig>;
-    }
     interface OIDCProvider {
         name: string;
         config_url: string;
@@ -6834,6 +6852,13 @@ export declare namespace jwk_consensus_config {
         const TYPE_QNAME = "0x1::jwk_consensus_config::OIDCProvider";
         function type(): TypeDescriptor<OIDCProvider>;
     }
+    interface JWKConsensusConfig {
+        variant: copyable_any.Any;
+    }
+    namespace JWKConsensusConfig {
+        const TYPE_QNAME = "0x1::jwk_consensus_config::JWKConsensusConfig";
+        function type(): TypeDescriptor<JWKConsensusConfig>;
+    }
     namespace entry { }
     namespace view { }
 }