@typemove/aptos 1.2.7-rc.1 → 1.2.7

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

@@ -238,6 +238,10 @@ export declare namespace coin {
         function isCoinInitialized<T0 = any>(client: AptosClient, request: {
             type_arguments: [string];
         }, version?: bigint): Promise<[Boolean]>;
+        function isCoinStoreFrozen<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
         function name<T0 = any>(client: AptosClient, request: {
             type_arguments: [string];
         }, version?: bigint): Promise<[string]>;
@@ -804,6 +808,13 @@ export declare namespace object_ {
         const TYPE_QNAME = "0x1::object::ObjectGroup";
         function type(): TypeDescriptor<ObjectGroup>;
     }
+    interface TombStone {
+        original_owner: Address;
+    }
+    namespace TombStone {
+        const TYPE_QNAME = "0x1::object::TombStone";
+        function type(): TypeDescriptor<TombStone>;
+    }
     interface TransferEvent {
         object: Address;
         from: Address;
@@ -829,6 +840,10 @@ export declare namespace object_ {
         type_arguments: [];
     }
     namespace entry {
+        function burn<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
         function transfer<T0 = any>(client: AptosClient, account: AptosAccount, request: {
             type_arguments: [string];
             arguments: [object_.Object<T0>, Address];
@@ -841,8 +856,17 @@ export declare namespace object_ {
             type_arguments: [string, string];
             arguments: [object_.Object<T0>, object_.Object<T1>];
         }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function unburn<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
+    namespace view {
+        function isBurnt<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>];
+        }, version?: bigint): Promise<[Boolean]>;
     }
-    namespace view { }
 }
 export declare namespace option {
     interface Option<T0> {
@@ -1184,12 +1208,18 @@ export declare namespace account {
         function getGuidNextCreationNum(client: AptosClient, request: {
             arguments: [Address];
         }, version?: bigint): Promise<[bigint]>;
+        function getRotationCapabilityOfferFor(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address]>;
         function getSequenceNumber(client: AptosClient, request: {
             arguments: [Address];
         }, version?: bigint): Promise<[bigint]>;
         function getSignerCapabilityOfferFor(client: AptosClient, request: {
             arguments: [Address];
         }, version?: bigint): Promise<[Address]>;
+        function isRotationCapabilityOffered(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
         function isSignerCapabilityOffered(client: AptosClient, request: {
             arguments: [Address];
         }, version?: bigint): Promise<[Boolean]>;
@@ -1567,6 +1597,10 @@ export declare namespace vesting {
             type_arguments: [];
             arguments: [Address[]];
         }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function updateCommissionPercentage(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
         function updateOperator(client: AptosClient, account: AptosAccount, request: {
             type_arguments: [];
             arguments: [Address, Address, bigint];
@@ -2242,6 +2276,21 @@ export declare namespace string_utils {
     namespace entry { }
     namespace view { }
 }
+export declare namespace aggregator_v2 {
+    interface AggregatorSnapshot<T0> {
+        value: T0;
+    }
+    namespace AggregatorSnapshot {
+        const TYPE_QNAME = "0x1::aggregator_v2::AggregatorSnapshot";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<AggregatorSnapshot<T0>>;
+    }
+    interface AggregatorSnapshotInstance extends TypedEventInstance<AggregatorSnapshot<any>> {
+        data_decoded: AggregatorSnapshot<any>;
+        type_arguments: [string];
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace aptos_account {
     interface DirectCoinTransferConfigUpdatedEvent {
         new_allow_direct_transfers: Boolean;
@@ -2643,6 +2692,46 @@ 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 DelegatedVotesInstance extends TypedEventInstance<DelegatedVotes> {
+        data_decoded: DelegatedVotes;
+        type_arguments: [];
+    }
     interface DelegationPool {
         active_shares: pool_u64_unbound.Pool;
         observed_lockup_cycle: delegation_pool.ObservedLockupCycle;
@@ -2682,6 +2771,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;
     }
@@ -2719,6 +2821,46 @@ 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 VoteDelegationInstance extends TypedEventInstance<VoteDelegation> {
+        data_decoded: VoteDelegation;
+        type_arguments: [];
+    }
+    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 VotingRecordKeyInstance extends TypedEventInstance<VotingRecordKey> {
+        data_decoded: VotingRecordKey;
+        type_arguments: [];
+    }
     interface WithdrawStakeEvent {
         pool_address: Address;
         delegator_address: Address;
@@ -2737,6 +2879,18 @@ export declare namespace delegation_pool {
             type_arguments: [];
             arguments: [Address, bigint];
         }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createProposal(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, string, string, string, Boolean];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function delegateVotingPower(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function enablePartialGovernanceVoting(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
         function initializeDelegationPool(client: AptosClient, account: AptosAccount, request: {
             type_arguments: [];
             arguments: [bigint, string];
@@ -2761,12 +2915,25 @@ export declare namespace delegation_pool {
             type_arguments: [];
             arguments: [Address, bigint];
         }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function vote(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint, bigint, Boolean];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
         function withdraw(client: AptosClient, account: AptosAccount, request: {
             type_arguments: [];
             arguments: [Address, bigint];
         }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
     }
     namespace view {
+        function calculateAndUpdateDelegatorVoter(client: AptosClient, request: {
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[Address]>;
+        function calculateAndUpdateRemainingVotingPower(client: AptosClient, request: {
+            arguments: [Address, Address, bigint];
+        }, version?: bigint): Promise<[bigint]>;
+        function calculateAndUpdateVoterTotalVotingPower(client: AptosClient, request: {
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[bigint]>;
         function canWithdrawPendingInactive(client: AptosClient, request: {
             arguments: [Address];
         }, version?: bigint): Promise<[Boolean]>;
@@ -2779,6 +2946,9 @@ export declare namespace delegation_pool {
         function getDelegationPoolStake(client: AptosClient, request: {
             arguments: [Address];
         }, version?: bigint): Promise<[bigint, bigint, bigint, bigint]>;
+        function getExpectedStakePoolAddress(client: AptosClient, request: {
+            arguments: [Address, string];
+        }, version?: bigint): Promise<[Address]>;
         function getOwnedPoolAddress(client: AptosClient, request: {
             arguments: [Address];
         }, version?: bigint): Promise<[Address]>;
@@ -2797,6 +2967,9 @@ export declare namespace delegation_pool {
         function ownerCapExists(client: AptosClient, request: {
             arguments: [Address];
         }, version?: bigint): Promise<[Boolean]>;
+        function partialGovernanceVotingEnabled(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
         function shareholdersCountActivePool(client: AptosClient, request: {
             arguments: [Address];
         }, version?: bigint): Promise<[bigint]>;
@@ -2841,6 +3014,13 @@ export declare namespace transaction_fee {
         const TYPE_QNAME = "0x1::transaction_fee::AptosCoinCapabilities";
         function type(): TypeDescriptor<AptosCoinCapabilities>;
     }
+    interface AptosCoinMintCapability {
+        mint_cap: coin.MintCapability<aptos_coin.AptosCoin>;
+    }
+    namespace AptosCoinMintCapability {
+        const TYPE_QNAME = "0x1::transaction_fee::AptosCoinMintCapability";
+        function type(): TypeDescriptor<AptosCoinMintCapability>;
+    }
     interface CollectedFeesPerBlock {
         amount: coin.AggregatableCoin<aptos_coin.AptosCoin>;
         proposer: option.Option<Address>;
@@ -2850,6 +3030,21 @@ export declare namespace transaction_fee {
         const TYPE_QNAME = "0x1::transaction_fee::CollectedFeesPerBlock";
         function type(): TypeDescriptor<CollectedFeesPerBlock>;
     }
+    interface FeeStatement {
+        total_charge_gas_units: bigint;
+        execution_gas_units: bigint;
+        io_gas_units: bigint;
+        storage_fee_octas: bigint;
+        storage_fee_refund_octas: bigint;
+    }
+    namespace FeeStatement {
+        const TYPE_QNAME = "0x1::transaction_fee::FeeStatement";
+        function type(): TypeDescriptor<FeeStatement>;
+    }
+    interface FeeStatementInstance extends TypedEventInstance<FeeStatement> {
+        data_decoded: FeeStatement;
+        type_arguments: [];
+    }
     namespace entry { }
     namespace view { }
 }
@@ -2948,6 +3143,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>;
+    }
     namespace entry {
         function addApprovedScriptHashScript(client: AptosClient, account: AptosAccount, request: {
             type_arguments: [];
@@ -2961,6 +3163,10 @@ export declare namespace aptos_governance {
             type_arguments: [];
             arguments: [Address, string, string, string, Boolean];
         }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function partialVote(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint, bigint, Boolean];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
         function vote(client: AptosClient, account: AptosAccount, request: {
             type_arguments: [];
             arguments: [Address, bigint, Boolean];
@@ -2968,8 +3174,17 @@ export declare namespace aptos_governance {
     }
     namespace view {
         function getMinVotingThreshold(client: AptosClient, version?: bigint): Promise<[bigint]>;
+        function getRemainingVotingPower(client: AptosClient, request: {
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[bigint]>;
         function getRequiredProposerStake(client: AptosClient, version?: bigint): Promise<[bigint]>;
         function getVotingDurationSecs(client: AptosClient, version?: bigint): Promise<[bigint]>;
+        function getVotingPower(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function hasEntirelyVoted(client: AptosClient, request: {
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[Boolean]>;
     }
 }
 export declare namespace bls12381_algebra {
@@ -3199,6 +3414,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>;
@@ -3288,6 +3514,10 @@ export declare namespace multisig_account {
             type_arguments: [];
             arguments: [Address[]];
         }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function addOwnersAndUpdateSignaturesRequired(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address[], bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
         function approveTransaction(client: AptosClient, account: AptosAccount, request: {
             type_arguments: [];
             arguments: [Address, bigint];
@@ -3317,10 +3547,27 @@ export declare namespace multisig_account {
                 string[]
             ];
         }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createWithExistingAccountAndRevokeAuthKey(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [
+                Address,
+                Address[],
+                bigint,
+                number,
+                string,
+                string,
+                string[],
+                string[]
+            ];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
         function createWithOwners(client: AptosClient, account: AptosAccount, request: {
             type_arguments: [];
             arguments: [Address[], bigint, string[], string[]];
         }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createWithOwnersThenRemoveBootstrapper(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address[], bigint, string[], string[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
         function executeRejectedTransaction(client: AptosClient, account: AptosAccount, request: {
             type_arguments: [];
             arguments: [Address];
@@ -3337,6 +3584,18 @@ export declare namespace multisig_account {
             type_arguments: [];
             arguments: [Address[]];
         }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function swapOwner(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function swapOwners(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address[], Address[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function swapOwnersAndUpdateSignaturesRequired(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address[], Address[], bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
         function updateMetadata(client: AptosClient, account: AptosAccount, request: {
             type_arguments: [];
             arguments: [string[], string[]];
@@ -3656,6 +3915,9 @@ export declare namespace staking_contract {
         function commissionPercentage(client: AptosClient, request: {
             arguments: [Address, Address];
         }, version?: bigint): Promise<[bigint]>;
+        function getExpectedStakePoolAddress(client: AptosClient, request: {
+            arguments: [Address, Address, string];
+        }, version?: bigint): Promise<[Address]>;
         function lastRecordedPrincipal(client: AptosClient, request: {
             arguments: [Address, Address];
         }, version?: bigint): Promise<[bigint]>;
@@ -3736,6 +3998,63 @@ export declare namespace optional_aggregator {
     namespace view { }
 }
 export declare namespace transaction_context {
+    interface AUID {
+        unique_address: Address;
+    }
+    namespace AUID {
+        const TYPE_QNAME = "0x1::transaction_context::AUID";
+        function type(): TypeDescriptor<AUID>;
+    }
+    interface AUIDInstance extends TypedEventInstance<AUID> {
+        data_decoded: AUID;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace ristretto255_elgamal {
+    interface Ciphertext {
+        left: ristretto255.RistrettoPoint;
+        right: ristretto255.RistrettoPoint;
+    }
+    namespace Ciphertext {
+        const TYPE_QNAME = "0x1::ristretto255_elgamal::Ciphertext";
+        function type(): TypeDescriptor<Ciphertext>;
+    }
+    interface CompressedCiphertext {
+        left: ristretto255.CompressedRistretto;
+        right: ristretto255.CompressedRistretto;
+    }
+    namespace CompressedCiphertext {
+        const TYPE_QNAME = "0x1::ristretto255_elgamal::CompressedCiphertext";
+        function type(): TypeDescriptor<CompressedCiphertext>;
+    }
+    interface CompressedCiphertextInstance extends TypedEventInstance<CompressedCiphertext> {
+        data_decoded: CompressedCiphertext;
+        type_arguments: [];
+    }
+    interface CompressedPubkey {
+        point: ristretto255.CompressedRistretto;
+    }
+    namespace CompressedPubkey {
+        const TYPE_QNAME = "0x1::ristretto255_elgamal::CompressedPubkey";
+        function type(): TypeDescriptor<CompressedPubkey>;
+    }
+    interface CompressedPubkeyInstance extends TypedEventInstance<CompressedPubkey> {
+        data_decoded: CompressedPubkey;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace ristretto255_pedersen {
+    interface Commitment {
+        point: ristretto255.RistrettoPoint;
+    }
+    namespace Commitment {
+        const TYPE_QNAME = "0x1::ristretto255_pedersen::Commitment";
+        function type(): TypeDescriptor<Commitment>;
+    }
     namespace entry { }
     namespace view { }
 }
@@ -3792,5 +4111,20 @@ export declare namespace transaction_validation {
     namespace entry { }
     namespace view { }
 }
+export declare namespace ristretto255_bulletproofs {
+    interface RangeProof {
+        bytes: string;
+    }
+    namespace RangeProof {
+        const TYPE_QNAME = "0x1::ristretto255_bulletproofs::RangeProof";
+        function type(): TypeDescriptor<RangeProof>;
+    }
+    interface RangeProofInstance extends TypedEventInstance<RangeProof> {
+        data_decoded: RangeProof;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare function loadAllTypes(coder: MoveCoder): void;
 //# sourceMappingURL=0x1.d.ts.map