@sentio/sdk 2.6.4-rc.2 → 2.7.0-rc.1

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

@@ -76,6 +76,10 @@ export declare class coin extends AptosBaseProcessor {
     onEventWithdrawEvent(func: (event: coin.WithdrawEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): coin;
 }
 export declare namespace coin {
+    class AggregatableCoin<T0> {
+        static TYPE_QNAME: string;
+        value: aggregator.Aggregator;
+    }
     class BurnCapability<T0> {
         static TYPE_QNAME: string;
         dummy_field: Boolean;
@@ -384,6 +388,10 @@ export declare namespace stake {
         fullnode_addresses: string;
         validator_index: bigint;
     }
+    class ValidatorFees {
+        static TYPE_QNAME: string;
+        fees_table: table.Table<Address, coin.Coin<aptos_coin.AptosCoin>>;
+    }
     class ValidatorInfo {
         static TYPE_QNAME: string;
         addr: Address;
@@ -476,6 +484,66 @@ export declare namespace table {
     }
 }
 export declare namespace math64 { }
+export declare class object_ extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): object_;
+    onEntryTransferCall(func: (call: object_.TransferCallPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): object_;
+    onEventTransferEvent(func: (event: object_.TransferEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): object_;
+}
+export declare namespace object_ {
+    class ConstructorRef {
+        static TYPE_QNAME: string;
+        self: Address;
+        can_delete: Boolean;
+    }
+    class DeleteRef {
+        static TYPE_QNAME: string;
+        self: Address;
+    }
+    class ExtendRef {
+        static TYPE_QNAME: string;
+        self: Address;
+    }
+    class LinearTransferRef {
+        static TYPE_QNAME: string;
+        self: Address;
+        owner: Address;
+    }
+    class Object<T0> {
+        static TYPE_QNAME: string;
+        inner: Address;
+    }
+    class ObjectCore {
+        static TYPE_QNAME: string;
+        guid_creation_num: bigint;
+        owner: Address;
+        allow_ungated_transfer: Boolean;
+        transfer_events: event.EventHandle<object_.TransferEvent>;
+    }
+    class ObjectGroup {
+        static TYPE_QNAME: string;
+        dummy_field: Boolean;
+    }
+    class TransferEvent {
+        static TYPE_QNAME: string;
+        object: Address;
+        from: Address;
+        to: Address;
+    }
+    interface TransferEventInstance extends TypedEventInstance<TransferEvent> {
+        data_decoded: TransferEvent;
+        type_arguments: [];
+    }
+    class TransferRef {
+        static TYPE_QNAME: string;
+        self: Address;
+    }
+    interface TransferCallPayload extends TypedFunctionPayload<[Address, Address]> {
+        arguments_decoded: [Address, Address];
+        type_arguments: [];
+    }
+}
 export declare namespace option {
     class Option<T0> {
         static TYPE_QNAME: string;
@@ -575,9 +643,14 @@ export declare class account extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): account;
+    onEntryOfferRotationCapability(func: (call: account.OfferRotationCapabilityPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): account;
     onEntryOfferSignerCapability(func: (call: account.OfferSignerCapabilityPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): account;
+    onEntryRevokeAnyRotationCapability(func: (call: account.RevokeAnyRotationCapabilityPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): account;
+    onEntryRevokeAnySignerCapability(func: (call: account.RevokeAnySignerCapabilityPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): account;
+    onEntryRevokeRotationCapability(func: (call: account.RevokeRotationCapabilityPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): account;
     onEntryRevokeSignerCapability(func: (call: account.RevokeSignerCapabilityPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): account;
     onEntryRotateAuthenticationKey(func: (call: account.RotateAuthenticationKeyPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): account;
+    onEntryRotateAuthenticationKeyWithRotationCapability(func: (call: account.RotateAuthenticationKeyWithRotationCapabilityPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): account;
     onEventCoinRegisterEvent(func: (event: account.CoinRegisterEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): account;
     onEventKeyRotationEvent(func: (event: account.KeyRotationEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): account;
 }
@@ -626,6 +699,13 @@ export declare namespace account {
         sequence_number: bigint;
         recipient_address: Address;
     }
+    class RotationCapabilityOfferProofChallengeV2 {
+        static TYPE_QNAME: string;
+        chain_id: number;
+        sequence_number: bigint;
+        source_address: Address;
+        recipient_address: Address;
+    }
     class RotationProofChallenge {
         static TYPE_QNAME: string;
         sequence_number: bigint;
@@ -648,10 +728,26 @@ export declare namespace account {
         source_address: Address;
         recipient_address: Address;
     }
+    interface OfferRotationCapabilityPayload extends TypedFunctionPayload<[string, number, string, Address]> {
+        arguments_decoded: [string, number, string, Address];
+        type_arguments: [];
+    }
     interface OfferSignerCapabilityPayload extends TypedFunctionPayload<[string, number, string, Address]> {
         arguments_decoded: [string, number, string, Address];
         type_arguments: [];
     }
+    interface RevokeAnyRotationCapabilityPayload extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
+    interface RevokeAnySignerCapabilityPayload extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
+    interface RevokeRotationCapabilityPayload extends TypedFunctionPayload<[Address]> {
+        arguments_decoded: [Address];
+        type_arguments: [];
+    }
     interface RevokeSignerCapabilityPayload extends TypedFunctionPayload<[Address]> {
         arguments_decoded: [Address];
         type_arguments: [];
@@ -667,6 +763,10 @@ export declare namespace account {
         arguments_decoded: [number, string, number, string, string, string];
         type_arguments: [];
     }
+    interface RotateAuthenticationKeyWithRotationCapabilityPayload extends TypedFunctionPayload<[Address, number, string, string]> {
+        arguments_decoded: [Address, number, string, string];
+        type_arguments: [];
+    }
 }
 export declare namespace ed25519 {
     class Signature {
@@ -746,6 +846,7 @@ export declare class vesting extends AptosBaseProcessor {
     static bind(options?: Partial<AptosBindOptions>): vesting;
     onEntryAdminWithdraw(func: (call: vesting.AdminWithdrawPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): vesting;
     onEntryDistribute(func: (call: vesting.DistributePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): vesting;
+    onEntryDistributeMany(func: (call: vesting.DistributeManyPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): vesting;
     onEntryResetBeneficiary(func: (call: vesting.ResetBeneficiaryPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): vesting;
     onEntryResetLockup(func: (call: vesting.ResetLockupPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): vesting;
     onEntrySetBeneficiary(func: (call: vesting.SetBeneficiaryPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): vesting;
@@ -753,10 +854,12 @@ export declare class vesting extends AptosBaseProcessor {
     onEntrySetManagementRole(func: (call: vesting.SetManagementRolePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): vesting;
     onEntryTerminateVestingContract(func: (call: vesting.TerminateVestingContractPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): vesting;
     onEntryUnlockRewards(func: (call: vesting.UnlockRewardsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): vesting;
+    onEntryUnlockRewardsMany(func: (call: vesting.UnlockRewardsManyPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): vesting;
     onEntryUpdateOperator(func: (call: vesting.UpdateOperatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): vesting;
     onEntryUpdateOperatorWithSameCommission(func: (call: vesting.UpdateOperatorWithSameCommissionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): vesting;
     onEntryUpdateVoter(func: (call: vesting.UpdateVoterPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): vesting;
     onEntryVest(func: (call: vesting.VestPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): vesting;
+    onEntryVestMany(func: (call: vesting.VestManyPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): vesting;
     onEventCreateVestingContractEvent(func: (event: vesting.CreateVestingContractEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): vesting;
     onEventUpdateOperatorEvent(func: (event: vesting.UpdateOperatorEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): vesting;
     onEventUpdateVoterEvent(func: (event: vesting.UpdateVoterEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): vesting;
@@ -936,6 +1039,10 @@ export declare namespace vesting {
         arguments_decoded: [Address];
         type_arguments: [];
     }
+    interface DistributeManyPayload extends TypedFunctionPayload<[Address[]]> {
+        arguments_decoded: [Address[]];
+        type_arguments: [];
+    }
     interface ResetBeneficiaryPayload extends TypedFunctionPayload<[Address, Address]> {
         arguments_decoded: [Address, Address];
         type_arguments: [];
@@ -964,6 +1071,10 @@ export declare namespace vesting {
         arguments_decoded: [Address];
         type_arguments: [];
     }
+    interface UnlockRewardsManyPayload extends TypedFunctionPayload<[Address[]]> {
+        arguments_decoded: [Address[]];
+        type_arguments: [];
+    }
     interface UpdateOperatorPayload extends TypedFunctionPayload<[Address, Address, bigint]> {
         arguments_decoded: [Address, Address, bigint];
         type_arguments: [];
@@ -980,6 +1091,10 @@ export declare namespace vesting {
         arguments_decoded: [Address];
         type_arguments: [];
     }
+    interface VestManyPayload extends TypedFunctionPayload<[Address[]]> {
+        arguments_decoded: [Address[]];
+        type_arguments: [];
+    }
 }
 export declare namespace bls12381 {
     class AggrOrMultiSignature {
@@ -1102,6 +1217,14 @@ export declare namespace aptos_coin {
     }
 }
 export declare namespace aptos_hash { }
+export declare namespace big_vector {
+    class BigVector<T0> {
+        static TYPE_QNAME: string;
+        buckets: table_with_length.TableWithLength<bigint, T0[] | string>;
+        end_index: bigint;
+        bucket_size: bigint;
+    }
+}
 export declare namespace bit_vector {
     class BitVector {
         static TYPE_QNAME: string;
@@ -1133,6 +1256,7 @@ export declare namespace comparator {
         inner: number;
     }
 }
+export declare namespace math_fixed { }
 export declare namespace simple_map {
     class Element<T0, T1> {
         static TYPE_QNAME: string;
@@ -1144,6 +1268,23 @@ export declare namespace simple_map {
         data: simple_map.Element<T0, T1>[];
     }
 }
+export declare namespace smart_table {
+    class Entry<T0, T1> {
+        static TYPE_QNAME: string;
+        hash: bigint;
+        key: T0;
+        value: T1;
+    }
+    class SmartTable<T0, T1> {
+        static TYPE_QNAME: string;
+        buckets: table_with_length.TableWithLength<bigint, smart_table.Entry<T0, T1>[]>;
+        num_buckets: bigint;
+        level: number;
+        size: bigint;
+        split_load_threshold: number;
+        target_bucket_size: bigint;
+    }
+}
 export declare namespace storage_gas {
     class GasCurve {
         static TYPE_QNAME: string;
@@ -1254,23 +1395,67 @@ export declare namespace ristretto255 {
         data: string;
     }
 }
+export declare namespace smart_vector {
+    class SmartVector<T0> {
+        static TYPE_QNAME: string;
+        inline_vec: T0[] | string;
+        big_vec: big_vector.BigVector<T0>[];
+        inline_capacity: option.Option<bigint>;
+        bucket_size: option.Option<bigint>;
+    }
+}
 export declare class aptos_account extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): aptos_account;
+    onEntryBatchTransfer(func: (call: aptos_account.BatchTransferPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): aptos_account;
+    onEntryBatchTransferCoins(func: (call: aptos_account.BatchTransferCoinsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): aptos_account;
     onEntryCreateAccount(func: (call: aptos_account.CreateAccountPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): aptos_account;
+    onEntrySetAllowDirectCoinTransfers(func: (call: aptos_account.SetAllowDirectCoinTransfersPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): aptos_account;
     onEntryTransfer(func: (call: aptos_account.TransferPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): aptos_account;
+    onEntryTransferCoins(func: (call: aptos_account.TransferCoinsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): aptos_account;
+    onEventDirectCoinTransferConfigUpdatedEvent(func: (event: aptos_account.DirectCoinTransferConfigUpdatedEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): aptos_account;
 }
 export declare namespace aptos_account {
+    class DirectCoinTransferConfigUpdatedEvent {
+        static TYPE_QNAME: string;
+        new_allow_direct_transfers: Boolean;
+    }
+    interface DirectCoinTransferConfigUpdatedEventInstance extends TypedEventInstance<DirectCoinTransferConfigUpdatedEvent> {
+        data_decoded: DirectCoinTransferConfigUpdatedEvent;
+        type_arguments: [];
+    }
+    class DirectTransferConfig {
+        static TYPE_QNAME: string;
+        allow_arbitrary_coin_transfers: Boolean;
+        update_coin_transfer_events: event.EventHandle<aptos_account.DirectCoinTransferConfigUpdatedEvent>;
+    }
+    interface BatchTransferPayload extends TypedFunctionPayload<[Address[], bigint[]]> {
+        arguments_decoded: [Address[], bigint[]];
+        type_arguments: [];
+    }
+    interface BatchTransferCoinsPayload<T0 = any> extends TypedFunctionPayload<[Address[], bigint[]]> {
+        arguments_decoded: [Address[], bigint[]];
+        type_arguments: [string];
+    }
     interface CreateAccountPayload extends TypedFunctionPayload<[Address]> {
         arguments_decoded: [Address];
         type_arguments: [];
     }
+    interface SetAllowDirectCoinTransfersPayload extends TypedFunctionPayload<[Boolean]> {
+        arguments_decoded: [Boolean];
+        type_arguments: [];
+    }
     interface TransferPayload extends TypedFunctionPayload<[Address, bigint]> {
         arguments_decoded: [Address, bigint];
         type_arguments: [];
     }
+    interface TransferCoinsPayload<T0 = any> extends TypedFunctionPayload<[Address, bigint]> {
+        arguments_decoded: [Address, bigint];
+        type_arguments: [string];
+    }
 }
+export declare namespace create_signer { }
 export declare namespace fixed_point32 {
     class FixedPoint32 {
         static TYPE_QNAME: string;
@@ -1366,6 +1551,133 @@ export declare namespace staking_config {
         voting_power_increase_limit: bigint;
     }
 }
+export declare class delegation_pool extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): delegation_pool;
+    onEntryAddStake(func: (call: delegation_pool.AddStakePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): delegation_pool;
+    onEntryInitializeDelegationPool(func: (call: delegation_pool.InitializeDelegationPoolPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): delegation_pool;
+    onEntryReactivateStake(func: (call: delegation_pool.ReactivateStakePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): delegation_pool;
+    onEntrySetDelegatedVoter(func: (call: delegation_pool.SetDelegatedVoterPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): delegation_pool;
+    onEntrySetOperator(func: (call: delegation_pool.SetOperatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): delegation_pool;
+    onEntrySynchronizeDelegationPool(func: (call: delegation_pool.SynchronizeDelegationPoolPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): delegation_pool;
+    onEntryUnlock(func: (call: delegation_pool.UnlockPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): delegation_pool;
+    onEntryWithdraw(func: (call: delegation_pool.WithdrawPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): delegation_pool;
+    onEventAddStakeEvent(func: (event: delegation_pool.AddStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): delegation_pool;
+    onEventReactivateStakeEvent(func: (event: delegation_pool.ReactivateStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): delegation_pool;
+    onEventUnlockStakeEvent(func: (event: delegation_pool.UnlockStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): delegation_pool;
+    onEventWithdrawStakeEvent(func: (event: delegation_pool.WithdrawStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): delegation_pool;
+    onEventDistributeCommissionEvent(func: (event: delegation_pool.DistributeCommissionEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): delegation_pool;
+}
+export declare namespace delegation_pool {
+    class AddStakeEvent {
+        static TYPE_QNAME: string;
+        pool_address: Address;
+        delegator_address: Address;
+        amount_added: bigint;
+        add_stake_fee: bigint;
+    }
+    interface AddStakeEventInstance extends TypedEventInstance<AddStakeEvent> {
+        data_decoded: AddStakeEvent;
+        type_arguments: [];
+    }
+    class DelegationPool {
+        static TYPE_QNAME: string;
+        active_shares: pool_u64_unbound.Pool;
+        observed_lockup_cycle: delegation_pool.ObservedLockupCycle;
+        inactive_shares: table.Table<delegation_pool.ObservedLockupCycle, pool_u64_unbound.Pool>;
+        pending_withdrawals: table.Table<Address, delegation_pool.ObservedLockupCycle>;
+        stake_pool_signer_cap: account.SignerCapability;
+        total_coins_inactive: bigint;
+        operator_commission_percentage: bigint;
+        add_stake_events: event.EventHandle<delegation_pool.AddStakeEvent>;
+        reactivate_stake_events: event.EventHandle<delegation_pool.ReactivateStakeEvent>;
+        unlock_stake_events: event.EventHandle<delegation_pool.UnlockStakeEvent>;
+        withdraw_stake_events: event.EventHandle<delegation_pool.WithdrawStakeEvent>;
+        distribute_commission_events: event.EventHandle<delegation_pool.DistributeCommissionEvent>;
+    }
+    class DelegationPoolOwnership {
+        static TYPE_QNAME: string;
+        pool_address: Address;
+    }
+    class DistributeCommissionEvent {
+        static TYPE_QNAME: string;
+        pool_address: Address;
+        operator: Address;
+        commission_active: bigint;
+        commission_pending_inactive: bigint;
+    }
+    interface DistributeCommissionEventInstance extends TypedEventInstance<DistributeCommissionEvent> {
+        data_decoded: DistributeCommissionEvent;
+        type_arguments: [];
+    }
+    class ObservedLockupCycle {
+        static TYPE_QNAME: string;
+        index: bigint;
+    }
+    class ReactivateStakeEvent {
+        static TYPE_QNAME: string;
+        pool_address: Address;
+        delegator_address: Address;
+        amount_reactivated: bigint;
+    }
+    interface ReactivateStakeEventInstance extends TypedEventInstance<ReactivateStakeEvent> {
+        data_decoded: ReactivateStakeEvent;
+        type_arguments: [];
+    }
+    class UnlockStakeEvent {
+        static TYPE_QNAME: string;
+        pool_address: Address;
+        delegator_address: Address;
+        amount_unlocked: bigint;
+    }
+    interface UnlockStakeEventInstance extends TypedEventInstance<UnlockStakeEvent> {
+        data_decoded: UnlockStakeEvent;
+        type_arguments: [];
+    }
+    class WithdrawStakeEvent {
+        static TYPE_QNAME: string;
+        pool_address: Address;
+        delegator_address: Address;
+        amount_withdrawn: bigint;
+    }
+    interface WithdrawStakeEventInstance extends TypedEventInstance<WithdrawStakeEvent> {
+        data_decoded: WithdrawStakeEvent;
+        type_arguments: [];
+    }
+    interface AddStakePayload extends TypedFunctionPayload<[Address, bigint]> {
+        arguments_decoded: [Address, bigint];
+        type_arguments: [];
+    }
+    interface InitializeDelegationPoolPayload extends TypedFunctionPayload<[bigint, string]> {
+        arguments_decoded: [bigint, string];
+        type_arguments: [];
+    }
+    interface ReactivateStakePayload extends TypedFunctionPayload<[Address, bigint]> {
+        arguments_decoded: [Address, bigint];
+        type_arguments: [];
+    }
+    interface SetDelegatedVoterPayload extends TypedFunctionPayload<[Address]> {
+        arguments_decoded: [Address];
+        type_arguments: [];
+    }
+    interface SetOperatorPayload extends TypedFunctionPayload<[Address]> {
+        arguments_decoded: [Address];
+        type_arguments: [];
+    }
+    interface SynchronizeDelegationPoolPayload extends TypedFunctionPayload<[Address]> {
+        arguments_decoded: [Address];
+        type_arguments: [];
+    }
+    interface UnlockPayload extends TypedFunctionPayload<[Address, bigint]> {
+        arguments_decoded: [Address, bigint];
+        type_arguments: [];
+    }
+    interface WithdrawPayload extends TypedFunctionPayload<[Address, bigint]> {
+        arguments_decoded: [Address, bigint];
+        type_arguments: [];
+    }
+}
 export declare class reconfiguration extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
@@ -1397,6 +1709,12 @@ export declare namespace transaction_fee {
         static TYPE_QNAME: string;
         burn_cap: coin.BurnCapability<aptos_coin.AptosCoin>;
     }
+    class CollectedFeesPerBlock {
+        static TYPE_QNAME: string;
+        amount: coin.AggregatableCoin<aptos_coin.AptosCoin>;
+        proposer: option.Option<Address>;
+        burn_percentage: number;
+    }
 }
 export declare class aptos_governance extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -1404,6 +1722,7 @@ export declare class aptos_governance extends AptosBaseProcessor {
     static bind(options?: Partial<AptosBindOptions>): aptos_governance;
     onEntryAddApprovedScriptHashScript(func: (call: aptos_governance.AddApprovedScriptHashScriptPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): aptos_governance;
     onEntryCreateProposal(func: (call: aptos_governance.CreateProposalPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): aptos_governance;
+    onEntryCreateProposalV2(func: (call: aptos_governance.CreateProposalV2Payload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): aptos_governance;
     onEntryVote(func: (call: aptos_governance.VotePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): aptos_governance;
     onEventCreateProposalEvent(func: (event: aptos_governance.CreateProposalEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): aptos_governance;
     onEventUpdateConfigEvent(func: (event: aptos_governance.UpdateConfigEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): aptos_governance;
@@ -1481,6 +1800,10 @@ export declare namespace aptos_governance {
         arguments_decoded: [Address, string, string, string];
         type_arguments: [];
     }
+    interface CreateProposalV2Payload extends TypedFunctionPayload<[Address, string, string, string, Boolean]> {
+        arguments_decoded: [Address, string, string, string, Boolean];
+        type_arguments: [];
+    }
     interface VotePayload extends TypedFunctionPayload<[Address, bigint, Boolean]> {
         arguments_decoded: [Address, bigint, Boolean];
         type_arguments: [];
@@ -1492,6 +1815,252 @@ export declare namespace consensus_config {
         config: string;
     }
 }
+export declare class multisig_account extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): multisig_account;
+    onEntryAddOwner(func: (call: multisig_account.AddOwnerPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEntryAddOwners(func: (call: multisig_account.AddOwnersPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEntryApproveTransaction(func: (call: multisig_account.ApproveTransactionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEntryCreate(func: (call: multisig_account.CreatePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEntryCreateTransaction(func: (call: multisig_account.CreateTransactionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEntryCreateTransactionWithHash(func: (call: multisig_account.CreateTransactionWithHashPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEntryCreateWithExistingAccount(func: (call: multisig_account.CreateWithExistingAccountPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEntryCreateWithOwners(func: (call: multisig_account.CreateWithOwnersPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEntryExecuteRejectedTransaction(func: (call: multisig_account.ExecuteRejectedTransactionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEntryRejectTransaction(func: (call: multisig_account.RejectTransactionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEntryRemoveOwner(func: (call: multisig_account.RemoveOwnerPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEntryRemoveOwners(func: (call: multisig_account.RemoveOwnersPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEntryUpdateMetadata(func: (call: multisig_account.UpdateMetadataPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEntryUpdateSignaturesRequired(func: (call: multisig_account.UpdateSignaturesRequiredPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEntryVoteTransanction(func: (call: multisig_account.VoteTransanctionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEventAddOwnersEvent(func: (event: multisig_account.AddOwnersEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEventRemoveOwnersEvent(func: (event: multisig_account.RemoveOwnersEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEventUpdateSignaturesRequiredEvent(func: (event: multisig_account.UpdateSignaturesRequiredEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEventCreateTransactionEvent(func: (event: multisig_account.CreateTransactionEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEventVoteEvent(func: (event: multisig_account.VoteEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEventExecuteRejectedTransactionEvent(func: (event: multisig_account.ExecuteRejectedTransactionEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEventTransactionExecutionSucceededEvent(func: (event: multisig_account.TransactionExecutionSucceededEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEventTransactionExecutionFailedEvent(func: (event: multisig_account.TransactionExecutionFailedEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): multisig_account;
+    onEventMetadataUpdatedEvent(func: (event: multisig_account.MetadataUpdatedEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): multisig_account;
+}
+export declare namespace multisig_account {
+    class AddOwnersEvent {
+        static TYPE_QNAME: string;
+        owners_added: Address[];
+    }
+    interface AddOwnersEventInstance extends TypedEventInstance<AddOwnersEvent> {
+        data_decoded: AddOwnersEvent;
+        type_arguments: [];
+    }
+    class CreateTransactionEvent {
+        static TYPE_QNAME: string;
+        creator: Address;
+        sequence_number: bigint;
+        transaction: multisig_account.MultisigTransaction;
+    }
+    interface CreateTransactionEventInstance extends TypedEventInstance<CreateTransactionEvent> {
+        data_decoded: CreateTransactionEvent;
+        type_arguments: [];
+    }
+    class ExecuteRejectedTransactionEvent {
+        static TYPE_QNAME: string;
+        sequence_number: bigint;
+        num_rejections: bigint;
+        executor: Address;
+    }
+    interface ExecuteRejectedTransactionEventInstance extends TypedEventInstance<ExecuteRejectedTransactionEvent> {
+        data_decoded: ExecuteRejectedTransactionEvent;
+        type_arguments: [];
+    }
+    class ExecutionError {
+        static TYPE_QNAME: string;
+        abort_location: string;
+        error_type: string;
+        error_code: bigint;
+    }
+    class MetadataUpdatedEvent {
+        static TYPE_QNAME: string;
+        old_metadata: simple_map.SimpleMap<string, string>;
+        new_metadata: simple_map.SimpleMap<string, string>;
+    }
+    interface MetadataUpdatedEventInstance extends TypedEventInstance<MetadataUpdatedEvent> {
+        data_decoded: MetadataUpdatedEvent;
+        type_arguments: [];
+    }
+    class MultisigAccount {
+        static TYPE_QNAME: string;
+        owners: Address[];
+        num_signatures_required: bigint;
+        transactions: table.Table<bigint, multisig_account.MultisigTransaction>;
+        last_executed_sequence_number: bigint;
+        next_sequence_number: bigint;
+        signer_cap: option.Option<account.SignerCapability>;
+        metadata: simple_map.SimpleMap<string, string>;
+        add_owners_events: event.EventHandle<multisig_account.AddOwnersEvent>;
+        remove_owners_events: event.EventHandle<multisig_account.RemoveOwnersEvent>;
+        update_signature_required_events: event.EventHandle<multisig_account.UpdateSignaturesRequiredEvent>;
+        create_transaction_events: event.EventHandle<multisig_account.CreateTransactionEvent>;
+        vote_events: event.EventHandle<multisig_account.VoteEvent>;
+        execute_rejected_transaction_events: event.EventHandle<multisig_account.ExecuteRejectedTransactionEvent>;
+        execute_transaction_events: event.EventHandle<multisig_account.TransactionExecutionSucceededEvent>;
+        transaction_execution_failed_events: event.EventHandle<multisig_account.TransactionExecutionFailedEvent>;
+        metadata_updated_events: event.EventHandle<multisig_account.MetadataUpdatedEvent>;
+    }
+    class MultisigAccountCreationMessage {
+        static TYPE_QNAME: string;
+        chain_id: number;
+        account_address: Address;
+        sequence_number: bigint;
+        owners: Address[];
+        num_signatures_required: bigint;
+    }
+    class MultisigTransaction {
+        static TYPE_QNAME: string;
+        payload: option.Option<string>;
+        payload_hash: option.Option<string>;
+        votes: simple_map.SimpleMap<Address, Boolean>;
+        creator: Address;
+        creation_time_secs: bigint;
+    }
+    class RemoveOwnersEvent {
+        static TYPE_QNAME: string;
+        owners_removed: Address[];
+    }
+    interface RemoveOwnersEventInstance extends TypedEventInstance<RemoveOwnersEvent> {
+        data_decoded: RemoveOwnersEvent;
+        type_arguments: [];
+    }
+    class TransactionExecutionFailedEvent {
+        static TYPE_QNAME: string;
+        executor: Address;
+        sequence_number: bigint;
+        transaction_payload: string;
+        num_approvals: bigint;
+        execution_error: multisig_account.ExecutionError;
+    }
+    interface TransactionExecutionFailedEventInstance extends TypedEventInstance<TransactionExecutionFailedEvent> {
+        data_decoded: TransactionExecutionFailedEvent;
+        type_arguments: [];
+    }
+    class TransactionExecutionSucceededEvent {
+        static TYPE_QNAME: string;
+        executor: Address;
+        sequence_number: bigint;
+        transaction_payload: string;
+        num_approvals: bigint;
+    }
+    interface TransactionExecutionSucceededEventInstance extends TypedEventInstance<TransactionExecutionSucceededEvent> {
+        data_decoded: TransactionExecutionSucceededEvent;
+        type_arguments: [];
+    }
+    class UpdateSignaturesRequiredEvent {
+        static TYPE_QNAME: string;
+        old_num_signatures_required: bigint;
+        new_num_signatures_required: bigint;
+    }
+    interface UpdateSignaturesRequiredEventInstance extends TypedEventInstance<UpdateSignaturesRequiredEvent> {
+        data_decoded: UpdateSignaturesRequiredEvent;
+        type_arguments: [];
+    }
+    class VoteEvent {
+        static TYPE_QNAME: string;
+        owner: Address;
+        sequence_number: bigint;
+        approved: Boolean;
+    }
+    interface VoteEventInstance extends TypedEventInstance<VoteEvent> {
+        data_decoded: VoteEvent;
+        type_arguments: [];
+    }
+    interface AddOwnerPayload extends TypedFunctionPayload<[Address]> {
+        arguments_decoded: [Address];
+        type_arguments: [];
+    }
+    interface AddOwnersPayload extends TypedFunctionPayload<[Address[]]> {
+        arguments_decoded: [Address[]];
+        type_arguments: [];
+    }
+    interface ApproveTransactionPayload extends TypedFunctionPayload<[Address, bigint]> {
+        arguments_decoded: [Address, bigint];
+        type_arguments: [];
+    }
+    interface CreatePayload extends TypedFunctionPayload<[bigint, string[], string[]]> {
+        arguments_decoded: [bigint, string[], string[]];
+        type_arguments: [];
+    }
+    interface CreateTransactionPayload extends TypedFunctionPayload<[Address, string]> {
+        arguments_decoded: [Address, string];
+        type_arguments: [];
+    }
+    interface CreateTransactionWithHashPayload extends TypedFunctionPayload<[Address, string]> {
+        arguments_decoded: [Address, string];
+        type_arguments: [];
+    }
+    interface CreateWithExistingAccountPayload extends TypedFunctionPayload<[
+        Address,
+        Address[],
+        bigint,
+        number,
+        string,
+        string,
+        string[],
+        string[]
+    ]> {
+        arguments_decoded: [
+            Address,
+            Address[],
+            bigint,
+            number,
+            string,
+            string,
+            string[],
+            string[]
+        ];
+        type_arguments: [];
+    }
+    interface CreateWithOwnersPayload extends TypedFunctionPayload<[Address[], bigint, string[], string[]]> {
+        arguments_decoded: [Address[], bigint, string[], string[]];
+        type_arguments: [];
+    }
+    interface ExecuteRejectedTransactionPayload extends TypedFunctionPayload<[Address]> {
+        arguments_decoded: [Address];
+        type_arguments: [];
+    }
+    interface RejectTransactionPayload extends TypedFunctionPayload<[Address, bigint]> {
+        arguments_decoded: [Address, bigint];
+        type_arguments: [];
+    }
+    interface RemoveOwnerPayload extends TypedFunctionPayload<[Address]> {
+        arguments_decoded: [Address];
+        type_arguments: [];
+    }
+    interface RemoveOwnersPayload extends TypedFunctionPayload<[Address[]]> {
+        arguments_decoded: [Address[]];
+        type_arguments: [];
+    }
+    interface UpdateMetadataPayload extends TypedFunctionPayload<[string[], string[]]> {
+        arguments_decoded: [string[], string[]];
+        type_arguments: [];
+    }
+    interface UpdateSignaturesRequiredPayload extends TypedFunctionPayload<[bigint]> {
+        arguments_decoded: [bigint];
+        type_arguments: [];
+    }
+    interface VoteTransanctionPayload extends TypedFunctionPayload<[Address, bigint, Boolean]> {
+        arguments_decoded: [Address, bigint, Boolean];
+        type_arguments: [];
+    }
+}
+export declare namespace pool_u64_unbound {
+    class Pool {
+        static TYPE_QNAME: string;
+        total_coins: bigint;
+        total_shares: bigint;
+        shares: table_with_length.TableWithLength<Address, bigint>;
+        scaling_factor: bigint;
+    }
+}
 export declare class resource_account extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
@@ -1531,7 +2100,9 @@ export declare class staking_contract extends AptosBaseProcessor {
     onEntrySwitchOperatorWithSameCommission(func: (call: staking_contract.SwitchOperatorWithSameCommissionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): staking_contract;
     onEntryUnlockRewards(func: (call: staking_contract.UnlockRewardsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): staking_contract;
     onEntryUnlockStake(func: (call: staking_contract.UnlockStakePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): staking_contract;
+    onEntryUpdateCommision(func: (call: staking_contract.UpdateCommisionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): staking_contract;
     onEntryUpdateVoter(func: (call: staking_contract.UpdateVoterPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): staking_contract;
+    onEventUpdateCommissionEvent(func: (event: staking_contract.UpdateCommissionEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): staking_contract;
     onEventCreateStakingContractEvent(func: (event: staking_contract.CreateStakingContractEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): staking_contract;
     onEventUpdateVoterEvent(func: (event: staking_contract.UpdateVoterEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): staking_contract;
     onEventResetLockupEvent(func: (event: staking_contract.ResetLockupEventInstance, ctx: AptosContext) => void, fetchConfig?: MoveFetchConfig): staking_contract;
@@ -1615,6 +2186,14 @@ export declare namespace staking_contract {
         distribution_pool: pool_u64.Pool;
         signer_cap: account.SignerCapability;
     }
+    class StakingGroupContainer {
+        static TYPE_QNAME: string;
+        dummy_field: Boolean;
+    }
+    class StakingGroupUpdateCommissionEvent {
+        static TYPE_QNAME: string;
+        update_commission_events: event.EventHandle<staking_contract.UpdateCommissionEvent>;
+    }
     class Store {
         static TYPE_QNAME: string;
         staking_contracts: simple_map.SimpleMap<Address, staking_contract.StakingContract>;
@@ -1649,6 +2228,17 @@ export declare namespace staking_contract {
         data_decoded: UnlockStakeEvent;
         type_arguments: [];
     }
+    class UpdateCommissionEvent {
+        static TYPE_QNAME: string;
+        staker: Address;
+        operator: Address;
+        old_commission_percentage: bigint;
+        new_commission_percentage: bigint;
+    }
+    interface UpdateCommissionEventInstance extends TypedEventInstance<UpdateCommissionEvent> {
+        data_decoded: UpdateCommissionEvent;
+        type_arguments: [];
+    }
     class UpdateVoterEvent {
         static TYPE_QNAME: string;
         operator: Address;
@@ -1696,6 +2286,10 @@ export declare namespace staking_contract {
         arguments_decoded: [Address, bigint];
         type_arguments: [];
     }
+    interface UpdateCommisionPayload extends TypedFunctionPayload<[Address, bigint]> {
+        arguments_decoded: [Address, bigint];
+        type_arguments: [];
+    }
     interface UpdateVoterPayload extends TypedFunctionPayload<[Address, Address]> {
         arguments_decoded: [Address, Address];
         type_arguments: [];