@sentio/sdk 3.8.0-rc.3 → 3.9.0-rc.10

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

@@ -905,6 +905,7 @@ export declare class stake extends AptosBaseProcessor {
     onEventUnlockStakeEvent(func: (event: stake.UnlockStakeEventInstance, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, stake.UnlockStakeEventInstance>, eventFilter?: Omit<EventFilter, "type" | "account">): stake;
     onEventUpdateNetworkAndFullnodeAddresses(func: (event: stake.UpdateNetworkAndFullnodeAddressesInstance, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, stake.UpdateNetworkAndFullnodeAddressesInstance>, eventFilter?: Omit<EventFilter, "type" | "account">): stake;
     onEventUpdateNetworkAndFullnodeAddressesEvent(func: (event: stake.UpdateNetworkAndFullnodeAddressesEventInstance, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, stake.UpdateNetworkAndFullnodeAddressesEventInstance>, eventFilter?: Omit<EventFilter, "type" | "account">): stake;
+    onEventValidatorSetLivenessFallback(func: (event: stake.ValidatorSetLivenessFallbackInstance, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, stake.ValidatorSetLivenessFallbackInstance>, eventFilter?: Omit<EventFilter, "type" | "account">): stake;
     onEventWithdrawStake(func: (event: stake.WithdrawStakeInstance, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, stake.WithdrawStakeInstance>, eventFilter?: Omit<EventFilter, "type" | "account">): stake;
     onEventWithdrawStakeEvent(func: (event: stake.WithdrawStakeEventInstance, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, stake.WithdrawStakeEventInstance>, eventFilter?: Omit<EventFilter, "type" | "account">): stake;
 }
@@ -1314,6 +1315,19 @@ export declare namespace stake {
         const TYPE_QNAME = "0x1::stake::ValidatorSet";
         function type(): TypeDescriptor<ValidatorSet>;
     }
+    interface ValidatorSetLivenessFallback {
+        minimum_stake: bigint;
+        emergency_validator_count: bigint;
+        total_emergency_voting_power: bigint;
+    }
+    namespace ValidatorSetLivenessFallback {
+        const TYPE_QNAME = "0x1::stake::ValidatorSetLivenessFallback";
+        function type(): TypeDescriptor<ValidatorSetLivenessFallback>;
+    }
+    type ValidatorSetLivenessFallbackInstance = TypedEventInstance<ValidatorSetLivenessFallback> & {
+        data_decoded: ValidatorSetLivenessFallback;
+        type_arguments: [];
+    };
     interface WithdrawStake {
         pool_address: MoveAddressType;
         amount_withdrawn: bigint;
@@ -3387,6 +3401,55 @@ export declare namespace capability {
     namespace entry { }
     namespace view { }
 }
+export declare class chunky_dkg extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): chunky_dkg;
+    onEventChunkyDKGStartEvent(func: (event: chunky_dkg.ChunkyDKGStartEventInstance, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, chunky_dkg.ChunkyDKGStartEventInstance>, eventFilter?: Omit<EventFilter, "type" | "account">): chunky_dkg;
+}
+export declare namespace chunky_dkg {
+    interface ChunkyDKGSessionMetadata {
+        dealer_epoch: bigint;
+        chunky_dkg_config: chunky_dkg_config.ChunkyDKGConfig;
+        dealer_validator_set: validator_consensus_info.ValidatorConsensusInfo[];
+        target_validator_set: validator_consensus_info.ValidatorConsensusInfo[];
+    }
+    namespace ChunkyDKGSessionMetadata {
+        const TYPE_QNAME = "0x1::chunky_dkg::ChunkyDKGSessionMetadata";
+        function type(): TypeDescriptor<ChunkyDKGSessionMetadata>;
+    }
+    interface ChunkyDKGSessionState {
+        metadata: chunky_dkg.ChunkyDKGSessionMetadata;
+        start_time_us: bigint;
+        aggregated_subtranscript: string;
+    }
+    namespace ChunkyDKGSessionState {
+        const TYPE_QNAME = "0x1::chunky_dkg::ChunkyDKGSessionState";
+        function type(): TypeDescriptor<ChunkyDKGSessionState>;
+    }
+    interface ChunkyDKGStartEvent {
+        session_metadata: chunky_dkg.ChunkyDKGSessionMetadata;
+        start_time_us: bigint;
+    }
+    namespace ChunkyDKGStartEvent {
+        const TYPE_QNAME = "0x1::chunky_dkg::ChunkyDKGStartEvent";
+        function type(): TypeDescriptor<ChunkyDKGStartEvent>;
+    }
+    type ChunkyDKGStartEventInstance = TypedEventInstance<ChunkyDKGStartEvent> & {
+        data_decoded: ChunkyDKGStartEvent;
+        type_arguments: [];
+    };
+    interface ChunkyDKGState {
+        last_completed: option.Option<chunky_dkg.ChunkyDKGSessionState>;
+        in_progress: option.Option<chunky_dkg.ChunkyDKGSessionState>;
+    }
+    namespace ChunkyDKGState {
+        const TYPE_QNAME = "0x1::chunky_dkg::ChunkyDKGState";
+        function type(): TypeDescriptor<ChunkyDKGState>;
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace comparator {
     interface Result {
         inner: number;
@@ -3398,6 +3461,27 @@ export declare namespace comparator {
     namespace entry { }
     namespace view { }
 }
+export declare namespace decryption {
+    interface PerBlockDecryptionKey {
+        epoch: bigint;
+        round: bigint;
+        decryption_key: option.Option<string>;
+    }
+    namespace PerBlockDecryptionKey {
+        const TYPE_QNAME = "0x1::decryption::PerBlockDecryptionKey";
+        function type(): TypeDescriptor<PerBlockDecryptionKey>;
+    }
+    interface PerEpochEncryptionKey {
+        epoch: bigint;
+        encryption_key: option.Option<string>;
+    }
+    namespace PerEpochEncryptionKey {
+        const TYPE_QNAME = "0x1::decryption::PerEpochEncryptionKey";
+        function type(): TypeDescriptor<PerEpochEncryptionKey>;
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace math_fixed {
     namespace entry { }
     namespace view { }
@@ -4593,6 +4677,9 @@ export declare namespace fungible_asset {
             typeArguments: [MoveStructId];
             functionArguments: [object$.Object<T0>];
         }, version?: bigint): Promise<[fungible_asset.Metadata]>;
+        function isAssetTypeDispatchable(client: Aptos, request: {
+            functionArguments: [object$.Object<fungible_asset.Metadata>];
+        }, version?: bigint): Promise<[boolean]>;
         function isBalanceAtLeast<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
             functionArguments: [object$.Object<T0>, bigint];
@@ -4634,6 +4721,10 @@ export declare namespace fungible_asset {
         type_arguments: [string];
     }
 }
+export declare namespace sigma_protocol {
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace staking_config {
     interface StakingConfig {
         minimum_stake: bigint;
@@ -7204,6 +7295,9 @@ export declare namespace staking_contract {
         function lastRecordedPrincipal(client: Aptos, request: {
             functionArguments: [MoveAddressType, MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
+        function pendingAttributionSnapshot(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
         function pendingDistributionCounts(client: Aptos, request: {
             functionArguments: [MoveAddressType, MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
@@ -7285,6 +7379,32 @@ export declare namespace system_addresses {
     namespace entry { }
     namespace view { }
 }
+export declare namespace chunky_dkg_config {
+    interface ConfigOff {
+        dummy_field: boolean;
+    }
+    namespace ConfigOff {
+        const TYPE_QNAME = "0x1::chunky_dkg_config::ConfigOff";
+        function type(): TypeDescriptor<ConfigOff>;
+    }
+    interface ConfigV1 {
+        secrecy_threshold: fixed_point64.FixedPoint64;
+        reconstruction_threshold: fixed_point64.FixedPoint64;
+    }
+    namespace ConfigV1 {
+        const TYPE_QNAME = "0x1::chunky_dkg_config::ConfigV1";
+        function type(): TypeDescriptor<ConfigV1>;
+    }
+    interface ChunkyDKGConfig {
+        variant: copyable_any.Any;
+    }
+    namespace ChunkyDKGConfig {
+        const TYPE_QNAME = "0x1::chunky_dkg_config::ChunkyDKGConfig";
+        function type(): TypeDescriptor<ChunkyDKGConfig>;
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace federated_keyless {
     interface PublicKey {
         jwk_address: MoveAddressType;
@@ -7355,6 +7475,517 @@ export declare namespace aggregator_factory {
     namespace entry { }
     namespace view { }
 }
+export declare class confidential_asset extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): confidential_asset;
+    onEntryDeposit(func: (call: confidential_asset.DepositPayload, ctx: AptosContext) => void, filter?: CallFilter, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.DepositPayload>): confidential_asset;
+    onEntryConfidentialTransferRaw(func: (call: confidential_asset.ConfidentialTransferRawPayload, ctx: AptosContext) => void, filter?: CallFilter, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.ConfidentialTransferRawPayload>): confidential_asset;
+    onEntryNormalizeRaw(func: (call: confidential_asset.NormalizeRawPayload, ctx: AptosContext) => void, filter?: CallFilter, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.NormalizeRawPayload>): confidential_asset;
+    onEntryRegisterRaw(func: (call: confidential_asset.RegisterRawPayload, ctx: AptosContext) => void, filter?: CallFilter, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.RegisterRawPayload>): confidential_asset;
+    onEntryRolloverPendingBalance(func: (call: confidential_asset.RolloverPendingBalancePayload, ctx: AptosContext) => void, filter?: CallFilter, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.RolloverPendingBalancePayload>): confidential_asset;
+    onEntryRolloverPendingBalanceAndPause(func: (call: confidential_asset.RolloverPendingBalanceAndPausePayload, ctx: AptosContext) => void, filter?: CallFilter, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.RolloverPendingBalanceAndPausePayload>): confidential_asset;
+    onEntryRotateEncryptionKeyRaw(func: (call: confidential_asset.RotateEncryptionKeyRawPayload, ctx: AptosContext) => void, filter?: CallFilter, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.RotateEncryptionKeyRawPayload>): confidential_asset;
+    onEntrySetIncomingTransfersPaused(func: (call: confidential_asset.SetIncomingTransfersPausedPayload, ctx: AptosContext) => void, filter?: CallFilter, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.SetIncomingTransfersPausedPayload>): confidential_asset;
+    onEntryWithdrawToRaw(func: (call: confidential_asset.WithdrawToRawPayload, ctx: AptosContext) => void, filter?: CallFilter, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.WithdrawToRawPayload>): confidential_asset;
+    onEventAllowListingChanged(func: (event: confidential_asset.AllowListingChangedInstance, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.AllowListingChangedInstance>, eventFilter?: Omit<EventFilter, "type" | "account">): confidential_asset;
+    onEventAssetSpecificAuditorChanged(func: (event: confidential_asset.AssetSpecificAuditorChangedInstance, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.AssetSpecificAuditorChangedInstance>, eventFilter?: Omit<EventFilter, "type" | "account">): confidential_asset;
+    onEventConfidentialityForAssetTypeChanged(func: (event: confidential_asset.ConfidentialityForAssetTypeChangedInstance, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.ConfidentialityForAssetTypeChangedInstance>, eventFilter?: Omit<EventFilter, "type" | "account">): confidential_asset;
+    onEventDeposited(func: (event: confidential_asset.DepositedInstance, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.DepositedInstance>, eventFilter?: Omit<EventFilter, "type" | "account">): confidential_asset;
+    onEventEmergencyPauseChanged(func: (event: confidential_asset.EmergencyPauseChangedInstance, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.EmergencyPauseChangedInstance>, eventFilter?: Omit<EventFilter, "type" | "account">): confidential_asset;
+    onEventGlobalAuditorChanged(func: (event: confidential_asset.GlobalAuditorChangedInstance, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.GlobalAuditorChangedInstance>, eventFilter?: Omit<EventFilter, "type" | "account">): confidential_asset;
+    onEventIncomingTransfersPauseChanged(func: (event: confidential_asset.IncomingTransfersPauseChangedInstance, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.IncomingTransfersPauseChangedInstance>, eventFilter?: Omit<EventFilter, "type" | "account">): confidential_asset;
+    onEventKeyRotated(func: (event: confidential_asset.KeyRotatedInstance, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.KeyRotatedInstance>, eventFilter?: Omit<EventFilter, "type" | "account">): confidential_asset;
+    onEventNormalized(func: (event: confidential_asset.NormalizedInstance, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.NormalizedInstance>, eventFilter?: Omit<EventFilter, "type" | "account">): confidential_asset;
+    onEventRegistered(func: (event: confidential_asset.RegisteredInstance, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.RegisteredInstance>, eventFilter?: Omit<EventFilter, "type" | "account">): confidential_asset;
+    onEventRolledOver(func: (event: confidential_asset.RolledOverInstance, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.RolledOverInstance>, eventFilter?: Omit<EventFilter, "type" | "account">): confidential_asset;
+    onEventTransferred(func: (event: confidential_asset.TransferredInstance, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.TransferredInstance>, eventFilter?: Omit<EventFilter, "type" | "account">): confidential_asset;
+    onEventWithdrawn(func: (event: confidential_asset.WithdrawnInstance, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, confidential_asset.WithdrawnInstance>, eventFilter?: Omit<EventFilter, "type" | "account">): confidential_asset;
+}
+export declare namespace confidential_asset {
+    interface AllowListingChanged {
+    }
+    namespace AllowListingChanged {
+        const TYPE_QNAME = "0x1::confidential_asset::AllowListingChanged";
+        function type(): TypeDescriptor<AllowListingChanged>;
+    }
+    type AllowListingChangedInstance = TypedEventInstance<AllowListingChanged> & {
+        data_decoded: AllowListingChanged;
+        type_arguments: [];
+    };
+    interface AssetConfig {
+    }
+    namespace AssetConfig {
+        const TYPE_QNAME = "0x1::confidential_asset::AssetConfig";
+        function type(): TypeDescriptor<AssetConfig>;
+    }
+    interface AssetSpecificAuditorChanged {
+    }
+    namespace AssetSpecificAuditorChanged {
+        const TYPE_QNAME = "0x1::confidential_asset::AssetSpecificAuditorChanged";
+        function type(): TypeDescriptor<AssetSpecificAuditorChanged>;
+    }
+    type AssetSpecificAuditorChangedInstance = TypedEventInstance<AssetSpecificAuditorChanged> & {
+        data_decoded: AssetSpecificAuditorChanged;
+        type_arguments: [];
+    };
+    interface AuditorConfig {
+    }
+    namespace AuditorConfig {
+        const TYPE_QNAME = "0x1::confidential_asset::AuditorConfig";
+        function type(): TypeDescriptor<AuditorConfig>;
+    }
+    interface ConfidentialStore {
+    }
+    namespace ConfidentialStore {
+        const TYPE_QNAME = "0x1::confidential_asset::ConfidentialStore";
+        function type(): TypeDescriptor<ConfidentialStore>;
+    }
+    interface ConfidentialityForAssetTypeChanged {
+    }
+    namespace ConfidentialityForAssetTypeChanged {
+        const TYPE_QNAME = "0x1::confidential_asset::ConfidentialityForAssetTypeChanged";
+        function type(): TypeDescriptor<ConfidentialityForAssetTypeChanged>;
+    }
+    type ConfidentialityForAssetTypeChangedInstance = TypedEventInstance<ConfidentialityForAssetTypeChanged> & {
+        data_decoded: ConfidentialityForAssetTypeChanged;
+        type_arguments: [];
+    };
+    interface Deposited {
+    }
+    namespace Deposited {
+        const TYPE_QNAME = "0x1::confidential_asset::Deposited";
+        function type(): TypeDescriptor<Deposited>;
+    }
+    type DepositedInstance = TypedEventInstance<Deposited> & {
+        data_decoded: Deposited;
+        type_arguments: [];
+    };
+    interface EffectiveAuditorConfig {
+    }
+    namespace EffectiveAuditorConfig {
+        const TYPE_QNAME = "0x1::confidential_asset::EffectiveAuditorConfig";
+        function type(): TypeDescriptor<EffectiveAuditorConfig>;
+    }
+    interface EffectiveAuditorHint {
+    }
+    namespace EffectiveAuditorHint {
+        const TYPE_QNAME = "0x1::confidential_asset::EffectiveAuditorHint";
+        function type(): TypeDescriptor<EffectiveAuditorHint>;
+    }
+    interface EmergencyPauseChanged {
+    }
+    namespace EmergencyPauseChanged {
+        const TYPE_QNAME = "0x1::confidential_asset::EmergencyPauseChanged";
+        function type(): TypeDescriptor<EmergencyPauseChanged>;
+    }
+    type EmergencyPauseChangedInstance = TypedEventInstance<EmergencyPauseChanged> & {
+        data_decoded: EmergencyPauseChanged;
+        type_arguments: [];
+    };
+    interface GlobalAuditorChanged {
+    }
+    namespace GlobalAuditorChanged {
+        const TYPE_QNAME = "0x1::confidential_asset::GlobalAuditorChanged";
+        function type(): TypeDescriptor<GlobalAuditorChanged>;
+    }
+    type GlobalAuditorChangedInstance = TypedEventInstance<GlobalAuditorChanged> & {
+        data_decoded: GlobalAuditorChanged;
+        type_arguments: [];
+    };
+    interface GlobalConfig {
+    }
+    namespace GlobalConfig {
+        const TYPE_QNAME = "0x1::confidential_asset::GlobalConfig";
+        function type(): TypeDescriptor<GlobalConfig>;
+    }
+    interface IncomingTransfersPauseChanged {
+    }
+    namespace IncomingTransfersPauseChanged {
+        const TYPE_QNAME = "0x1::confidential_asset::IncomingTransfersPauseChanged";
+        function type(): TypeDescriptor<IncomingTransfersPauseChanged>;
+    }
+    type IncomingTransfersPauseChangedInstance = TypedEventInstance<IncomingTransfersPauseChanged> & {
+        data_decoded: IncomingTransfersPauseChanged;
+        type_arguments: [];
+    };
+    interface KeyRotated {
+    }
+    namespace KeyRotated {
+        const TYPE_QNAME = "0x1::confidential_asset::KeyRotated";
+        function type(): TypeDescriptor<KeyRotated>;
+    }
+    type KeyRotatedInstance = TypedEventInstance<KeyRotated> & {
+        data_decoded: KeyRotated;
+        type_arguments: [];
+    };
+    interface KeyRotationProof {
+    }
+    namespace KeyRotationProof {
+        const TYPE_QNAME = "0x1::confidential_asset::KeyRotationProof";
+        function type(): TypeDescriptor<KeyRotationProof>;
+    }
+    interface Normalized {
+    }
+    namespace Normalized {
+        const TYPE_QNAME = "0x1::confidential_asset::Normalized";
+        function type(): TypeDescriptor<Normalized>;
+    }
+    type NormalizedInstance = TypedEventInstance<Normalized> & {
+        data_decoded: Normalized;
+        type_arguments: [];
+    };
+    interface Registered {
+    }
+    namespace Registered {
+        const TYPE_QNAME = "0x1::confidential_asset::Registered";
+        function type(): TypeDescriptor<Registered>;
+    }
+    type RegisteredInstance = TypedEventInstance<Registered> & {
+        data_decoded: Registered;
+        type_arguments: [];
+    };
+    interface RegistrationProof {
+    }
+    namespace RegistrationProof {
+        const TYPE_QNAME = "0x1::confidential_asset::RegistrationProof";
+        function type(): TypeDescriptor<RegistrationProof>;
+    }
+    interface RolledOver {
+    }
+    namespace RolledOver {
+        const TYPE_QNAME = "0x1::confidential_asset::RolledOver";
+        function type(): TypeDescriptor<RolledOver>;
+    }
+    type RolledOverInstance = TypedEventInstance<RolledOver> & {
+        data_decoded: RolledOver;
+        type_arguments: [];
+    };
+    interface TransferProof {
+    }
+    namespace TransferProof {
+        const TYPE_QNAME = "0x1::confidential_asset::TransferProof";
+        function type(): TypeDescriptor<TransferProof>;
+    }
+    interface Transferred {
+    }
+    namespace Transferred {
+        const TYPE_QNAME = "0x1::confidential_asset::Transferred";
+        function type(): TypeDescriptor<Transferred>;
+    }
+    type TransferredInstance = TypedEventInstance<Transferred> & {
+        data_decoded: Transferred;
+        type_arguments: [];
+    };
+    interface WithdrawalProof {
+    }
+    namespace WithdrawalProof {
+        const TYPE_QNAME = "0x1::confidential_asset::WithdrawalProof";
+        function type(): TypeDescriptor<WithdrawalProof>;
+    }
+    interface Withdrawn {
+    }
+    namespace Withdrawn {
+        const TYPE_QNAME = "0x1::confidential_asset::Withdrawn";
+        function type(): TypeDescriptor<Withdrawn>;
+    }
+    type WithdrawnInstance = TypedEventInstance<Withdrawn> & {
+        data_decoded: Withdrawn;
+        type_arguments: [];
+    };
+    namespace entry {
+        function deposit(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [object$.Object<fungible_asset.Metadata>, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function confidentialTransferRaw(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [
+                object$.Object<fungible_asset.Metadata>,
+                MoveAddressType,
+                string[],
+                string[],
+                string[],
+                string[],
+                string[],
+                string[],
+                string[],
+                string[],
+                string[][],
+                string,
+                string,
+                string[],
+                string[],
+                string
+            ];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function normalizeRaw(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [
+                object$.Object<fungible_asset.Metadata>,
+                string[],
+                string[],
+                string[],
+                string,
+                string[],
+                string[]
+            ];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function registerRaw(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [
+                object$.Object<fungible_asset.Metadata>,
+                string,
+                string[],
+                string[]
+            ];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function rolloverPendingBalance(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [object$.Object<fungible_asset.Metadata>];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function rolloverPendingBalanceAndPause(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [object$.Object<fungible_asset.Metadata>];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function rotateEncryptionKeyRaw(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [
+                object$.Object<fungible_asset.Metadata>,
+                string,
+                boolean,
+                string[],
+                string[],
+                string[]
+            ];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setIncomingTransfersPaused(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [object$.Object<fungible_asset.Metadata>, boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function withdrawToRaw(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [
+                object$.Object<fungible_asset.Metadata>,
+                MoveAddressType,
+                bigint,
+                string[],
+                string[],
+                string[],
+                string,
+                string[],
+                string[]
+            ];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view {
+        function getAssetSpecificAuditorConfig(client: Aptos, request: {
+            functionArguments: [object$.Object<fungible_asset.Metadata>];
+        }, version?: bigint): Promise<[confidential_asset.AuditorConfig]>;
+        function getAvailableBalance(client: Aptos, request: {
+            functionArguments: [
+                MoveAddressType,
+                object$.Object<fungible_asset.Metadata>
+            ];
+        }, version?: bigint): Promise<[
+            confidential_balance.CompressedBalance<confidential_balance.Available>
+        ]>;
+        function getEffectiveAuditorConfig(client: Aptos, request: {
+            functionArguments: [object$.Object<fungible_asset.Metadata>];
+        }, version?: bigint): Promise<[confidential_asset.EffectiveAuditorConfig]>;
+        function getEffectiveAuditorHint(client: Aptos, request: {
+            functionArguments: [
+                MoveAddressType,
+                object$.Object<fungible_asset.Metadata>
+            ];
+        }, version?: bigint): Promise<[option.Option<confidential_asset.EffectiveAuditorHint>]>;
+        function getEncryptionKey(client: Aptos, request: {
+            functionArguments: [
+                MoveAddressType,
+                object$.Object<fungible_asset.Metadata>
+            ];
+        }, version?: bigint): Promise<[ristretto255.CompressedRistretto]>;
+        function getGlobalAuditorConfig(client: Aptos, version?: bigint): Promise<[confidential_asset.AuditorConfig]>;
+        function getMaxMemoBytes(client: Aptos, version?: bigint): Promise<[bigint]>;
+        function getMaxTransfersBeforeRollover(client: Aptos, version?: bigint): Promise<[bigint]>;
+        function getNumTransfersReceived(client: Aptos, request: {
+            functionArguments: [
+                MoveAddressType,
+                object$.Object<fungible_asset.Metadata>
+            ];
+        }, version?: bigint): Promise<[bigint]>;
+        function getPendingBalance(client: Aptos, request: {
+            functionArguments: [
+                MoveAddressType,
+                object$.Object<fungible_asset.Metadata>
+            ];
+        }, version?: bigint): Promise<[
+            confidential_balance.CompressedBalance<confidential_balance.Pending>
+        ]>;
+        function getTotalConfidentialSupply(client: Aptos, request: {
+            functionArguments: [object$.Object<fungible_asset.Metadata>];
+        }, version?: bigint): Promise<[bigint]>;
+        function hasConfidentialStore(client: Aptos, request: {
+            functionArguments: [
+                MoveAddressType,
+                object$.Object<fungible_asset.Metadata>
+            ];
+        }, version?: bigint): Promise<[boolean]>;
+        function incomingTransfersPaused(client: Aptos, request: {
+            functionArguments: [
+                MoveAddressType,
+                object$.Object<fungible_asset.Metadata>
+            ];
+        }, version?: bigint): Promise<[boolean]>;
+        function isAllowListingRequired(client: Aptos, version?: bigint): Promise<[boolean]>;
+        function isConfidentialityEnabledForAssetType(client: Aptos, request: {
+            functionArguments: [object$.Object<fungible_asset.Metadata>];
+        }, version?: bigint): Promise<[boolean]>;
+        function isEmergencyPaused(client: Aptos, version?: bigint): Promise<[boolean]>;
+        function isNormalized(client: Aptos, request: {
+            functionArguments: [
+                MoveAddressType,
+                object$.Object<fungible_asset.Metadata>
+            ];
+        }, version?: bigint): Promise<[boolean]>;
+    }
+    interface DepositPayload extends TypedFunctionPayload<[
+        object$.Object<fungible_asset.Metadata>,
+        bigint
+    ]> {
+        arguments_decoded: [object$.Object<fungible_asset.Metadata>, bigint];
+        type_arguments: [];
+    }
+    interface ConfidentialTransferRawPayload extends TypedFunctionPayload<[
+        object$.Object<fungible_asset.Metadata>,
+        MoveAddressType,
+        string[],
+        string[],
+        string[],
+        string[],
+        string[],
+        string[],
+        string[],
+        string[],
+        string[][],
+        string,
+        string,
+        string[],
+        string[],
+        string
+    ]> {
+        arguments_decoded: [
+            object$.Object<fungible_asset.Metadata>,
+            MoveAddressType,
+            string[],
+            string[],
+            string[],
+            string[],
+            string[],
+            string[],
+            string[],
+            string[],
+            string[][],
+            string,
+            string,
+            string[],
+            string[],
+            string
+        ];
+        type_arguments: [];
+    }
+    interface NormalizeRawPayload extends TypedFunctionPayload<[
+        object$.Object<fungible_asset.Metadata>,
+        string[],
+        string[],
+        string[],
+        string,
+        string[],
+        string[]
+    ]> {
+        arguments_decoded: [
+            object$.Object<fungible_asset.Metadata>,
+            string[],
+            string[],
+            string[],
+            string,
+            string[],
+            string[]
+        ];
+        type_arguments: [];
+    }
+    interface RegisterRawPayload extends TypedFunctionPayload<[
+        object$.Object<fungible_asset.Metadata>,
+        string,
+        string[],
+        string[]
+    ]> {
+        arguments_decoded: [
+            object$.Object<fungible_asset.Metadata>,
+            string,
+            string[],
+            string[]
+        ];
+        type_arguments: [];
+    }
+    interface RolloverPendingBalancePayload extends TypedFunctionPayload<[object$.Object<fungible_asset.Metadata>]> {
+        arguments_decoded: [object$.Object<fungible_asset.Metadata>];
+        type_arguments: [];
+    }
+    interface RolloverPendingBalanceAndPausePayload extends TypedFunctionPayload<[object$.Object<fungible_asset.Metadata>]> {
+        arguments_decoded: [object$.Object<fungible_asset.Metadata>];
+        type_arguments: [];
+    }
+    interface RotateEncryptionKeyRawPayload extends TypedFunctionPayload<[
+        object$.Object<fungible_asset.Metadata>,
+        string,
+        boolean,
+        string[],
+        string[],
+        string[]
+    ]> {
+        arguments_decoded: [
+            object$.Object<fungible_asset.Metadata>,
+            string,
+            boolean,
+            string[],
+            string[],
+            string[]
+        ];
+        type_arguments: [];
+    }
+    interface SetIncomingTransfersPausedPayload extends TypedFunctionPayload<[
+        object$.Object<fungible_asset.Metadata>,
+        boolean
+    ]> {
+        arguments_decoded: [object$.Object<fungible_asset.Metadata>, boolean];
+        type_arguments: [];
+    }
+    interface WithdrawToRawPayload extends TypedFunctionPayload<[
+        object$.Object<fungible_asset.Metadata>,
+        MoveAddressType,
+        bigint,
+        string[],
+        string[],
+        string[],
+        string,
+        string[],
+        string[]
+    ]> {
+        arguments_decoded: [
+            object$.Object<fungible_asset.Metadata>,
+            MoveAddressType,
+            bigint,
+            string[],
+            string[],
+            string[],
+            string,
+            string[],
+            string[]
+        ];
+        type_arguments: [];
+    }
+}
 export declare class account_abstraction extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
@@ -7491,6 +8122,32 @@ export declare namespace account_abstraction {
         type_arguments: [];
     }
 }
+export declare namespace confidential_amount {
+    interface Amount {
+        P: ristretto255.RistrettoPoint[];
+        R_sender: ristretto255.RistrettoPoint[];
+        R_recip: ristretto255.RistrettoPoint[];
+        R_eff_aud: ristretto255.RistrettoPoint[];
+        R_volun_auds: ristretto255.RistrettoPoint[][];
+    }
+    namespace Amount {
+        const TYPE_QNAME = "0x1::confidential_amount::Amount";
+        function type(): TypeDescriptor<Amount>;
+    }
+    interface CompressedAmount {
+        compressed_P: ristretto255.CompressedRistretto[];
+        compressed_R_sender: ristretto255.CompressedRistretto[];
+        compressed_R_recip: ristretto255.CompressedRistretto[];
+        compressed_R_eff_aud: ristretto255.CompressedRistretto[];
+        compressed_R_volun_auds: ristretto255.CompressedRistretto[][];
+    }
+    namespace CompressedAmount {
+        const TYPE_QNAME = "0x1::confidential_amount::CompressedAmount";
+        function type(): TypeDescriptor<CompressedAmount>;
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare class governance_proposal extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
@@ -7638,6 +8295,39 @@ export declare namespace transaction_context {
     namespace entry { }
     namespace view { }
 }
+export declare namespace confidential_balance {
+    interface Available {
+        dummy_field: boolean;
+    }
+    namespace Available {
+        const TYPE_QNAME = "0x1::confidential_balance::Available";
+        function type(): TypeDescriptor<Available>;
+    }
+    interface Balance<T0> {
+    }
+    namespace Balance {
+        const TYPE_QNAME = "0x1::confidential_balance::Balance";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Balance<T0>>;
+    }
+    interface CompressedBalance<T0> {
+    }
+    namespace CompressedBalance {
+        const TYPE_QNAME = "0x1::confidential_balance::CompressedBalance";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<CompressedBalance<T0>>;
+    }
+    interface Pending {
+        dummy_field: boolean;
+    }
+    namespace Pending {
+        const TYPE_QNAME = "0x1::confidential_balance::Pending";
+        function type(): TypeDescriptor<Pending>;
+    }
+    namespace entry { }
+    namespace view {
+        function getNumAvailableChunks(client: Aptos, version?: bigint): Promise<[bigint]>;
+        function getNumPendingChunks(client: Aptos, version?: bigint): Promise<[bigint]>;
+    }
+}
 export declare namespace jwk_consensus_config {
     interface ConfigOff {
         dummy_field: boolean;
@@ -7698,6 +8388,23 @@ export declare namespace ristretto255_elgamal {
     namespace entry { }
     namespace view { }
 }
+export declare namespace sigma_protocol_proof {
+    interface Proof {
+        comm_A: ristretto255.RistrettoPoint[];
+        compressed_comm_A: ristretto255.CompressedRistretto[];
+        resp_sigma: ristretto255.Scalar[];
+    }
+    namespace Proof {
+        const TYPE_QNAME = "0x1::sigma_protocol_proof::Proof";
+        function type(): TypeDescriptor<Proof>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace sigma_protocol_utils {
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace reconfiguration_state {
     interface State {
         variant: copyable_any.Any;
@@ -7955,6 +8662,17 @@ export declare namespace primary_fungible_store {
         type_arguments: [string];
     }
 }
+export declare namespace sigma_protocol_witness {
+    interface Witness {
+        w: ristretto255.Scalar[];
+    }
+    namespace Witness {
+        const TYPE_QNAME = "0x1::sigma_protocol_witness::Witness";
+        function type(): TypeDescriptor<Witness>;
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace transaction_validation {
     interface GasPermission {
         dummy_field: boolean;
@@ -8007,6 +8725,51 @@ export declare namespace permissioned_delegation {
     namespace entry { }
     namespace view { }
 }
+export declare namespace sigma_protocol_transfer {
+    interface Transfer {
+        dummy_field: boolean;
+    }
+    namespace Transfer {
+        const TYPE_QNAME = "0x1::sigma_protocol_transfer::Transfer";
+        function type(): TypeDescriptor<Transfer>;
+    }
+    interface TransferSession {
+        sender: MoveAddressType;
+        recipient: MoveAddressType;
+        asset_type: object$.Object<fungible_asset.Metadata>;
+        num_avail_chunks: bigint;
+        num_transfer_chunks: bigint;
+        has_effective_auditor: boolean;
+        num_volun_auditors: bigint;
+    }
+    namespace TransferSession {
+        const TYPE_QNAME = "0x1::sigma_protocol_transfer::TransferSession";
+        function type(): TypeDescriptor<TransferSession>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace sigma_protocol_withdraw {
+    interface WithdrawSession {
+        sender: MoveAddressType;
+        asset_type: object$.Object<fungible_asset.Metadata>;
+        num_chunks: bigint;
+        has_auditor: boolean;
+    }
+    namespace WithdrawSession {
+        const TYPE_QNAME = "0x1::sigma_protocol_withdraw::WithdrawSession";
+        function type(): TypeDescriptor<WithdrawSession>;
+    }
+    interface Withdrawal {
+        dummy_field: boolean;
+    }
+    namespace Withdrawal {
+        const TYPE_QNAME = "0x1::sigma_protocol_withdraw::Withdrawal";
+        function type(): TypeDescriptor<Withdrawal>;
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace storage_slots_allocator {
     interface Link<T0> {
     }
@@ -8070,6 +8833,19 @@ export declare namespace reconfiguration_with_dkg {
     namespace entry { }
     namespace view { }
 }
+export declare namespace sigma_protocol_statement {
+    interface Statement<T0> {
+        points: ristretto255.RistrettoPoint[];
+        compressed_points: ristretto255.CompressedRistretto[];
+        scalars: ristretto255.Scalar[];
+    }
+    namespace Statement {
+        const TYPE_QNAME = "0x1::sigma_protocol_statement::Statement";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Statement<T0>>;
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace solana_derivable_account {
     interface SIWSAbstractSignature {
     }
@@ -8093,6 +8869,12 @@ export declare namespace validator_consensus_info {
     namespace entry { }
     namespace view { }
 }
+export declare namespace confidential_range_proofs {
+    namespace entry { }
+    namespace view {
+        function getBulletproofsDst(client: Aptos, version?: bigint): Promise<[string]>;
+    }
+}
 export declare namespace ristretto255_bulletproofs {
     interface RangeProof {
         bytes: string;
@@ -8122,6 +8904,28 @@ export declare namespace ethereum_derivable_account {
     namespace entry { }
     namespace view { }
 }
+export declare namespace sigma_protocol_fiat_shamir {
+    interface DomainSeparator {
+    }
+    namespace DomainSeparator {
+        const TYPE_QNAME = "0x1::sigma_protocol_fiat_shamir::DomainSeparator";
+        function type(): TypeDescriptor<DomainSeparator>;
+    }
+    interface FiatShamirInputs {
+        dst: sigma_protocol_fiat_shamir.DomainSeparator;
+        type_name: string;
+        k: bigint;
+        stmt_X: ristretto255.CompressedRistretto[];
+        stmt_x: ristretto255.Scalar[];
+        proof_A: ristretto255.CompressedRistretto[];
+    }
+    namespace FiatShamirInputs {
+        const TYPE_QNAME = "0x1::sigma_protocol_fiat_shamir::FiatShamirInputs";
+        function type(): TypeDescriptor<FiatShamirInputs>;
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare class dispatchable_fungible_asset extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
@@ -8184,9 +8988,102 @@ export declare namespace dispatchable_fungible_asset {
         type_arguments: [string];
     }
 }
+export declare namespace sigma_protocol_homomorphism {
+    interface Homomorphism<T0> {
+        _0: unknown;
+    }
+    namespace Homomorphism {
+        const TYPE_QNAME = "0x1::sigma_protocol_homomorphism::Homomorphism";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Homomorphism<T0>>;
+    }
+    interface TransformationFunction<T0> {
+        _0: unknown;
+    }
+    namespace TransformationFunction {
+        const TYPE_QNAME = "0x1::sigma_protocol_homomorphism::TransformationFunction";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<TransformationFunction<T0>>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace sigma_protocol_key_rotation {
+    interface KeyRotation {
+        dummy_field: boolean;
+    }
+    namespace KeyRotation {
+        const TYPE_QNAME = "0x1::sigma_protocol_key_rotation::KeyRotation";
+        function type(): TypeDescriptor<KeyRotation>;
+    }
+    interface KeyRotationSession {
+        sender: MoveAddressType;
+        token_type: object$.Object<fungible_asset.Metadata>;
+        num_chunks: bigint;
+    }
+    namespace KeyRotationSession {
+        const TYPE_QNAME = "0x1::sigma_protocol_key_rotation::KeyRotationSession";
+        function type(): TypeDescriptor<KeyRotationSession>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace sigma_protocol_registration {
+    interface Registration {
+        dummy_field: boolean;
+    }
+    namespace Registration {
+        const TYPE_QNAME = "0x1::sigma_protocol_registration::Registration";
+        function type(): TypeDescriptor<Registration>;
+    }
+    interface RegistrationSession {
+        sender: MoveAddressType;
+        asset_type: object$.Object<fungible_asset.Metadata>;
+    }
+    namespace RegistrationSession {
+        const TYPE_QNAME = "0x1::sigma_protocol_registration::RegistrationSession";
+        function type(): TypeDescriptor<RegistrationSession>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace sigma_protocol_representation {
+    interface Representation {
+        point_idxs: bigint[];
+        scalars: ristretto255.Scalar[];
+    }
+    namespace Representation {
+        const TYPE_QNAME = "0x1::sigma_protocol_representation::Representation";
+        function type(): TypeDescriptor<Representation>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace sigma_protocol_statement_builder {
+    interface StatementBuilder<T0> {
+        points: ristretto255.RistrettoPoint[];
+        compressed_points: ristretto255.CompressedRistretto[];
+        scalars: ristretto255.Scalar[];
+    }
+    namespace StatementBuilder {
+        const TYPE_QNAME = "0x1::sigma_protocol_statement_builder::StatementBuilder";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<StatementBuilder<T0>>;
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace common_account_abstractions_utils {
     namespace entry { }
     namespace view { }
 }
+export declare namespace sigma_protocol_representation_vec {
+    interface RepresentationVec {
+        v: sigma_protocol_representation.Representation[];
+    }
+    namespace RepresentationVec {
+        const TYPE_QNAME = "0x1::sigma_protocol_representation_vec::RepresentationVec";
+        function type(): TypeDescriptor<RepresentationVec>;
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare function loadAllTypes(coder: MoveCoder): void;
 //# sourceMappingURL=0x1.d.ts.map