@aptos-labs/ts-sdk 1.29.0-zeta.1 → 1.29.0-zeta.2

package/src/internal/move/jwks/build/jwk/sources/dependencies/AptosFramework/system_addresses.move

@@ -0,0 +1,82 @@
+module aptos_framework::system_addresses {
+    use std::error;
+    use std::signer;
+
+    /// The address/account did not correspond to the core resource address
+    const ENOT_CORE_RESOURCE_ADDRESS: u64 = 1;
+    /// The operation can only be performed by the VM
+    const EVM: u64 = 2;
+    /// The address/account did not correspond to the core framework address
+    const ENOT_APTOS_FRAMEWORK_ADDRESS: u64 = 3;
+    /// The address is not framework reserved address
+    const ENOT_FRAMEWORK_RESERVED_ADDRESS: u64 = 4;
+
+    public fun assert_core_resource(account: &signer) {
+        assert_core_resource_address(signer::address_of(account))
+    }
+
+    public fun assert_core_resource_address(addr: address) {
+        assert!(is_core_resource_address(addr), error::permission_denied(ENOT_CORE_RESOURCE_ADDRESS))
+    }
+
+    public fun is_core_resource_address(addr: address): bool {
+        addr == @core_resources
+    }
+
+    public fun assert_aptos_framework(account: &signer) {
+        assert!(
+            is_aptos_framework_address(signer::address_of(account)),
+            error::permission_denied(ENOT_APTOS_FRAMEWORK_ADDRESS),
+        )
+    }
+
+    public fun assert_framework_reserved_address(account: &signer) {
+        assert_framework_reserved(signer::address_of(account));
+    }
+
+    public fun assert_framework_reserved(addr: address) {
+        assert!(
+            is_framework_reserved_address(addr),
+            error::permission_denied(ENOT_FRAMEWORK_RESERVED_ADDRESS),
+        )
+    }
+
+    /// Return true if `addr` is 0x0 or under the on chain governance's control.
+    public fun is_framework_reserved_address(addr: address): bool {
+        is_aptos_framework_address(addr) ||
+            addr == @0x2 ||
+            addr == @0x3 ||
+            addr == @0x4 ||
+            addr == @0x5 ||
+            addr == @0x6 ||
+            addr == @0x7 ||
+            addr == @0x8 ||
+            addr == @0x9 ||
+            addr == @0xa
+    }
+
+    /// Return true if `addr` is 0x1.
+    public fun is_aptos_framework_address(addr: address): bool {
+        addr == @aptos_framework
+    }
+
+    /// Assert that the signer has the VM reserved address.
+    public fun assert_vm(account: &signer) {
+        assert!(is_vm(account), error::permission_denied(EVM))
+    }
+
+    /// Return true if `addr` is a reserved address for the VM to call system modules.
+    public fun is_vm(account: &signer): bool {
+        is_vm_address(signer::address_of(account))
+    }
+
+    /// Return true if `addr` is a reserved address for the VM to call system modules.
+    public fun is_vm_address(addr: address): bool {
+        addr == @vm_reserved
+    }
+
+    /// Return true if `addr` is either the VM address or an Aptos Framework address.
+    public fun is_reserved_address(addr: address): bool {
+        is_aptos_framework_address(addr) || is_vm_address(addr)
+    }
+}

package/src/internal/move/jwks/build/jwk/sources/dependencies/AptosFramework/timestamp.move

