@typemove/aptos 1.13.4-rc.2 → 1.13.5-rc.1

package/dist/esm/builtin/0x1.d.ts

@@ -1160,6 +1160,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;
@@ -2890,6 +2903,49 @@ export declare namespace capability {
     namespace entry { }
     namespace view { }
 }
+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;
@@ -2901,6 +2957,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 { }
@@ -3918,6 +3995,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];
@@ -3947,6 +4027,10 @@ export declare namespace fungible_asset {
         }, version?: bigint): Promise<[option.Option<bigint>]>;
     }
 }
+export declare namespace sigma_protocol {
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace staking_config {
     interface StakingConfig {
         minimum_stake: bigint;
@@ -6016,6 +6100,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]>;
@@ -6037,6 +6124,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;
@@ -6107,6 +6220,354 @@ export declare namespace aggregator_factory {
     namespace entry { }
     namespace view { }
 }
+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]>;
+    }
+}
 export declare namespace account_abstraction {
     interface DerivableDispatchableAuthenticator {
     }
@@ -6196,6 +6657,32 @@ export declare namespace account_abstraction {
         }, version?: bigint): Promise<[boolean]>;
     }
 }
+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 namespace governance_proposal {
     interface GovernanceProposal {
         dummy_field: boolean;
@@ -6316,6 +6803,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;
@@ -6376,6 +6896,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;
@@ -6582,6 +7119,17 @@ export declare namespace primary_fungible_store {
         }, version?: bigint): Promise<[boolean]>;
     }
 }
+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;
@@ -6634,6 +7182,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> {
     }
@@ -6697,6 +7290,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 {
     }
@@ -6720,6 +7326,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;
@@ -6749,6 +7361,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 namespace dispatchable_fungible_asset {
     interface TransferRefStore {
         transfer_ref: fungible_asset.TransferRef;
@@ -6787,9 +7421,102 @@ export declare namespace dispatchable_fungible_asset {
         }, version?: bigint): Promise<[boolean]>;
     }
 }
+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