@aptos-labs/ts-sdk 1.35.0-zeta.2 → 1.36.0

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

@@ -1,147 +0,0 @@
-/// This module allows users to deploy, upgrade and freeze modules deployed to objects on-chain.
-/// This enables users to deploy modules to an object with a unique address each time they are published.
-/// This modules provides an alternative method to publish code on-chain, where code is deployed to objects rather than accounts.
-/// This is encouraged as it abstracts the necessary resources needed for deploying modules,
-/// along with the required authorization to upgrade and freeze modules.
-///
-/// The functionalities of this module are as follows.
-///
-/// Publishing modules flow:
-/// 1. Create a new object with the address derived from the publisher address and the object seed.
-/// 2. Publish the module passed in the function via `metadata_serialized` and `code` to the newly created object.
-/// 3. Emits 'Publish' event with the address of the newly created object.
-/// 4. Create a `ManagingRefs` which stores the extend ref of the newly created object.
-/// Note: This is needed to upgrade the code as the signer must be generated to upgrade the existing code in an object.
-///
-/// Upgrading modules flow:
-/// 1. Assert the `code_object` passed in the function is owned by the `publisher`.
-/// 2. Assert the `code_object` passed in the function exists in global storage.
-/// 2. Retrieve the `ExtendRef` from the `code_object` and generate the signer from this.
-/// 3. Upgrade the module with the `metadata_serialized` and `code` passed in the function.
-/// 4. Emits 'Upgrade' event with the address of the object with the upgraded code.
-/// Note: If the modules were deployed as immutable when calling `publish`, the upgrade will fail.
-///
-/// Freezing modules flow:
-/// 1. Assert the `code_object` passed in the function exists in global storage.
-/// 2. Assert the `code_object` passed in the function is owned by the `publisher`.
-/// 3. Mark all the modules in the `code_object` as immutable.
-/// 4. Emits 'Freeze' event with the address of the object with the frozen code.
-/// Note: There is no unfreeze function as this gives no benefit if the user can freeze/unfreeze modules at will.
-///       Once modules are marked as immutable, they cannot be made mutable again.
-module aptos_framework::object_code_deployment {
-    use std::bcs;
-    use std::error;
-    use std::features;
-    use std::signer;
-    use std::vector;
-    use aptos_framework::account;
-    use aptos_framework::code;
-    use aptos_framework::code::PackageRegistry;
-    use aptos_framework::event;
-    use aptos_framework::object;
-    use aptos_framework::object::{ExtendRef, Object};
-
-    /// Object code deployment feature not supported.
-    const EOBJECT_CODE_DEPLOYMENT_NOT_SUPPORTED: u64 = 1;
-    /// Not the owner of the `code_object`
-    const ENOT_CODE_OBJECT_OWNER: u64 = 2;
-    /// `code_object` does not exist.
-    const ECODE_OBJECT_DOES_NOT_EXIST: u64 = 3;
-
-    const OBJECT_CODE_DEPLOYMENT_DOMAIN_SEPARATOR: vector<u8> = b"aptos_framework::object_code_deployment";
-
-    #[resource_group_member(group = aptos_framework::object::ObjectGroup)]
-    /// Internal struct, attached to the object, that holds Refs we need to manage the code deployment (i.e. upgrades).
-    struct ManagingRefs has key {
-        /// We need to keep the extend ref to be able to generate the signer to upgrade existing code.
-        extend_ref: ExtendRef,
-    }
-
-    #[event]
-    /// Event emitted when code is published to an object.
-    struct Publish has drop, store {
-        object_address: address,
-    }
-
-    #[event]
-    /// Event emitted when code in an existing object is upgraded.
-    struct Upgrade has drop, store {
-        object_address: address,
-    }
-
-    #[event]
-    /// Event emitted when code in an existing object is made immutable.
-    struct Freeze has drop, store {
-        object_address: address,
-    }
-
-    /// Creates a new object with a unique address derived from the publisher address and the object seed.
-    /// Publishes the code passed in the function to the newly created object.
-    /// The caller must provide package metadata describing the package via `metadata_serialized` and
-    /// the code to be published via `code`. This contains a vector of modules to be deployed on-chain.
-    public entry fun publish(
-        publisher: &signer,
-        metadata_serialized: vector<u8>,
-        code: vector<vector<u8>>,
-    ) {
-        assert!(
-            features::is_object_code_deployment_enabled(),
-            error::unavailable(EOBJECT_CODE_DEPLOYMENT_NOT_SUPPORTED),
-        );
-
-        let publisher_address = signer::address_of(publisher);
-        let object_seed = object_seed(publisher_address);
-        let constructor_ref = &object::create_named_object(publisher, object_seed);
-        let code_signer = &object::generate_signer(constructor_ref);
-        code::publish_package_txn(code_signer, metadata_serialized, code);
-
-        event::emit(Publish { object_address: signer::address_of(code_signer), });
-
-        move_to(code_signer, ManagingRefs {
-            extend_ref: object::generate_extend_ref(constructor_ref),
-        });
-    }
-
-    inline fun object_seed(publisher: address): vector<u8> {
-        let sequence_number = account::get_sequence_number(publisher) + 1;
-        let seeds = vector[];
-        vector::append(&mut seeds, bcs::to_bytes(&OBJECT_CODE_DEPLOYMENT_DOMAIN_SEPARATOR));
-        vector::append(&mut seeds, bcs::to_bytes(&sequence_number));
-        seeds
-    }
-
-    /// Upgrades the existing modules at the `code_object` address with the new modules passed in `code`,
-    /// along with the metadata `metadata_serialized`.
-    /// Note: If the modules were deployed as immutable when calling `publish`, the upgrade will fail.
-    /// Requires the publisher to be the owner of the `code_object`.
-    public entry fun upgrade(
-        publisher: &signer,
-        metadata_serialized: vector<u8>,
-        code: vector<vector<u8>>,
-        code_object: Object<PackageRegistry>,
-    ) acquires ManagingRefs {
-        let publisher_address = signer::address_of(publisher);
-        assert!(
-            object::is_owner(code_object, publisher_address),
-            error::permission_denied(ENOT_CODE_OBJECT_OWNER),
-        );
-
-        let code_object_address = object::object_address(&code_object);
-        assert!(exists<ManagingRefs>(code_object_address), error::not_found(ECODE_OBJECT_DOES_NOT_EXIST));
-
-        let extend_ref = &borrow_global<ManagingRefs>(code_object_address).extend_ref;
-        let code_signer = &object::generate_signer_for_extending(extend_ref);
-        code::publish_package_txn(code_signer, metadata_serialized, code);
-
-        event::emit(Upgrade { object_address: signer::address_of(code_signer), });
-    }
-
-    /// Make an existing upgradable package immutable. Once this is called, the package cannot be made upgradable again.
-    /// Each `code_object` should only have one package, as one package is deployed per object in this module.
-    /// Requires the `publisher` to be the owner of the `code_object`.
-    public entry fun freeze_code_object(publisher: &signer, code_object: Object<PackageRegistry>) {
-        code::freeze_code_object(publisher, code_object);
-
-        event::emit(Freeze { object_address: object::object_address(&code_object), });
-    }
-}

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

