@aptos-labs/ts-sdk 1.28.0-zeta.7 → 1.28.0-zeta.8

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

@@ -0,0 +1,147 @@
+/// 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

@@ -0,0 +1,295 @@
+/// 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);
+    }
+}