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

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

@@ -633,7 +633,9 @@ export declare class object_ extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): object_;
+    onEntryTransfer(func: (call: object_.TransferPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): object_;
     onEntryTransferCall(func: (call: object_.TransferCallPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): object_;
+    onEntryTransferToObject(func: (call: object_.TransferToObjectPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): object_;
     onEventTransferEvent(func: (event: object_.TransferEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): object_;
 }
 export declare namespace object_ {
@@ -652,6 +654,13 @@ export declare namespace object_ {
         const TYPE_QNAME = "0x1::object::DeleteRef";
         function type(): TypeDescriptor<DeleteRef>;
     }
+    interface DeriveRef {
+        self: Address;
+    }
+    namespace DeriveRef {
+        const TYPE_QNAME = "0x1::object::DeriveRef";
+        function type(): TypeDescriptor<DeriveRef>;
+    }
     interface ExtendRef {
         self: Address;
     }
@@ -711,10 +720,18 @@ export declare namespace object_ {
         const TYPE_QNAME = "0x1::object::TransferRef";
         function type(): TypeDescriptor<TransferRef>;
     }
+    interface TransferPayload<T0 = any> extends TypedFunctionPayload<[object_.Object<T0>, Address]> {
+        arguments_decoded: [object_.Object<T0>, Address];
+        type_arguments: [string];
+    }
     interface TransferCallPayload extends TypedFunctionPayload<[Address, Address]> {
         arguments_decoded: [Address, Address];
         type_arguments: [];
     }
+    interface TransferToObjectPayload<T0 = any, T1 = any> extends TypedFunctionPayload<[object_.Object<T0>, object_.Object<T1>]> {
+        arguments_decoded: [object_.Object<T0>, object_.Object<T1>];
+        type_arguments: [string, string];
+    }
 }
 export declare namespace option {
     interface Option<T0> {
@@ -1811,6 +1828,7 @@ export declare namespace managed_coin {
         type_arguments: [string];
     }
 }
+export declare namespace math_fixed64 { }
 export declare namespace ristretto255 {
     interface CompressedRistretto {
         data: string;
@@ -1837,7 +1855,7 @@ export declare namespace ristretto255 {
 export declare namespace smart_vector {
     interface SmartVector<T0> {
         inline_vec: T0[] | string;
-        big_vec: big_vector.BigVector<T0>[];
+        big_vec: option.Option<big_vector.BigVector<T0>>;
         inline_capacity: option.Option<bigint>;
         bucket_size: option.Option<bigint>;
     }
@@ -1846,6 +1864,31 @@ export declare namespace smart_vector {
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<SmartVector<T0>>;
     }
 }
+export declare namespace string_utils {
+    interface Cons<T0, T1> {
+        car: T0;
+        cdr: T1;
+    }
+    namespace Cons {
+        const TYPE_QNAME = "0x1::string_utils::Cons";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Cons<T0, T1>>;
+    }
+    interface FakeCons<T0, T1> {
+        car: T0;
+        cdr: T1;
+    }
+    namespace FakeCons {
+        const TYPE_QNAME = "0x1::string_utils::FakeCons";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<FakeCons<T0, T1>>;
+    }
+    interface NIL {
+        dummy_field: Boolean;
+    }
+    namespace NIL {
+        const TYPE_QNAME = "0x1::string_utils::NIL";
+        function type(): TypeDescriptor<NIL>;
+    }
+}
 export declare class aptos_account extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
@@ -1913,6 +1956,15 @@ export declare namespace fixed_point32 {
         function type(): TypeDescriptor<FixedPoint32>;
     }
 }
+export declare namespace fixed_point64 {
+    interface FixedPoint64 {
+        value: bigint;
+    }
+    namespace FixedPoint64 {
+        const TYPE_QNAME = "0x1::fixed_point64::FixedPoint64";
+        function type(): TypeDescriptor<FixedPoint64>;
+    }
+}
 export declare namespace multi_ed25519 {
     interface Signature {
         bytes: string;
@@ -2008,6 +2060,133 @@ export declare namespace state_storage {
         function type(): TypeDescriptor<Usage>;
     }
 }
+export declare namespace crypto_algebra {
+    interface Element<T0> {
+        handle: bigint;
+    }
+    namespace Element {
+        const TYPE_QNAME = "0x1::crypto_algebra::Element";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Element<T0>>;
+    }
+}
+export declare class fungible_asset extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): fungible_asset;
+    onEntryTransfer(func: (call: fungible_asset.TransferPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): fungible_asset;
+    onEventDepositEvent(func: (event: fungible_asset.DepositEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): fungible_asset;
+    onEventWithdrawEvent(func: (event: fungible_asset.WithdrawEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): fungible_asset;
+    onEventFrozenEvent(func: (event: fungible_asset.FrozenEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): fungible_asset;
+}
+export declare namespace fungible_asset {
+    interface BurnRef {
+        metadata: object_.Object<fungible_asset.Metadata>;
+    }
+    namespace BurnRef {
+        const TYPE_QNAME = "0x1::fungible_asset::BurnRef";
+        function type(): TypeDescriptor<BurnRef>;
+    }
+    interface DepositEvent {
+        amount: bigint;
+    }
+    namespace DepositEvent {
+        const TYPE_QNAME = "0x1::fungible_asset::DepositEvent";
+        function type(): TypeDescriptor<DepositEvent>;
+    }
+    interface DepositEventInstance extends TypedEventInstance<DepositEvent> {
+        data_decoded: DepositEvent;
+        type_arguments: [];
+    }
+    interface FrozenEvent {
+        frozen: Boolean;
+    }
+    namespace FrozenEvent {
+        const TYPE_QNAME = "0x1::fungible_asset::FrozenEvent";
+        function type(): TypeDescriptor<FrozenEvent>;
+    }
+    interface FrozenEventInstance extends TypedEventInstance<FrozenEvent> {
+        data_decoded: FrozenEvent;
+        type_arguments: [];
+    }
+    interface FungibleAsset {
+        metadata: object_.Object<fungible_asset.Metadata>;
+        amount: bigint;
+    }
+    namespace FungibleAsset {
+        const TYPE_QNAME = "0x1::fungible_asset::FungibleAsset";
+        function type(): TypeDescriptor<FungibleAsset>;
+    }
+    interface FungibleAssetEvents {
+        deposit_events: event.EventHandle<fungible_asset.DepositEvent>;
+        withdraw_events: event.EventHandle<fungible_asset.WithdrawEvent>;
+        frozen_events: event.EventHandle<fungible_asset.FrozenEvent>;
+    }
+    namespace FungibleAssetEvents {
+        const TYPE_QNAME = "0x1::fungible_asset::FungibleAssetEvents";
+        function type(): TypeDescriptor<FungibleAssetEvents>;
+    }
+    interface FungibleStore {
+        metadata: object_.Object<fungible_asset.Metadata>;
+        balance: bigint;
+        frozen: Boolean;
+    }
+    namespace FungibleStore {
+        const TYPE_QNAME = "0x1::fungible_asset::FungibleStore";
+        function type(): TypeDescriptor<FungibleStore>;
+    }
+    interface Metadata {
+        name: string;
+        symbol: string;
+        decimals: number;
+        icon_uri: string;
+        project_uri: string;
+    }
+    namespace Metadata {
+        const TYPE_QNAME = "0x1::fungible_asset::Metadata";
+        function type(): TypeDescriptor<Metadata>;
+    }
+    interface MintRef {
+        metadata: object_.Object<fungible_asset.Metadata>;
+    }
+    namespace MintRef {
+        const TYPE_QNAME = "0x1::fungible_asset::MintRef";
+        function type(): TypeDescriptor<MintRef>;
+    }
+    interface Supply {
+        current: bigint;
+        maximum: option.Option<bigint>;
+    }
+    namespace Supply {
+        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 WithdrawEvent {
+        amount: bigint;
+    }
+    namespace WithdrawEvent {
+        const TYPE_QNAME = "0x1::fungible_asset::WithdrawEvent";
+        function type(): TypeDescriptor<WithdrawEvent>;
+    }
+    interface WithdrawEventInstance extends TypedEventInstance<WithdrawEvent> {
+        data_decoded: WithdrawEvent;
+        type_arguments: [];
+    }
+    interface TransferPayload<T0 = any> extends TypedFunctionPayload<[
+        object_.Object<T0>,
+        object_.Object<T0>,
+        bigint
+    ]> {
+        arguments_decoded: [object_.Object<T0>, object_.Object<T0>, bigint];
+        type_arguments: [string];
+    }
+}
 export declare namespace staking_config {
     interface StakingConfig {
         minimum_stake: bigint;
@@ -2022,24 +2201,42 @@ export declare namespace staking_config {
         const TYPE_QNAME = "0x1::staking_config::StakingConfig";
         function type(): TypeDescriptor<StakingConfig>;
     }
+    interface StakingRewardsConfig {
+        rewards_rate: fixed_point64.FixedPoint64;
+        min_rewards_rate: fixed_point64.FixedPoint64;
+        rewards_rate_period_in_secs: bigint;
+        last_rewards_rate_period_start_in_secs: bigint;
+        rewards_rate_decrease_rate: fixed_point64.FixedPoint64;
+    }
+    namespace StakingRewardsConfig {
+        const TYPE_QNAME = "0x1::staking_config::StakingRewardsConfig";
+        function type(): TypeDescriptor<StakingRewardsConfig>;
+    }
 }
 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?: 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;
+    onEntryEnablePartialGovernanceVoting(func: (call: delegation_pool.EnablePartialGovernanceVotingPayload, 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;
     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;
+    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;
     onEventAddStakeEvent(func: (event: delegation_pool.AddStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventReactivateStakeEvent(func: (event: delegation_pool.ReactivateStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventUnlockStakeEvent(func: (event: delegation_pool.UnlockStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventWithdrawStakeEvent(func: (event: delegation_pool.WithdrawStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventDistributeCommissionEvent(func: (event: delegation_pool.DistributeCommissionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventVoteEvent(func: (event: delegation_pool.VoteEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventCreateProposalEvent(func: (event: delegation_pool.CreateProposalEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventDelegateVotingPowerEvent(func: (event: delegation_pool.DelegateVotingPowerEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
 }
 export declare namespace delegation_pool {
     interface AddStakeEvent {
@@ -2056,6 +2253,42 @@ export declare namespace delegation_pool {
         data_decoded: AddStakeEvent;
         type_arguments: [];
     }
+    interface CreateProposalEvent {
+        proposal_id: bigint;
+        voter: Address;
+        delegation_pool: Address;
+    }
+    namespace CreateProposalEvent {
+        const TYPE_QNAME = "0x1::delegation_pool::CreateProposalEvent";
+        function type(): TypeDescriptor<CreateProposalEvent>;
+    }
+    interface CreateProposalEventInstance extends TypedEventInstance<CreateProposalEvent> {
+        data_decoded: CreateProposalEvent;
+        type_arguments: [];
+    }
+    interface DelegateVotingPowerEvent {
+        pool_address: Address;
+        delegator: Address;
+        voter: Address;
+    }
+    namespace DelegateVotingPowerEvent {
+        const TYPE_QNAME = "0x1::delegation_pool::DelegateVotingPowerEvent";
+        function type(): TypeDescriptor<DelegateVotingPowerEvent>;
+    }
+    interface DelegateVotingPowerEventInstance extends TypedEventInstance<DelegateVotingPowerEvent> {
+        data_decoded: DelegateVotingPowerEvent;
+        type_arguments: [];
+    }
+    interface DelegatedVotes {
+        active_shares: bigint;
+        pending_inactive_shares: bigint;
+        active_shares_next_lockup: bigint;
+        last_locked_until_secs: bigint;
+    }
+    namespace DelegatedVotes {
+        const TYPE_QNAME = "0x1::delegation_pool::DelegatedVotes";
+        function type(): TypeDescriptor<DelegatedVotes>;
+    }
     interface DelegationPool {
         active_shares: pool_u64_unbound.Pool;
         observed_lockup_cycle: delegation_pool.ObservedLockupCycle;
@@ -2095,6 +2328,19 @@ export declare namespace delegation_pool {
         data_decoded: DistributeCommissionEvent;
         type_arguments: [];
     }
+    interface GovernanceRecords {
+        votes: smart_table.SmartTable<delegation_pool.VotingRecordKey, bigint>;
+        votes_per_proposal: smart_table.SmartTable<bigint, bigint>;
+        vote_delegation: smart_table.SmartTable<Address, delegation_pool.VoteDelegation>;
+        delegated_votes: smart_table.SmartTable<Address, delegation_pool.DelegatedVotes>;
+        vote_events: event.EventHandle<delegation_pool.VoteEvent>;
+        create_proposal_events: event.EventHandle<delegation_pool.CreateProposalEvent>;
+        delegate_voting_power_events: event.EventHandle<delegation_pool.DelegateVotingPowerEvent>;
+    }
+    namespace GovernanceRecords {
+        const TYPE_QNAME = "0x1::delegation_pool::GovernanceRecords";
+        function type(): TypeDescriptor<GovernanceRecords>;
+    }
     interface ObservedLockupCycle {
         index: bigint;
     }
@@ -2128,6 +2374,38 @@ export declare namespace delegation_pool {
         data_decoded: UnlockStakeEvent;
         type_arguments: [];
     }
+    interface VoteDelegation {
+        voter: Address;
+        pending_voter: Address;
+        last_locked_until_secs: bigint;
+    }
+    namespace VoteDelegation {
+        const TYPE_QNAME = "0x1::delegation_pool::VoteDelegation";
+        function type(): TypeDescriptor<VoteDelegation>;
+    }
+    interface VoteEvent {
+        voter: Address;
+        proposal_id: bigint;
+        delegation_pool: Address;
+        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: Address;
+        proposal_id: bigint;
+    }
+    namespace VotingRecordKey {
+        const TYPE_QNAME = "0x1::delegation_pool::VotingRecordKey";
+        function type(): TypeDescriptor<VotingRecordKey>;
+    }
     interface WithdrawStakeEvent {
         pool_address: Address;
         delegator_address: Address;
@@ -2145,6 +2423,18 @@ export declare namespace delegation_pool {
         arguments_decoded: [Address, bigint];
         type_arguments: [];
     }
+    interface CreateProposalPayload extends TypedFunctionPayload<[Address, string, string, string, Boolean]> {
+        arguments_decoded: [Address, string, string, string, Boolean];
+        type_arguments: [];
+    }
+    interface DelegateVotingPowerPayload extends TypedFunctionPayload<[Address, Address]> {
+        arguments_decoded: [Address, Address];
+        type_arguments: [];
+    }
+    interface EnablePartialGovernanceVotingPayload extends TypedFunctionPayload<[Address]> {
+        arguments_decoded: [Address];
+        type_arguments: [];
+    }
     interface InitializeDelegationPoolPayload extends TypedFunctionPayload<[bigint, string]> {
         arguments_decoded: [bigint, string];
         type_arguments: [];
@@ -2169,6 +2459,10 @@ export declare namespace delegation_pool {
         arguments_decoded: [Address, bigint];
         type_arguments: [];
     }
+    interface VotePayload extends TypedFunctionPayload<[Address, bigint, bigint, Boolean]> {
+        arguments_decoded: [Address, bigint, bigint, Boolean];
+        type_arguments: [];
+    }
     interface WithdrawPayload extends TypedFunctionPayload<[Address, bigint]> {
         arguments_decoded: [Address, bigint];
         type_arguments: [];
@@ -2234,6 +2528,7 @@ export declare class aptos_governance extends AptosBaseProcessor {
     onEntryAddApprovedScriptHashScript(func: (call: aptos_governance.AddApprovedScriptHashScriptPayload, 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;
+    onEntryPartialVote(func: (call: aptos_governance.PartialVotePayload, 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;
     onEventCreateProposalEvent(func: (event: aptos_governance.CreateProposalEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
     onEventUpdateConfigEvent(func: (event: aptos_governance.UpdateConfigEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
@@ -2330,6 +2625,13 @@ export declare namespace aptos_governance {
         const TYPE_QNAME = "0x1::aptos_governance::VotingRecords";
         function type(): TypeDescriptor<VotingRecords>;
     }
+    interface VotingRecordsV2 {
+        votes: smart_table.SmartTable<aptos_governance.RecordKey, bigint>;
+    }
+    namespace VotingRecordsV2 {
+        const TYPE_QNAME = "0x1::aptos_governance::VotingRecordsV2";
+        function type(): TypeDescriptor<VotingRecordsV2>;
+    }
     interface AddApprovedScriptHashScriptPayload extends TypedFunctionPayload<[bigint]> {
         arguments_decoded: [bigint];
         type_arguments: [];
@@ -2342,11 +2644,122 @@ export declare namespace aptos_governance {
         arguments_decoded: [Address, string, string, string, Boolean];
         type_arguments: [];
     }
+    interface PartialVotePayload extends TypedFunctionPayload<[Address, bigint, bigint, Boolean]> {
+        arguments_decoded: [Address, bigint, bigint, Boolean];
+        type_arguments: [];
+    }
     interface VotePayload extends TypedFunctionPayload<[Address, bigint, Boolean]> {
         arguments_decoded: [Address, bigint, Boolean];
         type_arguments: [];
     }
 }
+export declare namespace bls12381_algebra {
+    interface FormatFq12LscLsb {
+        dummy_field: Boolean;
+    }
+    namespace FormatFq12LscLsb {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatFq12LscLsb";
+        function type(): TypeDescriptor<FormatFq12LscLsb>;
+    }
+    interface FormatFrLsb {
+        dummy_field: Boolean;
+    }
+    namespace FormatFrLsb {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatFrLsb";
+        function type(): TypeDescriptor<FormatFrLsb>;
+    }
+    interface FormatFrMsb {
+        dummy_field: Boolean;
+    }
+    namespace FormatFrMsb {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatFrMsb";
+        function type(): TypeDescriptor<FormatFrMsb>;
+    }
+    interface FormatG1Compr {
+        dummy_field: Boolean;
+    }
+    namespace FormatG1Compr {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatG1Compr";
+        function type(): TypeDescriptor<FormatG1Compr>;
+    }
+    interface FormatG1Uncompr {
+        dummy_field: Boolean;
+    }
+    namespace FormatG1Uncompr {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatG1Uncompr";
+        function type(): TypeDescriptor<FormatG1Uncompr>;
+    }
+    interface FormatG2Compr {
+        dummy_field: Boolean;
+    }
+    namespace FormatG2Compr {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatG2Compr";
+        function type(): TypeDescriptor<FormatG2Compr>;
+    }
+    interface FormatG2Uncompr {
+        dummy_field: Boolean;
+    }
+    namespace FormatG2Uncompr {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatG2Uncompr";
+        function type(): TypeDescriptor<FormatG2Uncompr>;
+    }
+    interface FormatGt {
+        dummy_field: Boolean;
+    }
+    namespace FormatGt {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatGt";
+        function type(): TypeDescriptor<FormatGt>;
+    }
+    interface Fq12 {
+        dummy_field: Boolean;
+    }
+    namespace Fq12 {
+        const TYPE_QNAME = "0x1::bls12381_algebra::Fq12";
+        function type(): TypeDescriptor<Fq12>;
+    }
+    interface Fr {
+        dummy_field: Boolean;
+    }
+    namespace Fr {
+        const TYPE_QNAME = "0x1::bls12381_algebra::Fr";
+        function type(): TypeDescriptor<Fr>;
+    }
+    interface G1 {
+        dummy_field: Boolean;
+    }
+    namespace G1 {
+        const TYPE_QNAME = "0x1::bls12381_algebra::G1";
+        function type(): TypeDescriptor<G1>;
+    }
+    interface G2 {
+        dummy_field: Boolean;
+    }
+    namespace G2 {
+        const TYPE_QNAME = "0x1::bls12381_algebra::G2";
+        function type(): TypeDescriptor<G2>;
+    }
+    interface Gt {
+        dummy_field: Boolean;
+    }
+    namespace Gt {
+        const TYPE_QNAME = "0x1::bls12381_algebra::Gt";
+        function type(): TypeDescriptor<Gt>;
+    }
+    interface HashG1XmdSha256SswuRo {
+        dummy_field: Boolean;
+    }
+    namespace HashG1XmdSha256SswuRo {
+        const TYPE_QNAME = "0x1::bls12381_algebra::HashG1XmdSha256SswuRo";
+        function type(): TypeDescriptor<HashG1XmdSha256SswuRo>;
+    }
+    interface HashG2XmdSha256SswuRo {
+        dummy_field: Boolean;
+    }
+    namespace HashG2XmdSha256SswuRo {
+        const TYPE_QNAME = "0x1::bls12381_algebra::HashG2XmdSha256SswuRo";
+        function type(): TypeDescriptor<HashG2XmdSha256SswuRo>;
+    }
+}
 export declare namespace consensus_config {
     interface ConsensusConfig {
         config: string;
@@ -2356,22 +2769,37 @@ export declare namespace consensus_config {
         function type(): TypeDescriptor<ConsensusConfig>;
     }
 }
+export declare namespace execution_config {
+    interface ExecutionConfig {
+        config: string;
+    }
+    namespace ExecutionConfig {
+        const TYPE_QNAME = "0x1::execution_config::ExecutionConfig";
+        function type(): TypeDescriptor<ExecutionConfig>;
+    }
+}
 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?: 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;
+    onEntryCreateWithExistingAccountAndRevokeAuthKey(func: (call: multisig_account.CreateWithExistingAccountAndRevokeAuthKeyPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryCreateWithOwners(func: (call: multisig_account.CreateWithOwnersPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEntryCreateWithOwnersThenRemoveBootstrapper(func: (call: multisig_account.CreateWithOwnersThenRemoveBootstrapperPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryExecuteRejectedTransaction(func: (call: multisig_account.ExecuteRejectedTransactionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryRejectTransaction(func: (call: multisig_account.RejectTransactionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryRemoveOwner(func: (call: multisig_account.RemoveOwnerPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryRemoveOwners(func: (call: multisig_account.RemoveOwnersPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEntrySwapOwner(func: (call: multisig_account.SwapOwnerPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEntrySwapOwners(func: (call: multisig_account.SwapOwnersPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEntrySwapOwnersAndUpdateSignaturesRequired(func: (call: multisig_account.SwapOwnersAndUpdateSignaturesRequiredPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryUpdateMetadata(func: (call: multisig_account.UpdateMetadataPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryUpdateSignaturesRequired(func: (call: multisig_account.UpdateSignaturesRequiredPayload, 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;
@@ -2477,6 +2905,17 @@ export declare namespace multisig_account {
         const TYPE_QNAME = "0x1::multisig_account::MultisigAccountCreationMessage";
         function type(): TypeDescriptor<MultisigAccountCreationMessage>;
     }
+    interface MultisigAccountCreationWithAuthKeyRevocationMessage {
+        chain_id: number;
+        account_address: Address;
+        sequence_number: bigint;
+        owners: Address[];
+        num_signatures_required: bigint;
+    }
+    namespace MultisigAccountCreationWithAuthKeyRevocationMessage {
+        const TYPE_QNAME = "0x1::multisig_account::MultisigAccountCreationWithAuthKeyRevocationMessage";
+        function type(): TypeDescriptor<MultisigAccountCreationWithAuthKeyRevocationMessage>;
+    }
     interface MultisigTransaction {
         payload: option.Option<string>;
         payload_hash: option.Option<string>;
@@ -2561,6 +3000,10 @@ export declare namespace multisig_account {
         arguments_decoded: [Address[]];
         type_arguments: [];
     }
+    interface AddOwnersAndUpdateSignaturesRequiredPayload extends TypedFunctionPayload<[Address[], bigint]> {
+        arguments_decoded: [Address[], bigint];
+        type_arguments: [];
+    }
     interface ApproveTransactionPayload extends TypedFunctionPayload<[Address, bigint]> {
         arguments_decoded: [Address, bigint];
         type_arguments: [];
@@ -2599,10 +3042,36 @@ export declare namespace multisig_account {
         ];
         type_arguments: [];
     }
+    interface CreateWithExistingAccountAndRevokeAuthKeyPayload 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 CreateWithOwnersThenRemoveBootstrapperPayload extends TypedFunctionPayload<[Address[], bigint, string[], string[]]> {
+        arguments_decoded: [Address[], bigint, string[], string[]];
+        type_arguments: [];
+    }
     interface ExecuteRejectedTransactionPayload extends TypedFunctionPayload<[Address]> {
         arguments_decoded: [Address];
         type_arguments: [];
@@ -2619,6 +3088,18 @@ export declare namespace multisig_account {
         arguments_decoded: [Address[]];
         type_arguments: [];
     }
+    interface SwapOwnerPayload extends TypedFunctionPayload<[Address, Address]> {
+        arguments_decoded: [Address, Address];
+        type_arguments: [];
+    }
+    interface SwapOwnersPayload extends TypedFunctionPayload<[Address[], Address[]]> {
+        arguments_decoded: [Address[], Address[]];
+        type_arguments: [];
+    }
+    interface SwapOwnersAndUpdateSignaturesRequiredPayload extends TypedFunctionPayload<[Address[], Address[], bigint]> {
+        arguments_decoded: [Address[], Address[], bigint];
+        type_arguments: [];
+    }
     interface UpdateMetadataPayload extends TypedFunctionPayload<[string[], string[]]> {
         arguments_decoded: [string[], string[]];
         type_arguments: [];
@@ -2970,7 +3451,34 @@ export declare namespace optional_aggregator {
         function type(): TypeDescriptor<OptionalAggregator>;
     }
 }
-export declare namespace transaction_context { }
+export declare namespace transaction_context {
+    interface AUID {
+        unique_address: Address;
+    }
+    namespace AUID {
+        const TYPE_QNAME = "0x1::transaction_context::AUID";
+        function type(): TypeDescriptor<AUID>;
+    }
+}
+export declare class primary_fungible_store extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): primary_fungible_store;
+    onEntryTransfer(func: (call: primary_fungible_store.TransferPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): primary_fungible_store;
+}
+export declare namespace primary_fungible_store {
+    interface DeriveRefPod {
+        metadata_derive_ref: object_.DeriveRef;
+    }
+    namespace DeriveRefPod {
+        const TYPE_QNAME = "0x1::primary_fungible_store::DeriveRefPod";
+        function type(): TypeDescriptor<DeriveRefPod>;
+    }
+    interface TransferPayload<T0 = any> extends TypedFunctionPayload<[object_.Object<T0>, Address, bigint]> {
+        arguments_decoded: [object_.Object<T0>, Address, bigint];
+        type_arguments: [string];
+    }
+}
 export declare namespace transaction_validation {
     interface TransactionValidation {
         module_addr: Address;