@typemove/aptos 1.2.9 → 1.3.0-rc.2

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

@@ -1,10 +1,9 @@
 import { TypeDescriptor } from "@typemove/move";
 import { MoveCoder, TypedEventInstance } from "@typemove/aptos";
-import { Address } from "@typemove/aptos";
-import { AptosClient, AptosAccount, Types, OptionalTransactionArgs } from "aptos";
+import { Aptos, Account as AptosAccount, MoveAddressType, PendingTransactionResponse, InputGenerateTransactionOptions, MoveStructId } from "@aptos-labs/ts-sdk";
 export declare namespace acl {
     interface ACL {
-        list: Address[];
+        list: MoveAddressType[];
     }
     namespace ACL {
         const TYPE_QNAME = "0x1::acl::ACL";
@@ -39,7 +38,7 @@ export declare namespace bcs {
 }
 export declare namespace code {
     interface AllowedDep {
-        account: Address;
+        account: MoveAddressType;
         module_name: string;
     }
     namespace AllowedDep {
@@ -61,7 +60,7 @@ export declare namespace code {
         type_arguments: [];
     }
     interface PackageDep {
-        account: Address;
+        account: MoveAddressType;
         package_name: string;
     }
     namespace PackageDep {
@@ -113,10 +112,10 @@ export declare namespace code {
         type_arguments: [];
     }
     namespace entry {
-        function publishPackageTxn(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [string, string[]];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function publishPackageTxn(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string, string[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view { }
 }
@@ -206,50 +205,50 @@ export declare namespace coin {
         type_arguments: [];
     }
     namespace entry {
-        function freezeCoinStore<T0 = any>(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [string];
-            arguments: [Address, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function transfer<T0 = any>(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [string];
-            arguments: [Address, bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function unfreezeCoinStore<T0 = any>(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [string];
-            arguments: [Address, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function upgradeSupply<T0 = any>(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [string];
-            arguments: [];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function freezeCoinStore<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function transfer<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function unfreezeCoinStore<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function upgradeSupply<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
-        function balance<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [Address];
+        function balance<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function decimals<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
+        function decimals<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
         }, version?: bigint): Promise<[number]>;
-        function isAccountRegistered<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [Address];
+        function isAccountRegistered<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[Boolean]>;
-        function isCoinInitialized<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
+        function isCoinInitialized<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
         }, version?: bigint): Promise<[Boolean]>;
-        function isCoinStoreFrozen<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [Address];
+        function isCoinStoreFrozen<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[Boolean]>;
-        function name<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
+        function name<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
         }, version?: bigint): Promise<[string]>;
-        function supply<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
+        function supply<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
         }, version?: bigint): Promise<[option.Option<bigint>]>;
-        function symbol<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
+        function symbol<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
         }, version?: bigint): Promise<[string]>;
     }
 }
@@ -267,7 +266,7 @@ export declare namespace guid {
     }
     interface ID {
         creation_num: bigint;
-        addr: Address;
+        addr: MoveAddressType;
     }
     namespace ID {
         const TYPE_QNAME = "0x1::guid::ID";
@@ -300,12 +299,12 @@ export declare namespace block {
         function type(): TypeDescriptor<BlockResource>;
     }
     interface NewBlockEvent {
-        hash: Address;
+        hash: MoveAddressType;
         epoch: bigint;
         round: bigint;
         height: bigint;
         previous_block_votes_bitvec: string;
-        proposer: Address;
+        proposer: MoveAddressType;
         failed_proposer_indices: bigint[];
         time_microseconds: bigint;
     }
@@ -331,8 +330,8 @@ export declare namespace block {
     }
     namespace entry { }
     namespace view {
-        function getCurrentBlockHeight(client: AptosClient, version?: bigint): Promise<[bigint]>;
-        function getEpochIntervalSecs(client: AptosClient, version?: bigint): Promise<[bigint]>;
+        function getCurrentBlockHeight(client: Aptos, version?: bigint): Promise<[bigint]>;
+        function getEpochIntervalSecs(client: Aptos, version?: bigint): Promise<[bigint]>;
     }
 }
 export declare namespace debug {
@@ -357,7 +356,7 @@ export declare namespace event {
 }
 export declare namespace stake {
     interface AddStakeEvent {
-        pool_address: Address;
+        pool_address: MoveAddressType;
         amount_added: bigint;
     }
     namespace AddStakeEvent {
@@ -369,7 +368,7 @@ export declare namespace stake {
         type_arguments: [];
     }
     interface AllowedValidators {
-        accounts: Address[];
+        accounts: MoveAddressType[];
     }
     namespace AllowedValidators {
         const TYPE_QNAME = "0x1::stake::AllowedValidators";
@@ -383,7 +382,7 @@ export declare namespace stake {
         function type(): TypeDescriptor<AptosCoinCapabilities>;
     }
     interface DistributeRewardsEvent {
-        pool_address: Address;
+        pool_address: MoveAddressType;
         rewards_amount: bigint;
     }
     namespace DistributeRewardsEvent {
@@ -395,7 +394,7 @@ export declare namespace stake {
         type_arguments: [];
     }
     interface IncreaseLockupEvent {
-        pool_address: Address;
+        pool_address: MoveAddressType;
         old_locked_until_secs: bigint;
         new_locked_until_secs: bigint;
     }
@@ -420,7 +419,7 @@ export declare namespace stake {
         type_arguments: [];
     }
     interface JoinValidatorSetEvent {
-        pool_address: Address;
+        pool_address: MoveAddressType;
     }
     namespace JoinValidatorSetEvent {
         const TYPE_QNAME = "0x1::stake::JoinValidatorSetEvent";
@@ -431,7 +430,7 @@ export declare namespace stake {
         type_arguments: [];
     }
     interface LeaveValidatorSetEvent {
-        pool_address: Address;
+        pool_address: MoveAddressType;
     }
     namespace LeaveValidatorSetEvent {
         const TYPE_QNAME = "0x1::stake::LeaveValidatorSetEvent";
@@ -442,14 +441,14 @@ export declare namespace stake {
         type_arguments: [];
     }
     interface OwnerCapability {
-        pool_address: Address;
+        pool_address: MoveAddressType;
     }
     namespace OwnerCapability {
         const TYPE_QNAME = "0x1::stake::OwnerCapability";
         function type(): TypeDescriptor<OwnerCapability>;
     }
     interface ReactivateStakeEvent {
-        pool_address: Address;
+        pool_address: MoveAddressType;
         amount: bigint;
     }
     namespace ReactivateStakeEvent {
@@ -461,7 +460,7 @@ export declare namespace stake {
         type_arguments: [];
     }
     interface RegisterValidatorCandidateEvent {
-        pool_address: Address;
+        pool_address: MoveAddressType;
     }
     namespace RegisterValidatorCandidateEvent {
         const TYPE_QNAME = "0x1::stake::RegisterValidatorCandidateEvent";
@@ -472,7 +471,7 @@ export declare namespace stake {
         type_arguments: [];
     }
     interface RotateConsensusKeyEvent {
-        pool_address: Address;
+        pool_address: MoveAddressType;
         old_consensus_pubkey: string;
         new_consensus_pubkey: string;
     }
@@ -485,9 +484,9 @@ export declare namespace stake {
         type_arguments: [];
     }
     interface SetOperatorEvent {
-        pool_address: Address;
-        old_operator: Address;
-        new_operator: Address;
+        pool_address: MoveAddressType;
+        old_operator: MoveAddressType;
+        new_operator: MoveAddressType;
     }
     namespace SetOperatorEvent {
         const TYPE_QNAME = "0x1::stake::SetOperatorEvent";
@@ -503,8 +502,8 @@ export declare namespace stake {
         pending_active: coin.Coin<aptos_coin.AptosCoin>;
         pending_inactive: coin.Coin<aptos_coin.AptosCoin>;
         locked_until_secs: bigint;
-        operator_address: Address;
-        delegated_voter: Address;
+        operator_address: MoveAddressType;
+        delegated_voter: MoveAddressType;
         initialize_validator_events: event.EventHandle<stake.RegisterValidatorCandidateEvent>;
         set_operator_events: event.EventHandle<stake.SetOperatorEvent>;
         add_stake_events: event.EventHandle<stake.AddStakeEvent>;
@@ -523,7 +522,7 @@ export declare namespace stake {
         function type(): TypeDescriptor<StakePool>;
     }
     interface UnlockStakeEvent {
-        pool_address: Address;
+        pool_address: MoveAddressType;
         amount_unlocked: bigint;
     }
     namespace UnlockStakeEvent {
@@ -535,7 +534,7 @@ export declare namespace stake {
         type_arguments: [];
     }
     interface UpdateNetworkAndFullnodeAddressesEvent {
-        pool_address: Address;
+        pool_address: MoveAddressType;
         old_network_addresses: string;
         new_network_addresses: string;
         old_fullnode_addresses: string;
@@ -564,14 +563,14 @@ export declare namespace stake {
         type_arguments: [];
     }
     interface ValidatorFees {
-        fees_table: table.Table<Address, coin.Coin<aptos_coin.AptosCoin>>;
+        fees_table: table.Table<MoveAddressType, coin.Coin<aptos_coin.AptosCoin>>;
     }
     namespace ValidatorFees {
         const TYPE_QNAME = "0x1::stake::ValidatorFees";
         function type(): TypeDescriptor<ValidatorFees>;
     }
     interface ValidatorInfo {
-        addr: Address;
+        addr: MoveAddressType;
         voting_power: bigint;
         config: stake.ValidatorConfig;
     }
@@ -603,7 +602,7 @@ export declare namespace stake {
         function type(): TypeDescriptor<ValidatorSet>;
     }
     interface WithdrawStakeEvent {
-        pool_address: Address;
+        pool_address: MoveAddressType;
         amount_withdrawn: bigint;
     }
     namespace WithdrawStakeEvent {
@@ -615,92 +614,92 @@ export declare namespace stake {
         type_arguments: [];
     }
     namespace entry {
-        function addStake(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function increaseLockup(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function initializeStakeOwner(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [bigint, Address, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function initializeValidator(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [string, string, string, string];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function joinValidatorSet(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function leaveValidatorSet(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function reactivateStake(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function rotateConsensusKey(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, string, string];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function setDelegatedVoter(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function setOperator(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function unlock(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function updateNetworkAndFullnodeAddresses(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, string, string];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function withdraw(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function addStake(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function increaseLockup(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function initializeStakeOwner(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint, MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function initializeValidator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string, string, string, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function joinValidatorSet(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function leaveValidatorSet(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function reactivateStake(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function rotateConsensusKey(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setDelegatedVoter(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function unlock(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateNetworkAndFullnodeAddresses(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function withdraw(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
-        function getCurrentEpochProposalCounts(client: AptosClient, request: {
-            arguments: [bigint];
+        function getCurrentEpochProposalCounts(client: Aptos, request: {
+            functionArguments: [bigint];
         }, version?: bigint): Promise<[bigint, bigint]>;
-        function getCurrentEpochVotingPower(client: AptosClient, request: {
-            arguments: [Address];
+        function getCurrentEpochVotingPower(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function getDelegatedVoter(client: AptosClient, request: {
-            arguments: [Address];
-        }, version?: bigint): Promise<[Address]>;
-        function getLockupSecs(client: AptosClient, request: {
-            arguments: [Address];
+        function getDelegatedVoter(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function getLockupSecs(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function getOperator(client: AptosClient, request: {
-            arguments: [Address];
-        }, version?: bigint): Promise<[Address]>;
-        function getRemainingLockupSecs(client: AptosClient, request: {
-            arguments: [Address];
+        function getOperator(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function getRemainingLockupSecs(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function getStake(client: AptosClient, request: {
-            arguments: [Address];
+        function getStake(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint, bigint, bigint, bigint]>;
-        function getValidatorConfig(client: AptosClient, request: {
-            arguments: [Address];
+        function getValidatorConfig(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[string, string, string]>;
-        function getValidatorIndex(client: AptosClient, request: {
-            arguments: [Address];
+        function getValidatorIndex(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function getValidatorState(client: AptosClient, request: {
-            arguments: [Address];
+        function getValidatorState(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function stakePoolExists(client: AptosClient, request: {
-            arguments: [Address];
+        function stakePoolExists(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[Boolean]>;
     }
 }
@@ -717,7 +716,7 @@ export declare namespace table {
         type_arguments: [string];
     }
     interface Table<T0, T1> {
-        handle: Address;
+        handle: MoveAddressType;
     }
     namespace Table {
         const TYPE_QNAME = "0x1::table::Table";
@@ -732,7 +731,7 @@ export declare namespace math64 {
 }
 export declare namespace object_ {
     interface ConstructorRef {
-        self: Address;
+        self: MoveAddressType;
         can_delete: Boolean;
     }
     namespace ConstructorRef {
@@ -740,7 +739,7 @@ export declare namespace object_ {
         function type(): TypeDescriptor<ConstructorRef>;
     }
     interface DeleteRef {
-        self: Address;
+        self: MoveAddressType;
     }
     namespace DeleteRef {
         const TYPE_QNAME = "0x1::object::DeleteRef";
@@ -751,7 +750,7 @@ export declare namespace object_ {
         type_arguments: [];
     }
     interface DeriveRef {
-        self: Address;
+        self: MoveAddressType;
     }
     namespace DeriveRef {
         const TYPE_QNAME = "0x1::object::DeriveRef";
@@ -762,7 +761,7 @@ export declare namespace object_ {
         type_arguments: [];
     }
     interface ExtendRef {
-        self: Address;
+        self: MoveAddressType;
     }
     namespace ExtendRef {
         const TYPE_QNAME = "0x1::object::ExtendRef";
@@ -773,15 +772,15 @@ export declare namespace object_ {
         type_arguments: [];
     }
     interface LinearTransferRef {
-        self: Address;
-        owner: Address;
+        self: MoveAddressType;
+        owner: MoveAddressType;
     }
     namespace LinearTransferRef {
         const TYPE_QNAME = "0x1::object::LinearTransferRef";
         function type(): TypeDescriptor<LinearTransferRef>;
     }
     interface Object<T0> {
-        inner: Address;
+        inner: MoveAddressType;
     }
     namespace Object {
         const TYPE_QNAME = "0x1::object::Object";
@@ -793,7 +792,7 @@ export declare namespace object_ {
     }
     interface ObjectCore {
         guid_creation_num: bigint;
-        owner: Address;
+        owner: MoveAddressType;
         allow_ungated_transfer: Boolean;
         transfer_events: event.EventHandle<object_.TransferEvent>;
     }
@@ -809,16 +808,16 @@ export declare namespace object_ {
         function type(): TypeDescriptor<ObjectGroup>;
     }
     interface TombStone {
-        original_owner: Address;
+        original_owner: MoveAddressType;
     }
     namespace TombStone {
         const TYPE_QNAME = "0x1::object::TombStone";
         function type(): TypeDescriptor<TombStone>;
     }
     interface TransferEvent {
-        object: Address;
-        from: Address;
-        to: Address;
+        object: MoveAddressType;
+        from: MoveAddressType;
+        to: MoveAddressType;
     }
     namespace TransferEvent {
         const TYPE_QNAME = "0x1::object::TransferEvent";
@@ -829,7 +828,7 @@ export declare namespace object_ {
         type_arguments: [];
     }
     interface TransferRef {
-        self: Address;
+        self: MoveAddressType;
     }
     namespace TransferRef {
         const TYPE_QNAME = "0x1::object::TransferRef";
@@ -840,31 +839,31 @@ 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];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function transferCall(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function transferToObject<T0 = any, T1 = any>(client: AptosClient, account: AptosAccount, request: {
-            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>;
+        function burn<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object_.Object<T0>];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function transfer<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object_.Object<T0>, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function transferCall(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function transferToObject<T0 = any, T1 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId, MoveStructId];
+            functionArguments: [object_.Object<T0>, object_.Object<T1>];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function unburn<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object_.Object<T0>];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
-        function isBurnt<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [object_.Object<T0>];
+        function isBurnt<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object_.Object<T0>];
         }, version?: bigint): Promise<[Boolean]>;
     }
 }
@@ -924,7 +923,7 @@ export declare namespace voting {
         type_arguments: [];
     }
     interface Proposal<T0> {
-        proposer: Address;
+        proposer: MoveAddressType;
         execution_content: option.Option<T0>;
         metadata: simple_map.SimpleMap<string, string>;
         creation_time_secs: bigint;
@@ -942,7 +941,7 @@ export declare namespace voting {
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Proposal<T0>>;
     }
     interface RegisterForumEvent {
-        hosting_account: Address;
+        hosting_account: MoveAddressType;
         proposal_type_info: type_info.TypeInfo;
     }
     namespace RegisterForumEvent {
@@ -1000,49 +999,49 @@ export declare namespace voting {
     }
     namespace entry { }
     namespace view {
-        function getEarlyResolutionVoteThreshold<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [Address, bigint];
+        function getEarlyResolutionVoteThreshold<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[option.Option<bigint>]>;
-        function getExecutionHash<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [Address, bigint];
+        function getExecutionHash<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[string]>;
-        function getMinVoteThreshold<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [Address, bigint];
+        function getMinVoteThreshold<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[bigint]>;
-        function getProposalCreationSecs<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [Address, bigint];
+        function getProposalCreationSecs<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[bigint]>;
-        function getProposalExpirationSecs<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [Address, bigint];
+        function getProposalExpirationSecs<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[bigint]>;
-        function getProposalState<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [Address, bigint];
+        function getProposalState<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[bigint]>;
-        function getVotes<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [Address, bigint];
+        function getVotes<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[bigint, bigint]>;
-        function isMultiStepProposalInExecution<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [Address, bigint];
+        function isMultiStepProposalInExecution<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[Boolean]>;
-        function isResolved<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [Address, bigint];
+        function isResolved<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[Boolean]>;
-        function isVotingClosed<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [Address, bigint];
+        function isVotingClosed<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[Boolean]>;
-        function nextProposalId<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [Address];
+        function nextProposalId<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
     }
 }
@@ -1061,7 +1060,7 @@ export declare namespace account {
         function type(): TypeDescriptor<Account>;
     }
     interface CapabilityOffer<T0> {
-        for: option.Option<Address>;
+        for: option.Option<MoveAddressType>;
     }
     namespace CapabilityOffer {
         const TYPE_QNAME = "0x1::account::CapabilityOffer";
@@ -1091,14 +1090,14 @@ export declare namespace account {
         type_arguments: [];
     }
     interface OriginatingAddress {
-        address_map: table.Table<Address, Address>;
+        address_map: table.Table<MoveAddressType, MoveAddressType>;
     }
     namespace OriginatingAddress {
         const TYPE_QNAME = "0x1::account::OriginatingAddress";
         function type(): TypeDescriptor<OriginatingAddress>;
     }
     interface RotationCapability {
-        account: Address;
+        account: MoveAddressType;
     }
     namespace RotationCapability {
         const TYPE_QNAME = "0x1::account::RotationCapability";
@@ -1110,7 +1109,7 @@ export declare namespace account {
     }
     interface RotationCapabilityOfferProofChallenge {
         sequence_number: bigint;
-        recipient_address: Address;
+        recipient_address: MoveAddressType;
     }
     namespace RotationCapabilityOfferProofChallenge {
         const TYPE_QNAME = "0x1::account::RotationCapabilityOfferProofChallenge";
@@ -1119,8 +1118,8 @@ export declare namespace account {
     interface RotationCapabilityOfferProofChallengeV2 {
         chain_id: number;
         sequence_number: bigint;
-        source_address: Address;
-        recipient_address: Address;
+        source_address: MoveAddressType;
+        recipient_address: MoveAddressType;
     }
     namespace RotationCapabilityOfferProofChallengeV2 {
         const TYPE_QNAME = "0x1::account::RotationCapabilityOfferProofChallengeV2";
@@ -1128,8 +1127,8 @@ export declare namespace account {
     }
     interface RotationProofChallenge {
         sequence_number: bigint;
-        originator: Address;
-        current_auth_key: Address;
+        originator: MoveAddressType;
+        current_auth_key: MoveAddressType;
         new_public_key: string;
     }
     namespace RotationProofChallenge {
@@ -1137,7 +1136,7 @@ export declare namespace account {
         function type(): TypeDescriptor<RotationProofChallenge>;
     }
     interface SignerCapability {
-        account: Address;
+        account: MoveAddressType;
     }
     namespace SignerCapability {
         const TYPE_QNAME = "0x1::account::SignerCapability";
@@ -1149,7 +1148,7 @@ export declare namespace account {
     }
     interface SignerCapabilityOfferProofChallenge {
         sequence_number: bigint;
-        recipient_address: Address;
+        recipient_address: MoveAddressType;
     }
     namespace SignerCapabilityOfferProofChallenge {
         const TYPE_QNAME = "0x1::account::SignerCapabilityOfferProofChallenge";
@@ -1157,71 +1156,71 @@ export declare namespace account {
     }
     interface SignerCapabilityOfferProofChallengeV2 {
         sequence_number: bigint;
-        source_address: Address;
-        recipient_address: Address;
+        source_address: MoveAddressType;
+        recipient_address: MoveAddressType;
     }
     namespace SignerCapabilityOfferProofChallengeV2 {
         const TYPE_QNAME = "0x1::account::SignerCapabilityOfferProofChallengeV2";
         function type(): TypeDescriptor<SignerCapabilityOfferProofChallengeV2>;
     }
     namespace entry {
-        function offerRotationCapability(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [string, number, string, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function offerSignerCapability(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [string, number, string, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function revokeAnyRotationCapability(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function revokeAnySignerCapability(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function revokeRotationCapability(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function revokeSignerCapability(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function rotateAuthenticationKey(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [number, string, number, string, string, string];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function rotateAuthenticationKeyWithRotationCapability(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, number, string, string];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function offerRotationCapability(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string, number, string, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function offerSignerCapability(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string, number, string, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function revokeAnyRotationCapability(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function revokeAnySignerCapability(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function revokeRotationCapability(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function revokeSignerCapability(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function rotateAuthenticationKey(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [number, string, number, string, string, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function rotateAuthenticationKeyWithRotationCapability(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, number, string, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
-        function existsAt(client: AptosClient, request: {
-            arguments: [Address];
+        function existsAt(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[Boolean]>;
-        function getAuthenticationKey(client: AptosClient, request: {
-            arguments: [Address];
+        function getAuthenticationKey(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[string]>;
-        function getGuidNextCreationNum(client: AptosClient, request: {
-            arguments: [Address];
+        function getGuidNextCreationNum(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function getRotationCapabilityOfferFor(client: AptosClient, request: {
-            arguments: [Address];
-        }, version?: bigint): Promise<[Address]>;
-        function getSequenceNumber(client: AptosClient, request: {
-            arguments: [Address];
+        function getRotationCapabilityOfferFor(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function getSequenceNumber(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function getSignerCapabilityOfferFor(client: AptosClient, request: {
-            arguments: [Address];
-        }, version?: bigint): Promise<[Address]>;
-        function isRotationCapabilityOffered(client: AptosClient, request: {
-            arguments: [Address];
+        function getSignerCapabilityOfferFor(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function isRotationCapabilityOffered(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[Boolean]>;
-        function isSignerCapabilityOffered(client: AptosClient, request: {
-            arguments: [Address];
+        function isSignerCapabilityOffered(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[Boolean]>;
     }
 }
@@ -1272,7 +1271,7 @@ export declare namespace ed25519 {
 }
 export declare namespace genesis {
     interface AccountMap {
-        account_address: Address;
+        account_address: MoveAddressType;
         balance: bigint;
     }
     namespace AccountMap {
@@ -1280,20 +1279,20 @@ export declare namespace genesis {
         function type(): TypeDescriptor<AccountMap>;
     }
     interface EmployeeAccountMap {
-        accounts: Address[];
+        accounts: MoveAddressType[];
         validator: genesis.ValidatorConfigurationWithCommission;
         vesting_schedule_numerator: bigint[];
         vesting_schedule_denominator: bigint;
-        beneficiary_resetter: Address;
+        beneficiary_resetter: MoveAddressType;
     }
     namespace EmployeeAccountMap {
         const TYPE_QNAME = "0x1::genesis::EmployeeAccountMap";
         function type(): TypeDescriptor<EmployeeAccountMap>;
     }
     interface ValidatorConfiguration {
-        owner_address: Address;
-        operator_address: Address;
-        voter_address: Address;
+        owner_address: MoveAddressType;
+        operator_address: MoveAddressType;
+        voter_address: MoveAddressType;
         stake_amount: bigint;
         consensus_pubkey: string;
         proof_of_possession: string;
@@ -1336,16 +1335,16 @@ export declare namespace version {
         function type(): TypeDescriptor<Version>;
     }
     namespace entry {
-        function setVersion(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setVersion(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view { }
 }
 export declare namespace vesting {
     interface AdminStore {
-        vesting_contracts: Address[];
+        vesting_contracts: MoveAddressType[];
         nonce: bigint;
         create_events: event.EventHandle<vesting.CreateVestingContractEvent>;
     }
@@ -1354,8 +1353,8 @@ export declare namespace vesting {
         function type(): TypeDescriptor<AdminStore>;
     }
     interface AdminWithdrawEvent {
-        admin: Address;
-        vesting_contract_address: Address;
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
         amount: bigint;
     }
     namespace AdminWithdrawEvent {
@@ -1367,12 +1366,12 @@ export declare namespace vesting {
         type_arguments: [];
     }
     interface CreateVestingContractEvent {
-        operator: Address;
-        voter: Address;
+        operator: MoveAddressType;
+        voter: MoveAddressType;
         grant_amount: bigint;
-        withdrawal_address: Address;
-        vesting_contract_address: Address;
-        staking_pool_address: Address;
+        withdrawal_address: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
         commission_percentage: bigint;
     }
     namespace CreateVestingContractEvent {
@@ -1384,8 +1383,8 @@ export declare namespace vesting {
         type_arguments: [];
     }
     interface DistributeEvent {
-        admin: Address;
-        vesting_contract_address: Address;
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
         amount: bigint;
     }
     namespace DistributeEvent {
@@ -1397,9 +1396,9 @@ export declare namespace vesting {
         type_arguments: [];
     }
     interface ResetLockupEvent {
-        admin: Address;
-        vesting_contract_address: Address;
-        staking_pool_address: Address;
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
         new_lockup_expiration_secs: bigint;
     }
     namespace ResetLockupEvent {
@@ -1411,11 +1410,11 @@ export declare namespace vesting {
         type_arguments: [];
     }
     interface SetBeneficiaryEvent {
-        admin: Address;
-        vesting_contract_address: Address;
-        shareholder: Address;
-        old_beneficiary: Address;
-        new_beneficiary: Address;
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        shareholder: MoveAddressType;
+        old_beneficiary: MoveAddressType;
+        new_beneficiary: MoveAddressType;
     }
     namespace SetBeneficiaryEvent {
         const TYPE_QNAME = "0x1::vesting::SetBeneficiaryEvent";
@@ -1426,9 +1425,9 @@ export declare namespace vesting {
         type_arguments: [];
     }
     interface StakingInfo {
-        pool_address: Address;
-        operator: Address;
-        voter: Address;
+        pool_address: MoveAddressType;
+        operator: MoveAddressType;
+        voter: MoveAddressType;
         commission_percentage: bigint;
     }
     namespace StakingInfo {
@@ -1436,8 +1435,8 @@ export declare namespace vesting {
         function type(): TypeDescriptor<StakingInfo>;
     }
     interface TerminateEvent {
-        admin: Address;
-        vesting_contract_address: Address;
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
     }
     namespace TerminateEvent {
         const TYPE_QNAME = "0x1::vesting::TerminateEvent";
@@ -1448,9 +1447,9 @@ export declare namespace vesting {
         type_arguments: [];
     }
     interface UnlockRewardsEvent {
-        admin: Address;
-        vesting_contract_address: Address;
-        staking_pool_address: Address;
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
         amount: bigint;
     }
     namespace UnlockRewardsEvent {
@@ -1462,11 +1461,11 @@ export declare namespace vesting {
         type_arguments: [];
     }
     interface UpdateOperatorEvent {
-        admin: Address;
-        vesting_contract_address: Address;
-        staking_pool_address: Address;
-        old_operator: Address;
-        new_operator: Address;
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
+        old_operator: MoveAddressType;
+        new_operator: MoveAddressType;
         commission_percentage: bigint;
     }
     namespace UpdateOperatorEvent {
@@ -1478,11 +1477,11 @@ export declare namespace vesting {
         type_arguments: [];
     }
     interface UpdateVoterEvent {
-        admin: Address;
-        vesting_contract_address: Address;
-        staking_pool_address: Address;
-        old_voter: Address;
-        new_voter: Address;
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
+        old_voter: MoveAddressType;
+        new_voter: MoveAddressType;
     }
     namespace UpdateVoterEvent {
         const TYPE_QNAME = "0x1::vesting::UpdateVoterEvent";
@@ -1493,9 +1492,9 @@ export declare namespace vesting {
         type_arguments: [];
     }
     interface VestEvent {
-        admin: Address;
-        vesting_contract_address: Address;
-        staking_pool_address: Address;
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
         period_vested: bigint;
         amount: bigint;
     }
@@ -1508,7 +1507,7 @@ export declare namespace vesting {
         type_arguments: [];
     }
     interface VestingAccountManagement {
-        roles: simple_map.SimpleMap<string, Address>;
+        roles: simple_map.SimpleMap<string, MoveAddressType>;
     }
     namespace VestingAccountManagement {
         const TYPE_QNAME = "0x1::vesting::VestingAccountManagement";
@@ -1516,11 +1515,11 @@ export declare namespace vesting {
     }
     interface VestingContract {
         state: bigint;
-        admin: Address;
+        admin: MoveAddressType;
         grant_pool: pool_u64.Pool;
-        beneficiaries: simple_map.SimpleMap<Address, Address>;
+        beneficiaries: simple_map.SimpleMap<MoveAddressType, MoveAddressType>;
         vesting_schedule: vesting.VestingSchedule;
-        withdrawal_address: Address;
+        withdrawal_address: MoveAddressType;
         staking: vesting.StakingInfo;
         remaining_grant: bigint;
         signer_cap: account.SignerCapability;
@@ -1553,118 +1552,122 @@ export declare namespace vesting {
         type_arguments: [];
     }
     namespace entry {
-        function adminWithdraw(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function distribute(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function distributeMany(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address[]];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function resetBeneficiary(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function resetLockup(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function setBeneficiary(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, Address, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function setBeneficiaryResetter(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function setManagementRole(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, string, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function terminateVestingContract(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function unlockRewards(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function unlockRewardsMany(client: AptosClient, account: AptosAccount, request: {
-            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];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function updateOperatorWithSameCommission(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function updateVoter(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function vest(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function vestMany(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address[]];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function adminWithdraw(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function distribute(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function distributeMany(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function resetBeneficiary(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function resetLockup(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setBeneficiary(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setBeneficiaryForOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setBeneficiaryResetter(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setManagementRole(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function terminateVestingContract(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function unlockRewards(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function unlockRewardsMany(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateCommissionPercentage(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateOperatorWithSameCommission(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateVoter(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function vest(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function vestMany(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
-        function accumulatedRewards(client: AptosClient, request: {
-            arguments: [Address, Address];
+        function accumulatedRewards(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function beneficiary(client: AptosClient, request: {
-            arguments: [Address, Address];
-        }, version?: bigint): Promise<[Address]>;
-        function operator(client: AptosClient, request: {
-            arguments: [Address];
-        }, version?: bigint): Promise<[Address]>;
-        function operatorCommissionPercentage(client: AptosClient, request: {
-            arguments: [Address];
+        function beneficiary(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function operator(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function operatorCommissionPercentage(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function periodDurationSecs(client: AptosClient, request: {
-            arguments: [Address];
+        function periodDurationSecs(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function remainingGrant(client: AptosClient, request: {
-            arguments: [Address];
+        function remainingGrant(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function shareholder(client: AptosClient, request: {
-            arguments: [Address, Address];
-        }, version?: bigint): Promise<[Address]>;
-        function shareholders(client: AptosClient, request: {
-            arguments: [Address];
-        }, version?: bigint): Promise<[Address[]]>;
-        function stakePoolAddress(client: AptosClient, request: {
-            arguments: [Address];
-        }, version?: bigint): Promise<[Address]>;
-        function totalAccumulatedRewards(client: AptosClient, request: {
-            arguments: [Address];
+        function shareholder(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function shareholders(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType[]]>;
+        function stakePoolAddress(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function totalAccumulatedRewards(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function vestingContracts(client: AptosClient, request: {
-            arguments: [Address];
-        }, version?: bigint): Promise<[Address[]]>;
-        function vestingSchedule(client: AptosClient, request: {
-            arguments: [Address];
+        function vestingContracts(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType[]]>;
+        function vestingSchedule(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[vesting.VestingSchedule]>;
-        function vestingStartSecs(client: AptosClient, request: {
-            arguments: [Address];
+        function vestingStartSecs(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function voter(client: AptosClient, request: {
-            arguments: [Address];
-        }, version?: bigint): Promise<[Address]>;
+        function voter(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
     }
 }
 export declare namespace bls12381 {
@@ -1747,7 +1750,7 @@ export declare namespace chain_id {
     }
     namespace entry { }
     namespace view {
-        function get(client: AptosClient, version?: bigint): Promise<[number]>;
+        function get(client: Aptos, version?: bigint): Promise<[number]>;
     }
 }
 export declare namespace features {
@@ -1770,8 +1773,8 @@ export declare namespace pool_u64 {
         shareholders_limit: bigint;
         total_coins: bigint;
         total_shares: bigint;
-        shares: simple_map.SimpleMap<Address, bigint>;
-        shareholders: Address[];
+        shares: simple_map.SimpleMap<MoveAddressType, bigint>;
+        shareholders: MoveAddressType[];
         scaling_factor: bigint;
     }
     namespace Pool {
@@ -1817,13 +1820,13 @@ export declare namespace timestamp {
     }
     namespace entry { }
     namespace view {
-        function nowMicroseconds(client: AptosClient, version?: bigint): Promise<[bigint]>;
-        function nowSeconds(client: AptosClient, version?: bigint): Promise<[bigint]>;
+        function nowMicroseconds(client: Aptos, version?: bigint): Promise<[bigint]>;
+        function nowSeconds(client: Aptos, version?: bigint): Promise<[bigint]>;
     }
 }
 export declare namespace type_info {
     interface TypeInfo {
-        account_address: Address;
+        account_address: MoveAddressType;
         module_name: string;
         struct_name: string;
     }
@@ -1840,8 +1843,8 @@ export declare namespace type_info {
 }
 export declare namespace aggregator {
     interface Aggregator {
-        handle: Address;
-        key: Address;
+        handle: MoveAddressType;
+        key: MoveAddressType;
         limit: bigint;
     }
     namespace Aggregator {
@@ -1860,7 +1863,7 @@ export declare namespace aptos_coin {
         function type(): TypeDescriptor<AptosCoin>;
     }
     interface DelegatedMintCapability {
-        to: Address;
+        to: MoveAddressType;
     }
     namespace DelegatedMintCapability {
         const TYPE_QNAME = "0x1::aptos_coin::DelegatedMintCapability";
@@ -1881,18 +1884,18 @@ export declare namespace aptos_coin {
         function type(): TypeDescriptor<MintCapStore>;
     }
     namespace entry {
-        function claimMintCapability(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function delegateMintCapability(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function mint(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function claimMintCapability(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function delegateMintCapability(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function mint(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view { }
 }
@@ -1931,28 +1934,28 @@ export declare namespace bit_vector {
 }
 export declare namespace capability {
     interface Cap<T0> {
-        root: Address;
+        root: MoveAddressType;
     }
     namespace Cap {
         const TYPE_QNAME = "0x1::capability::Cap";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Cap<T0>>;
     }
     interface CapDelegateState<T0> {
-        root: Address;
+        root: MoveAddressType;
     }
     namespace CapDelegateState {
         const TYPE_QNAME = "0x1::capability::CapDelegateState";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<CapDelegateState<T0>>;
     }
     interface CapState<T0> {
-        delegates: Address[];
+        delegates: MoveAddressType[];
     }
     namespace CapState {
         const TYPE_QNAME = "0x1::capability::CapState";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<CapState<T0>>;
     }
     interface LinearCap<T0> {
-        root: Address;
+        root: MoveAddressType;
     }
     namespace LinearCap {
         const TYPE_QNAME = "0x1::capability::LinearCap";
@@ -2105,8 +2108,8 @@ export declare namespace chain_status {
     }
     namespace entry { }
     namespace view {
-        function isGenesis(client: AptosClient, version?: bigint): Promise<[Boolean]>;
-        function isOperating(client: AptosClient, version?: bigint): Promise<[Boolean]>;
+        function isGenesis(client: Aptos, version?: bigint): Promise<[Boolean]>;
+        function isOperating(client: Aptos, version?: bigint): Promise<[Boolean]>;
     }
 }
 export declare namespace copyable_any {
@@ -2167,22 +2170,22 @@ export declare namespace managed_coin {
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Capabilities<T0>>;
     }
     namespace entry {
-        function burn<T0 = any>(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [string];
-            arguments: [bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function initialize<T0 = any>(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [string];
-            arguments: [string, string, number, Boolean];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function mint<T0 = any>(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [string];
-            arguments: [Address, bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function register<T0 = any>(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [string];
-            arguments: [];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function burn<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function initialize<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [string, string, number, Boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function mint<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function register<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view { }
 }
@@ -2312,34 +2315,34 @@ export declare namespace aptos_account {
         function type(): TypeDescriptor<DirectTransferConfig>;
     }
     namespace entry {
-        function batchTransfer(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address[], bigint[]];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function batchTransferCoins<T0 = any>(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [string];
-            arguments: [Address[], bigint[]];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function createAccount(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function setAllowDirectCoinTransfers(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Boolean];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function transfer(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function transferCoins<T0 = any>(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [string];
-            arguments: [Address, bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function batchTransfer(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[], bigint[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function batchTransferCoins<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType[], bigint[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createAccount(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setAllowDirectCoinTransfers(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [Boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function transfer(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function transferCoins<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
-        function canReceiveDirectCoinTransfers(client: AptosClient, request: {
-            arguments: [Address];
+        function canReceiveDirectCoinTransfers(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[Boolean]>;
     }
 }
@@ -2416,38 +2419,38 @@ export declare namespace multi_ed25519 {
 }
 export declare namespace staking_proxy {
     namespace entry {
-        function setOperator(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function setStakePoolOperator(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function setStakePoolVoter(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function setStakingContractOperator(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function setStakingContractVoter(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function setVestingContractOperator(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function setVestingContractVoter(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function setVoter(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setStakePoolOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setStakePoolVoter(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setStakingContractOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setStakingContractVoter(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setVestingContractOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setVestingContractVoter(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setVoter(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view { }
 }
@@ -2606,46 +2609,46 @@ export declare namespace fungible_asset {
         type_arguments: [];
     }
     namespace entry {
-        function transfer<T0 = any>(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [string];
-            arguments: [object_.Object<T0>, object_.Object<T0>, bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function transfer<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object_.Object<T0>, object_.Object<T0>, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
-        function balance<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [object_.Object<T0>];
+        function balance<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object_.Object<T0>];
         }, version?: bigint): Promise<[bigint]>;
-        function decimals<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [object_.Object<T0>];
+        function decimals<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object_.Object<T0>];
         }, version?: bigint): Promise<[number]>;
-        function isFrozen<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [object_.Object<T0>];
+        function isFrozen<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object_.Object<T0>];
         }, version?: bigint): Promise<[Boolean]>;
-        function maximum<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [object_.Object<T0>];
+        function maximum<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object_.Object<T0>];
         }, version?: bigint): Promise<[option.Option<bigint>]>;
-        function name<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [object_.Object<T0>];
+        function name<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object_.Object<T0>];
         }, version?: bigint): Promise<[string]>;
-        function storeExists(client: AptosClient, request: {
-            arguments: [Address];
+        function storeExists(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[Boolean]>;
-        function storeMetadata<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [object_.Object<T0>];
+        function storeMetadata<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object_.Object<T0>];
         }, version?: bigint): Promise<[object_.Object<fungible_asset.Metadata>]>;
-        function supply<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [object_.Object<T0>];
+        function supply<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object_.Object<T0>];
         }, version?: bigint): Promise<[option.Option<bigint>]>;
-        function symbol<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [object_.Object<T0>];
+        function symbol<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object_.Object<T0>];
         }, version?: bigint): Promise<[string]>;
     }
 }
@@ -2679,8 +2682,8 @@ export declare namespace staking_config {
 }
 export declare namespace delegation_pool {
     interface AddStakeEvent {
-        pool_address: Address;
-        delegator_address: Address;
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
         amount_added: bigint;
         add_stake_fee: bigint;
     }
@@ -2692,10 +2695,17 @@ export declare namespace delegation_pool {
         data_decoded: AddStakeEvent;
         type_arguments: [];
     }
+    interface BeneficiaryForOperator {
+        beneficiary_for_operator: MoveAddressType;
+    }
+    namespace BeneficiaryForOperator {
+        const TYPE_QNAME = "0x1::delegation_pool::BeneficiaryForOperator";
+        function type(): TypeDescriptor<BeneficiaryForOperator>;
+    }
     interface CreateProposalEvent {
         proposal_id: bigint;
-        voter: Address;
-        delegation_pool: Address;
+        voter: MoveAddressType;
+        delegation_pool: MoveAddressType;
     }
     namespace CreateProposalEvent {
         const TYPE_QNAME = "0x1::delegation_pool::CreateProposalEvent";
@@ -2706,9 +2716,9 @@ export declare namespace delegation_pool {
         type_arguments: [];
     }
     interface DelegateVotingPowerEvent {
-        pool_address: Address;
-        delegator: Address;
-        voter: Address;
+        pool_address: MoveAddressType;
+        delegator: MoveAddressType;
+        voter: MoveAddressType;
     }
     namespace DelegateVotingPowerEvent {
         const TYPE_QNAME = "0x1::delegation_pool::DelegateVotingPowerEvent";
@@ -2736,7 +2746,7 @@ export declare namespace delegation_pool {
         active_shares: pool_u64_unbound.Pool;
         observed_lockup_cycle: delegation_pool.ObservedLockupCycle;
         inactive_shares: table.Table<delegation_pool.ObservedLockupCycle, pool_u64_unbound.Pool>;
-        pending_withdrawals: table.Table<Address, delegation_pool.ObservedLockupCycle>;
+        pending_withdrawals: table.Table<MoveAddressType, delegation_pool.ObservedLockupCycle>;
         stake_pool_signer_cap: account.SignerCapability;
         total_coins_inactive: bigint;
         operator_commission_percentage: bigint;
@@ -2751,15 +2761,30 @@ export declare namespace delegation_pool {
         function type(): TypeDescriptor<DelegationPool>;
     }
     interface DelegationPoolOwnership {
-        pool_address: Address;
+        pool_address: MoveAddressType;
     }
     namespace DelegationPoolOwnership {
         const TYPE_QNAME = "0x1::delegation_pool::DelegationPoolOwnership";
         function type(): TypeDescriptor<DelegationPoolOwnership>;
     }
+    interface DistributeCommission {
+        pool_address: MoveAddressType;
+        operator: MoveAddressType;
+        beneficiary: MoveAddressType;
+        commission_active: bigint;
+        commission_pending_inactive: bigint;
+    }
+    namespace DistributeCommission {
+        const TYPE_QNAME = "0x1::delegation_pool::DistributeCommission";
+        function type(): TypeDescriptor<DistributeCommission>;
+    }
+    interface DistributeCommissionInstance extends TypedEventInstance<DistributeCommission> {
+        data_decoded: DistributeCommission;
+        type_arguments: [];
+    }
     interface DistributeCommissionEvent {
-        pool_address: Address;
-        operator: Address;
+        pool_address: MoveAddressType;
+        operator: MoveAddressType;
         commission_active: bigint;
         commission_pending_inactive: bigint;
     }
@@ -2774,8 +2799,8 @@ export declare namespace delegation_pool {
     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_delegation: smart_table.SmartTable<MoveAddressType, delegation_pool.VoteDelegation>;
+        delegated_votes: smart_table.SmartTable<MoveAddressType, 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>;
@@ -2796,8 +2821,8 @@ export declare namespace delegation_pool {
         type_arguments: [];
     }
     interface ReactivateStakeEvent {
-        pool_address: Address;
-        delegator_address: Address;
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
         amount_reactivated: bigint;
     }
     namespace ReactivateStakeEvent {
@@ -2808,9 +2833,22 @@ export declare namespace delegation_pool {
         data_decoded: ReactivateStakeEvent;
         type_arguments: [];
     }
+    interface SetBeneficiaryForOperator {
+        operator: MoveAddressType;
+        old_beneficiary: MoveAddressType;
+        new_beneficiary: MoveAddressType;
+    }
+    namespace SetBeneficiaryForOperator {
+        const TYPE_QNAME = "0x1::delegation_pool::SetBeneficiaryForOperator";
+        function type(): TypeDescriptor<SetBeneficiaryForOperator>;
+    }
+    interface SetBeneficiaryForOperatorInstance extends TypedEventInstance<SetBeneficiaryForOperator> {
+        data_decoded: SetBeneficiaryForOperator;
+        type_arguments: [];
+    }
     interface UnlockStakeEvent {
-        pool_address: Address;
-        delegator_address: Address;
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
         amount_unlocked: bigint;
     }
     namespace UnlockStakeEvent {
@@ -2822,8 +2860,8 @@ export declare namespace delegation_pool {
         type_arguments: [];
     }
     interface VoteDelegation {
-        voter: Address;
-        pending_voter: Address;
+        voter: MoveAddressType;
+        pending_voter: MoveAddressType;
         last_locked_until_secs: bigint;
     }
     namespace VoteDelegation {
@@ -2835,9 +2873,9 @@ export declare namespace delegation_pool {
         type_arguments: [];
     }
     interface VoteEvent {
-        voter: Address;
+        voter: MoveAddressType;
         proposal_id: bigint;
-        delegation_pool: Address;
+        delegation_pool: MoveAddressType;
         num_votes: bigint;
         should_pass: Boolean;
     }
@@ -2850,7 +2888,7 @@ export declare namespace delegation_pool {
         type_arguments: [];
     }
     interface VotingRecordKey {
-        voter: Address;
+        voter: MoveAddressType;
         proposal_id: bigint;
     }
     namespace VotingRecordKey {
@@ -2862,8 +2900,8 @@ export declare namespace delegation_pool {
         type_arguments: [];
     }
     interface WithdrawStakeEvent {
-        pool_address: Address;
-        delegator_address: Address;
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
         amount_withdrawn: bigint;
     }
     namespace WithdrawStakeEvent {
@@ -2875,103 +2913,110 @@ export declare namespace delegation_pool {
         type_arguments: [];
     }
     namespace entry {
-        function addStake(client: AptosClient, account: AptosAccount, request: {
-            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];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function reactivateStake(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function setDelegatedVoter(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function setOperator(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function synchronizeDelegationPool(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function unlock(client: AptosClient, account: AptosAccount, request: {
-            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>;
+        function addStake(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createProposal(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, string, string, Boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function delegateVotingPower(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function enablePartialGovernanceVoting(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function initializeDelegationPool(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function reactivateStake(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setBeneficiaryForOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setDelegatedVoter(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function synchronizeDelegationPool(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function unlock(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function vote(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint, bigint, Boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function withdraw(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
-        function calculateAndUpdateDelegatorVoter(client: AptosClient, request: {
-            arguments: [Address, Address];
-        }, version?: bigint): Promise<[Address]>;
-        function calculateAndUpdateRemainingVotingPower(client: AptosClient, request: {
-            arguments: [Address, Address, bigint];
+        function beneficiaryForOperator(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function calculateAndUpdateDelegatorVoter(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function calculateAndUpdateRemainingVotingPower(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType, bigint];
         }, version?: bigint): Promise<[bigint]>;
-        function calculateAndUpdateVoterTotalVotingPower(client: AptosClient, request: {
-            arguments: [Address, Address];
+        function calculateAndUpdateVoterTotalVotingPower(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function canWithdrawPendingInactive(client: AptosClient, request: {
-            arguments: [Address];
+        function canWithdrawPendingInactive(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[Boolean]>;
-        function delegationPoolExists(client: AptosClient, request: {
-            arguments: [Address];
+        function delegationPoolExists(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[Boolean]>;
-        function getAddStakeFee(client: AptosClient, request: {
-            arguments: [Address, bigint];
+        function getAddStakeFee(client: Aptos, request: {
+            functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[bigint]>;
-        function getDelegationPoolStake(client: AptosClient, request: {
-            arguments: [Address];
+        function getDelegationPoolStake(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, 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]>;
-        function getPendingWithdrawal(client: AptosClient, request: {
-            arguments: [Address, Address];
+        function getExpectedStakePoolAddress(client: Aptos, request: {
+            functionArguments: [MoveAddressType, string];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function getOwnedPoolAddress(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function getPendingWithdrawal(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
         }, version?: bigint): Promise<[Boolean, bigint]>;
-        function getStake(client: AptosClient, request: {
-            arguments: [Address, Address];
+        function getStake(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
         }, version?: bigint): Promise<[bigint, bigint, bigint]>;
-        function observedLockupCycle(client: AptosClient, request: {
-            arguments: [Address];
+        function observedLockupCycle(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function operatorCommissionPercentage(client: AptosClient, request: {
-            arguments: [Address];
+        function operatorCommissionPercentage(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function ownerCapExists(client: AptosClient, request: {
-            arguments: [Address];
+        function ownerCapExists(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[Boolean]>;
-        function partialGovernanceVotingEnabled(client: AptosClient, request: {
-            arguments: [Address];
+        function partialGovernanceVotingEnabled(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[Boolean]>;
-        function shareholdersCountActivePool(client: AptosClient, request: {
-            arguments: [Address];
+        function shareholdersCountActivePool(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
     }
 }
@@ -3023,7 +3068,7 @@ export declare namespace transaction_fee {
     }
     interface CollectedFeesPerBlock {
         amount: coin.AggregatableCoin<aptos_coin.AptosCoin>;
-        proposer: option.Option<Address>;
+        proposer: option.Option<MoveAddressType>;
         burn_percentage: number;
     }
     namespace CollectedFeesPerBlock {
@@ -3057,8 +3102,8 @@ export declare namespace aptos_governance {
         function type(): TypeDescriptor<ApprovedExecutionHashes>;
     }
     interface CreateProposalEvent {
-        proposer: Address;
-        stake_pool: Address;
+        proposer: MoveAddressType;
+        stake_pool: MoveAddressType;
         proposal_id: bigint;
         execution_hash: string;
         proposal_metadata: simple_map.SimpleMap<string, string>;
@@ -3090,14 +3135,14 @@ export declare namespace aptos_governance {
         function type(): TypeDescriptor<GovernanceEvents>;
     }
     interface GovernanceResponsbility {
-        signer_caps: simple_map.SimpleMap<Address, account.SignerCapability>;
+        signer_caps: simple_map.SimpleMap<MoveAddressType, account.SignerCapability>;
     }
     namespace GovernanceResponsbility {
         const TYPE_QNAME = "0x1::aptos_governance::GovernanceResponsbility";
         function type(): TypeDescriptor<GovernanceResponsbility>;
     }
     interface RecordKey {
-        stake_pool: Address;
+        stake_pool: MoveAddressType;
         proposal_id: bigint;
     }
     namespace RecordKey {
@@ -3123,8 +3168,8 @@ export declare namespace aptos_governance {
     }
     interface VoteEvent {
         proposal_id: bigint;
-        voter: Address;
-        stake_pool: Address;
+        voter: MoveAddressType;
+        stake_pool: MoveAddressType;
         num_votes: bigint;
         should_pass: Boolean;
     }
@@ -3151,39 +3196,39 @@ export declare namespace aptos_governance {
         function type(): TypeDescriptor<VotingRecordsV2>;
     }
     namespace entry {
-        function addApprovedScriptHashScript(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function createProposal(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, string, string, string];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function createProposalV2(client: AptosClient, account: AptosAccount, request: {
-            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];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function addApprovedScriptHashScript(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createProposal(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, string, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createProposalV2(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, string, string, Boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function partialVote(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint, bigint, Boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function vote(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint, Boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
-        function getMinVotingThreshold(client: AptosClient, version?: bigint): Promise<[bigint]>;
-        function getRemainingVotingPower(client: AptosClient, request: {
-            arguments: [Address, bigint];
+        function getMinVotingThreshold(client: Aptos, version?: bigint): Promise<[bigint]>;
+        function getRemainingVotingPower(client: Aptos, request: {
+            functionArguments: [MoveAddressType, 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];
+        function getRequiredProposerStake(client: Aptos, version?: bigint): Promise<[bigint]>;
+        function getVotingDurationSecs(client: Aptos, version?: bigint): Promise<[bigint]>;
+        function getVotingPower(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function hasEntirelyVoted(client: AptosClient, request: {
-            arguments: [Address, bigint];
+        function hasEntirelyVoted(client: Aptos, request: {
+            functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[Boolean]>;
     }
 }
@@ -3320,7 +3365,7 @@ export declare namespace execution_config {
 }
 export declare namespace multisig_account {
     interface AddOwnersEvent {
-        owners_added: Address[];
+        owners_added: MoveAddressType[];
     }
     namespace AddOwnersEvent {
         const TYPE_QNAME = "0x1::multisig_account::AddOwnersEvent";
@@ -3331,7 +3376,7 @@ export declare namespace multisig_account {
         type_arguments: [];
     }
     interface CreateTransactionEvent {
-        creator: Address;
+        creator: MoveAddressType;
         sequence_number: bigint;
         transaction: multisig_account.MultisigTransaction;
     }
@@ -3346,7 +3391,7 @@ export declare namespace multisig_account {
     interface ExecuteRejectedTransactionEvent {
         sequence_number: bigint;
         num_rejections: bigint;
-        executor: Address;
+        executor: MoveAddressType;
     }
     namespace ExecuteRejectedTransactionEvent {
         const TYPE_QNAME = "0x1::multisig_account::ExecuteRejectedTransactionEvent";
@@ -3382,7 +3427,7 @@ export declare namespace multisig_account {
         type_arguments: [];
     }
     interface MultisigAccount {
-        owners: Address[];
+        owners: MoveAddressType[];
         num_signatures_required: bigint;
         transactions: table.Table<bigint, multisig_account.MultisigTransaction>;
         last_executed_sequence_number: bigint;
@@ -3405,9 +3450,9 @@ export declare namespace multisig_account {
     }
     interface MultisigAccountCreationMessage {
         chain_id: number;
-        account_address: Address;
+        account_address: MoveAddressType;
         sequence_number: bigint;
-        owners: Address[];
+        owners: MoveAddressType[];
         num_signatures_required: bigint;
     }
     namespace MultisigAccountCreationMessage {
@@ -3416,9 +3461,9 @@ export declare namespace multisig_account {
     }
     interface MultisigAccountCreationWithAuthKeyRevocationMessage {
         chain_id: number;
-        account_address: Address;
+        account_address: MoveAddressType;
         sequence_number: bigint;
-        owners: Address[];
+        owners: MoveAddressType[];
         num_signatures_required: bigint;
     }
     namespace MultisigAccountCreationWithAuthKeyRevocationMessage {
@@ -3428,8 +3473,8 @@ export declare namespace multisig_account {
     interface MultisigTransaction {
         payload: option.Option<string>;
         payload_hash: option.Option<string>;
-        votes: simple_map.SimpleMap<Address, Boolean>;
-        creator: Address;
+        votes: simple_map.SimpleMap<MoveAddressType, Boolean>;
+        creator: MoveAddressType;
         creation_time_secs: bigint;
     }
     namespace MultisigTransaction {
@@ -3441,7 +3486,7 @@ export declare namespace multisig_account {
         type_arguments: [];
     }
     interface RemoveOwnersEvent {
-        owners_removed: Address[];
+        owners_removed: MoveAddressType[];
     }
     namespace RemoveOwnersEvent {
         const TYPE_QNAME = "0x1::multisig_account::RemoveOwnersEvent";
@@ -3452,7 +3497,7 @@ export declare namespace multisig_account {
         type_arguments: [];
     }
     interface TransactionExecutionFailedEvent {
-        executor: Address;
+        executor: MoveAddressType;
         sequence_number: bigint;
         transaction_payload: string;
         num_approvals: bigint;
@@ -3467,7 +3512,7 @@ export declare namespace multisig_account {
         type_arguments: [];
     }
     interface TransactionExecutionSucceededEvent {
-        executor: Address;
+        executor: MoveAddressType;
         sequence_number: bigint;
         transaction_payload: string;
         num_approvals: bigint;
@@ -3493,7 +3538,7 @@ export declare namespace multisig_account {
         type_arguments: [];
     }
     interface VoteEvent {
-        owner: Address;
+        owner: MoveAddressType;
         sequence_number: bigint;
         approved: Boolean;
     }
@@ -3506,39 +3551,39 @@ export declare namespace multisig_account {
         type_arguments: [];
     }
     namespace entry {
-        function addOwner(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function addOwners(client: AptosClient, account: AptosAccount, request: {
-            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];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function create(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [bigint, string[], string[]];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function createTransaction(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, string];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function createTransactionWithHash(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, string];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function createWithExistingAccount(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [
-                Address,
-                Address[],
+        function addOwner(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function addOwners(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function addOwnersAndUpdateSignaturesRequired(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[], bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function approveTransaction(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function create(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint, string[], string[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createTransaction(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createTransactionWithHash(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createWithExistingAccount(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [
+                MoveAddressType,
+                MoveAddressType[],
                 bigint,
                 number,
                 string,
@@ -3546,12 +3591,12 @@ export declare namespace multisig_account {
                 string[],
                 string[]
             ];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function createWithExistingAccountAndRevokeAuthKey(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [
-                Address,
-                Address[],
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createWithExistingAccountAndRevokeAuthKey(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [
+                MoveAddressType,
+                MoveAddressType[],
                 bigint,
                 number,
                 string,
@@ -3559,92 +3604,92 @@ export declare namespace multisig_account {
                 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];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function rejectTransaction(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function removeOwner(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function removeOwners(client: AptosClient, account: AptosAccount, request: {
-            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[]];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function updateSignaturesRequired(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function voteTransanction(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, bigint, Boolean];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createWithOwners(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[], bigint, string[], string[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createWithOwnersThenRemoveBootstrapper(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[], bigint, string[], string[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function executeRejectedTransaction(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function rejectTransaction(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function removeOwner(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function removeOwners(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function swapOwner(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function swapOwners(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[], MoveAddressType[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function swapOwnersAndUpdateSignaturesRequired(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[], MoveAddressType[], bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateMetadata(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string[], string[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateSignaturesRequired(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function voteTransanction(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint, Boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
-        function canBeExecuted(client: AptosClient, request: {
-            arguments: [Address, bigint];
+        function canBeExecuted(client: Aptos, request: {
+            functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[Boolean]>;
-        function canBeRejected(client: AptosClient, request: {
-            arguments: [Address, bigint];
+        function canBeRejected(client: Aptos, request: {
+            functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[Boolean]>;
-        function getNextMultisigAccountAddress(client: AptosClient, request: {
-            arguments: [Address];
-        }, version?: bigint): Promise<[Address]>;
-        function getNextTransactionPayload(client: AptosClient, request: {
-            arguments: [Address, string];
+        function getNextMultisigAccountAddress(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function getNextTransactionPayload(client: Aptos, request: {
+            functionArguments: [MoveAddressType, string];
         }, version?: bigint): Promise<[string]>;
-        function getPendingTransactions(client: AptosClient, request: {
-            arguments: [Address];
+        function getPendingTransactions(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[multisig_account.MultisigTransaction[]]>;
-        function getTransaction(client: AptosClient, request: {
-            arguments: [Address, bigint];
+        function getTransaction(client: Aptos, request: {
+            functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[multisig_account.MultisigTransaction]>;
-        function lastResolvedSequenceNumber(client: AptosClient, request: {
-            arguments: [Address];
+        function lastResolvedSequenceNumber(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function metadata(client: AptosClient, request: {
-            arguments: [Address];
+        function metadata(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[simple_map.SimpleMap<string, string>]>;
-        function nextSequenceNumber(client: AptosClient, request: {
-            arguments: [Address];
+        function nextSequenceNumber(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function numSignaturesRequired(client: AptosClient, request: {
-            arguments: [Address];
+        function numSignaturesRequired(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function owners(client: AptosClient, request: {
-            arguments: [Address];
-        }, version?: bigint): Promise<[Address[]]>;
-        function vote(client: AptosClient, request: {
-            arguments: [Address, bigint, Address];
+        function owners(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType[]]>;
+        function vote(client: Aptos, request: {
+            functionArguments: [MoveAddressType, bigint, MoveAddressType];
         }, version?: bigint): Promise<[Boolean, Boolean]>;
     }
 }
@@ -3652,7 +3697,7 @@ export declare namespace pool_u64_unbound {
     interface Pool {
         total_coins: bigint;
         total_shares: bigint;
-        shares: table_with_length.TableWithLength<Address, bigint>;
+        shares: table_with_length.TableWithLength<MoveAddressType, bigint>;
         scaling_factor: bigint;
     }
     namespace Pool {
@@ -3664,32 +3709,32 @@ export declare namespace pool_u64_unbound {
 }
 export declare namespace resource_account {
     interface Container {
-        store: simple_map.SimpleMap<Address, account.SignerCapability>;
+        store: simple_map.SimpleMap<MoveAddressType, account.SignerCapability>;
     }
     namespace Container {
         const TYPE_QNAME = "0x1::resource_account::Container";
         function type(): TypeDescriptor<Container>;
     }
     namespace entry {
-        function createResourceAccount(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [string, string];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function createResourceAccountAndFund(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [string, string, bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function createResourceAccountAndPublishPackage(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [string, string, string[]];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createResourceAccount(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createResourceAccountAndFund(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string, string, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createResourceAccountAndPublishPackage(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string, string, string[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view { }
 }
 export declare namespace staking_contract {
     interface AddDistributionEvent {
-        operator: Address;
-        pool_address: Address;
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
         amount: bigint;
     }
     namespace AddDistributionEvent {
@@ -3701,8 +3746,8 @@ export declare namespace staking_contract {
         type_arguments: [];
     }
     interface AddStakeEvent {
-        operator: Address;
-        pool_address: Address;
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
         amount: bigint;
     }
     namespace AddStakeEvent {
@@ -3713,10 +3758,17 @@ export declare namespace staking_contract {
         data_decoded: AddStakeEvent;
         type_arguments: [];
     }
+    interface BeneficiaryForOperator {
+        beneficiary_for_operator: MoveAddressType;
+    }
+    namespace BeneficiaryForOperator {
+        const TYPE_QNAME = "0x1::staking_contract::BeneficiaryForOperator";
+        function type(): TypeDescriptor<BeneficiaryForOperator>;
+    }
     interface CreateStakingContractEvent {
-        operator: Address;
-        voter: Address;
-        pool_address: Address;
+        operator: MoveAddressType;
+        voter: MoveAddressType;
+        pool_address: MoveAddressType;
         principal: bigint;
         commission_percentage: bigint;
     }
@@ -3729,9 +3781,9 @@ export declare namespace staking_contract {
         type_arguments: [];
     }
     interface DistributeEvent {
-        operator: Address;
-        pool_address: Address;
-        recipient: Address;
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
+        recipient: MoveAddressType;
         amount: bigint;
     }
     namespace DistributeEvent {
@@ -3743,8 +3795,8 @@ export declare namespace staking_contract {
         type_arguments: [];
     }
     interface RequestCommissionEvent {
-        operator: Address;
-        pool_address: Address;
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
         accumulated_rewards: bigint;
         commission_amount: bigint;
     }
@@ -3757,8 +3809,8 @@ export declare namespace staking_contract {
         type_arguments: [];
     }
     interface ResetLockupEvent {
-        operator: Address;
-        pool_address: Address;
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
     }
     namespace ResetLockupEvent {
         const TYPE_QNAME = "0x1::staking_contract::ResetLockupEvent";
@@ -3768,9 +3820,22 @@ export declare namespace staking_contract {
         data_decoded: ResetLockupEvent;
         type_arguments: [];
     }
+    interface SetBeneficiaryForOperator {
+        operator: MoveAddressType;
+        old_beneficiary: MoveAddressType;
+        new_beneficiary: MoveAddressType;
+    }
+    namespace SetBeneficiaryForOperator {
+        const TYPE_QNAME = "0x1::staking_contract::SetBeneficiaryForOperator";
+        function type(): TypeDescriptor<SetBeneficiaryForOperator>;
+    }
+    interface SetBeneficiaryForOperatorInstance extends TypedEventInstance<SetBeneficiaryForOperator> {
+        data_decoded: SetBeneficiaryForOperator;
+        type_arguments: [];
+    }
     interface StakingContract {
         principal: bigint;
-        pool_address: Address;
+        pool_address: MoveAddressType;
         owner_cap: stake.OwnerCapability;
         commission_percentage: bigint;
         distribution_pool: pool_u64.Pool;
@@ -3795,7 +3860,7 @@ export declare namespace staking_contract {
         function type(): TypeDescriptor<StakingGroupUpdateCommissionEvent>;
     }
     interface Store {
-        staking_contracts: simple_map.SimpleMap<Address, staking_contract.StakingContract>;
+        staking_contracts: simple_map.SimpleMap<MoveAddressType, staking_contract.StakingContract>;
         create_staking_contract_events: event.EventHandle<staking_contract.CreateStakingContractEvent>;
         update_voter_events: event.EventHandle<staking_contract.UpdateVoterEvent>;
         reset_lockup_events: event.EventHandle<staking_contract.ResetLockupEvent>;
@@ -3811,9 +3876,9 @@ export declare namespace staking_contract {
         function type(): TypeDescriptor<Store>;
     }
     interface SwitchOperatorEvent {
-        old_operator: Address;
-        new_operator: Address;
-        pool_address: Address;
+        old_operator: MoveAddressType;
+        new_operator: MoveAddressType;
+        pool_address: MoveAddressType;
     }
     namespace SwitchOperatorEvent {
         const TYPE_QNAME = "0x1::staking_contract::SwitchOperatorEvent";
@@ -3824,8 +3889,8 @@ export declare namespace staking_contract {
         type_arguments: [];
     }
     interface UnlockStakeEvent {
-        operator: Address;
-        pool_address: Address;
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
         amount: bigint;
         commission_paid: bigint;
     }
@@ -3838,8 +3903,8 @@ export declare namespace staking_contract {
         type_arguments: [];
     }
     interface UpdateCommissionEvent {
-        staker: Address;
-        operator: Address;
+        staker: MoveAddressType;
+        operator: MoveAddressType;
         old_commission_percentage: bigint;
         new_commission_percentage: bigint;
     }
@@ -3852,10 +3917,10 @@ export declare namespace staking_contract {
         type_arguments: [];
     }
     interface UpdateVoterEvent {
-        operator: Address;
-        pool_address: Address;
-        old_voter: Address;
-        new_voter: Address;
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
+        old_voter: MoveAddressType;
+        new_voter: MoveAddressType;
     }
     namespace UpdateVoterEvent {
         const TYPE_QNAME = "0x1::staking_contract::UpdateVoterEvent";
@@ -3866,72 +3931,85 @@ export declare namespace staking_contract {
         type_arguments: [];
     }
     namespace entry {
-        function addStake(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function createStakingContract(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, Address, bigint, bigint, string];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function distribute(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function requestCommission(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function resetLockup(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function switchOperator(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, Address, bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function switchOperatorWithSameCommission(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function unlockRewards(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function unlockStake(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function updateCommision(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
-        function updateVoter(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [];
-            arguments: [Address, Address];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function addStake(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createStakingContract(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [
+                MoveAddressType,
+                MoveAddressType,
+                bigint,
+                bigint,
+                string
+            ];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function distribute(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function requestCommission(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function resetLockup(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setBeneficiaryForOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function switchOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function switchOperatorWithSameCommission(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function unlockRewards(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function unlockStake(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateCommision(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateVoter(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
-        function commissionPercentage(client: AptosClient, request: {
-            arguments: [Address, Address];
+        function beneficiaryForOperator(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function commissionPercentage(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
         }, 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];
+        function getExpectedStakePoolAddress(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType, string];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function lastRecordedPrincipal(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function pendingDistributionCounts(client: AptosClient, request: {
-            arguments: [Address, Address];
+        function pendingDistributionCounts(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function stakePoolAddress(client: AptosClient, request: {
-            arguments: [Address, Address];
-        }, version?: bigint): Promise<[Address]>;
-        function stakingContractAmounts(client: AptosClient, request: {
-            arguments: [Address, Address];
+        function stakePoolAddress(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function stakingContractAmounts(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
         }, version?: bigint): Promise<[bigint, bigint, bigint]>;
-        function stakingContractExists(client: AptosClient, request: {
-            arguments: [Address, Address];
+        function stakingContractExists(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
         }, version?: bigint): Promise<[Boolean]>;
     }
 }
@@ -3953,7 +4031,7 @@ export declare namespace table_with_length {
 }
 export declare namespace aggregator_factory {
     interface AggregatorFactory {
-        phantom_table: table.Table<Address, bigint>;
+        phantom_table: table.Table<MoveAddressType, bigint>;
     }
     namespace AggregatorFactory {
         const TYPE_QNAME = "0x1::aggregator_factory::AggregatorFactory";
@@ -3999,7 +4077,7 @@ export declare namespace optional_aggregator {
 }
 export declare namespace transaction_context {
     interface AUID {
-        unique_address: Address;
+        unique_address: MoveAddressType;
     }
     namespace AUID {
         const TYPE_QNAME = "0x1::transaction_context::AUID";
@@ -4067,37 +4145,37 @@ export declare namespace primary_fungible_store {
         function type(): TypeDescriptor<DeriveRefPod>;
     }
     namespace entry {
-        function transfer<T0 = any>(client: AptosClient, account: AptosAccount, request: {
-            type_arguments: [string];
-            arguments: [object_.Object<T0>, Address, bigint];
-        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function transfer<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object_.Object<T0>, MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
-        function balance<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [Address, object_.Object<T0>];
+        function balance<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, object_.Object<T0>];
         }, version?: bigint): Promise<[bigint]>;
-        function isFrozen<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [Address, object_.Object<T0>];
+        function isFrozen<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, object_.Object<T0>];
         }, version?: bigint): Promise<[Boolean]>;
-        function primaryStore<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [Address, object_.Object<T0>];
+        function primaryStore<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, object_.Object<T0>];
         }, version?: bigint): Promise<[object_.Object<fungible_asset.FungibleStore>]>;
-        function primaryStoreAddress<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [Address, object_.Object<T0>];
-        }, version?: bigint): Promise<[Address]>;
-        function primaryStoreExists<T0 = any>(client: AptosClient, request: {
-            type_arguments: [string];
-            arguments: [Address, object_.Object<T0>];
+        function primaryStoreAddress<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, object_.Object<T0>];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function primaryStoreExists<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, object_.Object<T0>];
         }, version?: bigint): Promise<[Boolean]>;
     }
 }
 export declare namespace transaction_validation {
     interface TransactionValidation {
-        module_addr: Address;
+        module_addr: MoveAddressType;
         module_name: string;
         script_prologue_name: string;
         module_prologue_name: string;