@@ -1,295 +0,0 @@
-/// This module provides an interface to aggregate integers either via
-/// aggregator (parallelizable) or via normal integers.
-module aptos_framework::optional_aggregator {
-    use std::error;
-    use std::option::{Self, Option};
-
-    use aptos_framework::aggregator_factory;
-    use aptos_framework::aggregator::{Self, Aggregator};
-
-    friend aptos_framework::coin;
-    friend aptos_framework::fungible_asset;
-
-    /// The value of aggregator underflows (goes below zero). Raised by native code.
-    const EAGGREGATOR_OVERFLOW: u64 = 1;
-
-    /// Aggregator feature is not supported. Raised by native code.
-    const EAGGREGATOR_UNDERFLOW: u64 = 2;
-
-    /// Wrapper around integer with a custom overflow limit. Supports add, subtract and read just like `Aggregator`.
-    struct Integer has store {
-        value: u128,
-        limit: u128,
-    }
-
-    /// Creates a new integer which overflows on exceeding a `limit`.
-    fun new_integer(limit: u128): Integer {
-        Integer {
-            value: 0,
-            limit,
-        }
-    }
-
-    /// Adds `value` to integer. Aborts on overflowing the limit.
-    fun add_integer(integer: &mut Integer, value: u128) {
-        assert!(
-            value <= (integer.limit - integer.value),
-            error::out_of_range(EAGGREGATOR_OVERFLOW)
-        );
-        integer.value = integer.value + value;
-    }
-
-    /// Subtracts `value` from integer. Aborts on going below zero.
-    fun sub_integer(integer: &mut Integer, value: u128) {
-        assert!(value <= integer.value, error::out_of_range(EAGGREGATOR_UNDERFLOW));
-        integer.value = integer.value - value;
-    }
-
-    /// Returns an overflow limit of integer.
-    fun limit(integer: &Integer): u128 {
-        integer.limit
-    }
-
-    /// Returns a value stored in this integer.
-    fun read_integer(integer: &Integer): u128 {
-        integer.value
-    }
-
-    /// Destroys an integer.
-    fun destroy_integer(integer: Integer) {
-        let Integer { value: _, limit: _ } = integer;
-    }
-
-    /// Contains either an aggregator or a normal integer, both overflowing on limit.
-    struct OptionalAggregator has store {
-        // Parallelizable.
-        aggregator: Option<Aggregator>,
-        // Non-parallelizable.
-        integer: Option<Integer>,
-    }
-
-    /// Creates a new optional aggregator.
-    public(friend) fun new(limit: u128, parallelizable: bool): OptionalAggregator {
-        if (parallelizable) {
-            OptionalAggregator {
-                aggregator: option::some(aggregator_factory::create_aggregator_internal(limit)),
-                integer: option::none(),
-            }
-        } else {
-            OptionalAggregator {
-                aggregator: option::none(),
-                integer: option::some(new_integer(limit)),
-            }
-        }
-    }
-
-    /// Switches between parallelizable and non-parallelizable implementations.
-    public fun switch(optional_aggregator: &mut OptionalAggregator) {
-        let value = read(optional_aggregator);
-        switch_and_zero_out(optional_aggregator);
-        add(optional_aggregator, value);
-    }
-
-    /// Switches between parallelizable and non-parallelizable implementations, setting
-    /// the value of the new optional aggregator to zero.
-    fun switch_and_zero_out(optional_aggregator: &mut OptionalAggregator) {
-        if (is_parallelizable(optional_aggregator)) {
-            switch_to_integer_and_zero_out(optional_aggregator);
-        } else {
-            switch_to_aggregator_and_zero_out(optional_aggregator);
-        }
-    }
-
-    /// Switches from parallelizable to non-parallelizable implementation, zero-initializing
-    /// the value.
-    fun switch_to_integer_and_zero_out(
-        optional_aggregator: &mut OptionalAggregator
-    ): u128 {
-        let aggregator = option::extract(&mut optional_aggregator.aggregator);
-        let limit = aggregator::limit(&aggregator);
-        aggregator::destroy(aggregator);
-        let integer = new_integer(limit);
-        option::fill(&mut optional_aggregator.integer, integer);
-        limit
-    }
-
-    /// Switches from non-parallelizable to parallelizable implementation, zero-initializing
-    /// the value.
-    fun switch_to_aggregator_and_zero_out(
-        optional_aggregator: &mut OptionalAggregator
-    ): u128 {
-        let integer = option::extract(&mut optional_aggregator.integer);
-        let limit = limit(&integer);
-        destroy_integer(integer);
-        let aggregator = aggregator_factory::create_aggregator_internal(limit);
-        option::fill(&mut optional_aggregator.aggregator, aggregator);
-        limit
-    }
-
-    /// Destroys optional aggregator.
-    public fun destroy(optional_aggregator: OptionalAggregator) {
-        if (is_parallelizable(&optional_aggregator)) {
-            destroy_optional_aggregator(optional_aggregator);
-        } else {
-            destroy_optional_integer(optional_aggregator);
-        }
-    }
-
-    /// Destroys parallelizable optional aggregator and returns its limit.
-    fun destroy_optional_aggregator(optional_aggregator: OptionalAggregator): u128 {
-        let OptionalAggregator { aggregator, integer } = optional_aggregator;
-        let limit = aggregator::limit(option::borrow(&aggregator));
-        aggregator::destroy(option::destroy_some(aggregator));
-        option::destroy_none(integer);
-        limit
-    }
-
-    /// Destroys non-parallelizable optional aggregator and returns its limit.
-    fun destroy_optional_integer(optional_aggregator: OptionalAggregator): u128 {
-        let OptionalAggregator { aggregator, integer } = optional_aggregator;
-        let limit = limit(option::borrow(&integer));
-        destroy_integer(option::destroy_some(integer));
-        option::destroy_none(aggregator);
-        limit
-    }
-
-    /// Adds `value` to optional aggregator, aborting on exceeding the `limit`.
-    public fun add(optional_aggregator: &mut OptionalAggregator, value: u128) {
-        if (option::is_some(&optional_aggregator.aggregator)) {
-            let aggregator = option::borrow_mut(&mut optional_aggregator.aggregator);
-            aggregator::add(aggregator, value);
-        } else {
-            let integer = option::borrow_mut(&mut optional_aggregator.integer);
-            add_integer(integer, value);
-        }
-    }
-
-    /// Subtracts `value` from optional aggregator, aborting on going below zero.
-    public fun sub(optional_aggregator: &mut OptionalAggregator, value: u128) {
-        if (option::is_some(&optional_aggregator.aggregator)) {
-            let aggregator = option::borrow_mut(&mut optional_aggregator.aggregator);
-            aggregator::sub(aggregator, value);
-        } else {
-            let integer = option::borrow_mut(&mut optional_aggregator.integer);
-            sub_integer(integer, value);
-        }
-    }
-
-    /// Returns the value stored in optional aggregator.
-    public fun read(optional_aggregator: &OptionalAggregator): u128 {
-        if (option::is_some(&optional_aggregator.aggregator)) {
-            let aggregator = option::borrow(&optional_aggregator.aggregator);
-            aggregator::read(aggregator)
-        } else {
-            let integer = option::borrow(&optional_aggregator.integer);
-            read_integer(integer)
-        }
-    }
-
-    /// Returns true if optional aggregator uses parallelizable implementation.
-    public fun is_parallelizable(optional_aggregator: &OptionalAggregator): bool {
-        option::is_some(&optional_aggregator.aggregator)
-    }
-
-    #[test(account = @aptos_framework)]
-    fun optional_aggregator_test(account: signer) {
-        aggregator_factory::initialize_aggregator_factory(&account);
-
-        let aggregator = new(30, false);
-        assert!(!is_parallelizable(&aggregator), 0);
-
-        add(&mut aggregator, 12);
-        add(&mut aggregator, 3);
-        assert!(read(&aggregator) == 15, 0);
-
-        sub(&mut aggregator, 10);
-        assert!(read(&aggregator) == 5, 0);
-
-        // Switch to parallelizable aggregator and check the value is preserved.
-        switch(&mut aggregator);
-        assert!(is_parallelizable(&aggregator), 0);
-        assert!(read(&aggregator) == 5, 0);
-
-        add(&mut aggregator, 12);
-        add(&mut aggregator, 3);
-        assert!(read(&aggregator) == 20, 0);
-
-        sub(&mut aggregator, 10);
-        assert!(read(&aggregator) == 10, 0);
-
-        // Switch back!
-        switch(&mut aggregator);
-        assert!(!is_parallelizable(&aggregator), 0);
-        assert!(read(&aggregator) == 10, 0);
-
-        destroy(aggregator);
-    }
-
-    #[test(account = @aptos_framework)]
-    fun optional_aggregator_destroy_test(account: signer) {
-        aggregator_factory::initialize_aggregator_factory(&account);
-
-        let aggregator = new(30, false);
-        destroy(aggregator);
-
-        let aggregator = new(30, true);
-        destroy(aggregator);
-
-        let aggregator = new(12, false);
-        assert!(destroy_optional_integer(aggregator) == 12, 0);
-
-        let aggregator = new(21, true);
-        assert!(destroy_optional_aggregator(aggregator) == 21, 0);
-    }
-
-    #[test(account = @aptos_framework)]
-    #[expected_failure(abort_code = 0x020001, location = Self)]
-    fun non_parallelizable_aggregator_overflow_test(account: signer) {
-        aggregator_factory::initialize_aggregator_factory(&account);
-        let aggregator = new(15, false);
-
-        // Overflow!
-        add(&mut aggregator, 16);
-
-        destroy(aggregator);
-    }
-
-    #[test(account = @aptos_framework)]
-    #[expected_failure(abort_code = 0x020002, location = Self)]
-    fun non_parallelizable_aggregator_underflow_test(account: signer) {
-        aggregator_factory::initialize_aggregator_factory(&account);
-        let aggregator = new(100, false);
-
-        // Underflow!
-        sub(&mut aggregator, 100);
-        add(&mut aggregator, 100);
-
-        destroy(aggregator);
-    }
-
-    #[test(account = @aptos_framework)]
-    #[expected_failure(abort_code = 0x020001, location = aptos_framework::aggregator)]
-    fun parallelizable_aggregator_overflow_test(account: signer) {
-        aggregator_factory::initialize_aggregator_factory(&account);
-        let aggregator = new(15, true);
-
-        // Overflow!
-        add(&mut aggregator, 16);
-
-        destroy(aggregator);
-    }
-
-    #[test(account = @aptos_framework)]
-    #[expected_failure(abort_code = 0x020002, location = aptos_framework::aggregator)]
-    fun parallelizable_aggregator_underflow_test(account: signer) {
-        aggregator_factory::initialize_aggregator_factory(&account);
-        let aggregator = new(100, true);
-
-        // Underflow!
-        add(&mut aggregator, 99);
-        sub(&mut aggregator, 100);
-        add(&mut aggregator, 100);
-
-        destroy(aggregator);
-    }
-}