@@ -0,0 +1,88 @@
+/// This module keeps a global wall clock that stores the current Unix time in microseconds.
+/// It interacts with the other modules in the following ways:
+/// * genesis: to initialize the timestamp
+/// * block: to reach consensus on the global wall clock time
+module aptos_framework::timestamp {
+    use aptos_framework::system_addresses;
+    use std::error;
+
+    friend aptos_framework::genesis;
+
+    /// A singleton resource holding the current Unix time in microseconds
+    struct CurrentTimeMicroseconds has key {
+        microseconds: u64,
+    }
+
+    /// Conversion factor between seconds and microseconds
+    const MICRO_CONVERSION_FACTOR: u64 = 1000000;
+
+    /// The blockchain is not in an operating state yet
+    const ENOT_OPERATING: u64 = 1;
+    /// An invalid timestamp was provided
+    const EINVALID_TIMESTAMP: u64 = 2;
+
+    /// Marks that time has started. This can only be called from genesis and with the aptos framework account.
+    public(friend) fun set_time_has_started(aptos_framework: &signer) {
+        system_addresses::assert_aptos_framework(aptos_framework);
+        let timer = CurrentTimeMicroseconds { microseconds: 0 };
+        move_to(aptos_framework, timer);
+    }
+
+    /// Updates the wall clock time by consensus. Requires VM privilege and will be invoked during block prologue.
+    public fun update_global_time(
+        account: &signer,
+        proposer: address,
+        timestamp: u64
+    ) acquires CurrentTimeMicroseconds {
+        // Can only be invoked by AptosVM signer.
+        system_addresses::assert_vm(account);
+
+        let global_timer = borrow_global_mut<CurrentTimeMicroseconds>(@aptos_framework);
+        let now = global_timer.microseconds;
+        if (proposer == @vm_reserved) {
+            // NIL block with null address as proposer. Timestamp must be equal.
+            assert!(now == timestamp, error::invalid_argument(EINVALID_TIMESTAMP));
+        } else {
+            // Normal block. Time must advance
+            assert!(now < timestamp, error::invalid_argument(EINVALID_TIMESTAMP));
+            global_timer.microseconds = timestamp;
+        };
+    }
+
+    #[test_only]
+    public fun set_time_has_started_for_testing(account: &signer) {
+        if (!exists<CurrentTimeMicroseconds>(@aptos_framework)) {
+            set_time_has_started(account);
+        };
+    }
+
+    #[view]
+    /// Gets the current time in microseconds.
+    public fun now_microseconds(): u64 acquires CurrentTimeMicroseconds {
+        borrow_global<CurrentTimeMicroseconds>(@aptos_framework).microseconds
+    }
+
+    #[view]
+    /// Gets the current time in seconds.
+    public fun now_seconds(): u64 acquires CurrentTimeMicroseconds {
+        now_microseconds() / MICRO_CONVERSION_FACTOR
+    }
+
+    #[test_only]
+    public fun update_global_time_for_test(timestamp_microsecs: u64) acquires CurrentTimeMicroseconds {
+        let global_timer = borrow_global_mut<CurrentTimeMicroseconds>(@aptos_framework);
+        let now = global_timer.microseconds;
+        assert!(now < timestamp_microsecs, error::invalid_argument(EINVALID_TIMESTAMP));
+        global_timer.microseconds = timestamp_microsecs;
+    }
+
+    #[test_only]
+    public fun update_global_time_for_test_secs(timestamp_seconds: u64) acquires CurrentTimeMicroseconds {
+        update_global_time_for_test(timestamp_seconds * MICRO_CONVERSION_FACTOR);
+    }
+
+    #[test_only]
+    public fun fast_forward_seconds(timestamp_seconds: u64) acquires CurrentTimeMicroseconds {
+        update_global_time_for_test_secs(now_seconds() + timestamp_seconds);
+    }
+}

package/src/internal/move/jwks/build/jwk/sources/dependencies/AptosFramework/transaction_context.move

@@ -0,0 +1,262 @@
+module aptos_framework::transaction_context {
+    use std::error;
+    use std::features;
+    use std::option::Option;
+    use std::string::String;
+
+    /// Transaction context is only available in the user transaction prologue, execution, or epilogue phases.
+    const ETRANSACTION_CONTEXT_NOT_AVAILABLE: u64 = 1;
+
+    /// The transaction context extension feature is not enabled.
+    const ETRANSACTION_CONTEXT_EXTENSION_NOT_ENABLED: u64 = 2;
+
+    /// A wrapper denoting aptos unique identifer (AUID)
+    /// for storing an address
+    struct AUID has drop, store {
+        unique_address: address
+    }
+
+    /// Represents the entry function payload.
+    struct EntryFunctionPayload has copy, drop {
+        account_address: address,
+        module_name: String,
+        function_name: String,
+        ty_args_names: vector<String>,
+        args: vector<vector<u8>>,
+    }
+
+    /// Represents the multisig payload.
+    struct MultisigPayload has copy, drop {
+        multisig_address: address,
+        entry_function_payload: Option<EntryFunctionPayload>,
+    }
+
+    /// Returns the transaction hash of the current transaction.
+    native fun get_txn_hash(): vector<u8>;
+
+    /// Returns the transaction hash of the current transaction.
+    /// Internally calls the private function `get_txn_hash`.
+    /// This function is created for to feature gate the `get_txn_hash` function.
+    public fun get_transaction_hash(): vector<u8> {
+        get_txn_hash()
+    }
+
+    /// Returns a universally unique identifier (of type address) generated
+    /// by hashing the transaction hash of this transaction and a sequence number
+    /// specific to this transaction. This function can be called any
+    /// number of times inside a single transaction. Each such call increments
+    /// the sequence number and generates a new unique address.
+    /// Uses Scheme in types/src/transaction/authenticator.rs for domain separation
+    /// from other ways of generating unique addresses.
+    native fun generate_unique_address(): address;
+
+    /// Returns a aptos unique identifier. Internally calls
+    /// the private function `generate_unique_address`. This function is
+    /// created for to feature gate the `generate_unique_address` function.
+    public fun generate_auid_address(): address {
+        generate_unique_address()
+    }
+
+    /// Returns the script hash of the current entry function.
+    public native fun get_script_hash(): vector<u8>;
+
+    /// This method runs `generate_unique_address` native function and returns
+    /// the generated unique address wrapped in the AUID class.
+    public fun generate_auid(): AUID {
+        return AUID {
+            unique_address: generate_unique_address()
+        }
+    }
+
+    /// Returns the unique address wrapped in the given AUID struct.
+    public fun auid_address(auid: &AUID): address {
+        auid.unique_address
+    }
+
+    /// Returns the sender's address for the current transaction.
+    /// This function aborts if called outside of the transaction prologue, execution, or epilogue phases.
+    public fun sender(): address {
+        assert!(features::transaction_context_extension_enabled(), error::invalid_state(ETRANSACTION_CONTEXT_EXTENSION_NOT_ENABLED));
+        sender_internal()
+    }
+    native fun sender_internal(): address;
+
+    /// Returns the list of the secondary signers for the current transaction.
+    /// If the current transaction has no secondary signers, this function returns an empty vector.
+    /// This function aborts if called outside of the transaction prologue, execution, or epilogue phases.
+    public fun secondary_signers(): vector<address> {
+        assert!(features::transaction_context_extension_enabled(), error::invalid_state(ETRANSACTION_CONTEXT_EXTENSION_NOT_ENABLED));
+        secondary_signers_internal()
+    }
+    native fun secondary_signers_internal(): vector<address>;
+
+    /// Returns the gas payer address for the current transaction.
+    /// It is either the sender's address if no separate gas fee payer is specified for the current transaction,
+    /// or the address of the separate gas fee payer if one is specified.
+    /// This function aborts if called outside of the transaction prologue, execution, or epilogue phases.
+    public fun gas_payer(): address {
+        assert!(features::transaction_context_extension_enabled(), error::invalid_state(ETRANSACTION_CONTEXT_EXTENSION_NOT_ENABLED));
+        gas_payer_internal()
+    }
+    native fun gas_payer_internal(): address;
+
+    /// Returns the max gas amount in units which is specified for the current transaction.
+    /// This function aborts if called outside of the transaction prologue, execution, or epilogue phases.
+    public fun max_gas_amount(): u64 {
+        assert!(features::transaction_context_extension_enabled(), error::invalid_state(ETRANSACTION_CONTEXT_EXTENSION_NOT_ENABLED));
+        max_gas_amount_internal()
+    }
+    native fun max_gas_amount_internal(): u64;
+
+    /// Returns the gas unit price in Octas which is specified for the current transaction.
+    /// This function aborts if called outside of the transaction prologue, execution, or epilogue phases.
+    public fun gas_unit_price(): u64 {
+        assert!(features::transaction_context_extension_enabled(), error::invalid_state(ETRANSACTION_CONTEXT_EXTENSION_NOT_ENABLED));
+        gas_unit_price_internal()
+    }
+    native fun gas_unit_price_internal(): u64;
+
+    /// Returns the chain ID specified for the current transaction.
+    /// This function aborts if called outside of the transaction prologue, execution, or epilogue phases.
+    public fun chain_id(): u8 {
+        assert!(features::transaction_context_extension_enabled(), error::invalid_state(ETRANSACTION_CONTEXT_EXTENSION_NOT_ENABLED));
+        chain_id_internal()
+    }
+    native fun chain_id_internal(): u8;
+
+    /// Returns the entry function payload if the current transaction has such a payload. Otherwise, return `None`.
+    /// This function aborts if called outside of the transaction prologue, execution, or epilogue phases.
+    public fun entry_function_payload(): Option<EntryFunctionPayload> {
+        assert!(features::transaction_context_extension_enabled(), error::invalid_state(ETRANSACTION_CONTEXT_EXTENSION_NOT_ENABLED));
+        entry_function_payload_internal()
+    }
+    native fun entry_function_payload_internal(): Option<EntryFunctionPayload>;
+
+    /// Returns the account address of the entry function payload.
+    public fun account_address(payload: &EntryFunctionPayload): address {
+        assert!(features::transaction_context_extension_enabled(), error::invalid_state(ETRANSACTION_CONTEXT_EXTENSION_NOT_ENABLED));
+        payload.account_address
+    }
+
+    /// Returns the module name of the entry function payload.
+    public fun module_name(payload: &EntryFunctionPayload): String {
+        assert!(features::transaction_context_extension_enabled(), error::invalid_state(ETRANSACTION_CONTEXT_EXTENSION_NOT_ENABLED));
+        payload.module_name
+    }
+
+    /// Returns the function name of the entry function payload.
+    public fun function_name(payload: &EntryFunctionPayload): String {
+        assert!(features::transaction_context_extension_enabled(), error::invalid_state(ETRANSACTION_CONTEXT_EXTENSION_NOT_ENABLED));
+        payload.function_name
+    }
+
+    /// Returns the type arguments names of the entry function payload.
+    public fun type_arg_names(payload: &EntryFunctionPayload): vector<String> {
+        assert!(features::transaction_context_extension_enabled(), error::invalid_state(ETRANSACTION_CONTEXT_EXTENSION_NOT_ENABLED));
+        payload.ty_args_names
+    }
+
+    /// Returns the arguments of the entry function payload.
+    public fun args(payload: &EntryFunctionPayload): vector<vector<u8>> {
+        assert!(features::transaction_context_extension_enabled(), error::invalid_state(ETRANSACTION_CONTEXT_EXTENSION_NOT_ENABLED));
+        payload.args
+    }
+
+    /// Returns the multisig payload if the current transaction has such a payload. Otherwise, return `None`.
+    /// This function aborts if called outside of the transaction prologue, execution, or epilogue phases.
+    public fun multisig_payload(): Option<MultisigPayload> {
+        assert!(features::transaction_context_extension_enabled(), error::invalid_state(ETRANSACTION_CONTEXT_EXTENSION_NOT_ENABLED));
+        multisig_payload_internal()
+    }
+    native fun multisig_payload_internal(): Option<MultisigPayload>;
+
+    /// Returns the multisig account address of the multisig payload.
+    public fun multisig_address(payload: &MultisigPayload): address {
+        assert!(features::transaction_context_extension_enabled(), error::invalid_state(ETRANSACTION_CONTEXT_EXTENSION_NOT_ENABLED));
+        payload.multisig_address
+    }
+
+    /// Returns the inner entry function payload of the multisig payload.
+    public fun inner_entry_function_payload(payload: &MultisigPayload): Option<EntryFunctionPayload> {
+        assert!(features::transaction_context_extension_enabled(), error::invalid_state(ETRANSACTION_CONTEXT_EXTENSION_NOT_ENABLED));
+        payload.entry_function_payload
+    }
+
+    #[test()]
+    fun test_auid_uniquess() {
+        use std::vector;
+
+        let auids: vector<address> = vector<address>[];
+        let i: u64 = 0;
+        let count: u64 = 50;
+        while (i < count) {
+            i = i + 1;
+            vector::push_back(&mut auids, generate_auid_address());
+        };
+        i = 0;
+        while (i < count - 1) {
+            let j: u64 = i + 1;
+            while (j < count) {
+                assert!(*vector::borrow(&auids, i) != *vector::borrow(&auids, j), 0);
+                j = j + 1;
+            };
+            i = i + 1;
+        };
+    }
+
+    #[test]
+    #[expected_failure(abort_code=196609, location = Self)]
+    fun test_call_sender() {
+        // expected to fail with the error code of `invalid_state(E_TRANSACTION_CONTEXT_NOT_AVAILABLE)`
+        let _sender = sender();
+    }
+
+    #[test]
+    #[expected_failure(abort_code=196609, location = Self)]
+    fun test_call_secondary_signers() {
+        // expected to fail with the error code of `invalid_state(E_TRANSACTION_CONTEXT_NOT_AVAILABLE)`
+        let _secondary_signers = secondary_signers();
+    }
+
+    #[test]
+    #[expected_failure(abort_code=196609, location = Self)]
+    fun test_call_gas_payer() {
+        // expected to fail with the error code of `invalid_state(E_TRANSACTION_CONTEXT_NOT_AVAILABLE)`
+        let _gas_payer = gas_payer();
+    }
+
+    #[test]
+    #[expected_failure(abort_code=196609, location = Self)]
+    fun test_call_max_gas_amount() {
+        // expected to fail with the error code of `invalid_state(E_TRANSACTION_CONTEXT_NOT_AVAILABLE)`
+        let _max_gas_amount = max_gas_amount();
+    }
+
+    #[test]
+    #[expected_failure(abort_code=196609, location = Self)]
+    fun test_call_gas_unit_price() {
+        // expected to fail with the error code of `invalid_state(E_TRANSACTION_CONTEXT_NOT_AVAILABLE)`
+        let _gas_unit_price = gas_unit_price();
+    }
+
+    #[test]
+    #[expected_failure(abort_code=196609, location = Self)]
+    fun test_call_chain_id() {
+        // expected to fail with the error code of `invalid_state(E_TRANSACTION_CONTEXT_NOT_AVAILABLE)`
+        let _chain_id = chain_id();
+    }
+
+    #[test]
+    #[expected_failure(abort_code=196609, location = Self)]
+    fun test_call_entry_function_payload() {
+        // expected to fail with the error code of `invalid_state(E_TRANSACTION_CONTEXT_NOT_AVAILABLE)`
+        let _entry_fun = entry_function_payload();
+    }
+
+    #[test]
+    #[expected_failure(abort_code=196609, location = Self)]
+    fun test_call_multisig_payload() {
+        // expected to fail with the error code of `invalid_state(E_TRANSACTION_CONTEXT_NOT_AVAILABLE)`
+        let _multisig = multisig_payload();
+    }
+}