@aptos-labs/ts-sdk 1.26.0 → 1.27.1-zeta.0

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

@@ -0,0 +1,367 @@
+/// This module supports functionality related to code management.
+module aptos_framework::code {
+    use std::string::String;
+    use std::error;
+    use std::signer;
+    use std::vector;
+    use std::features;
+
+    use aptos_framework::util;
+    use aptos_framework::system_addresses;
+    use aptos_std::copyable_any::Any;
+    use std::option::Option;
+    use std::string;
+    use aptos_framework::event;
+    use aptos_framework::object::{Self, Object};
+
+    // ----------------------------------------------------------------------
+    // Code Publishing
+
+    /// The package registry at the given address.
+    struct PackageRegistry has key, store, drop {
+        /// Packages installed at this address.
+        packages: vector<PackageMetadata>,
+    }
+
+    /// Metadata for a package. All byte blobs are represented as base64-of-gzipped-bytes
+    struct PackageMetadata has copy, drop, store {
+        /// Name of this package.
+        name: String,
+        /// The upgrade policy of this package.
+        upgrade_policy: UpgradePolicy,
+        /// The numbers of times this module has been upgraded. Also serves as the on-chain version.
+        /// This field will be automatically assigned on successful upgrade.
+        upgrade_number: u64,
+        /// The source digest of the sources in the package. This is constructed by first building the
+        /// sha256 of each individual source, than sorting them alphabetically, and sha256 them again.
+        source_digest: String,
+        /// The package manifest, in the Move.toml format. Gzipped text.
+        manifest: vector<u8>,
+        /// The list of modules installed by this package.
+        modules: vector<ModuleMetadata>,
+        /// Holds PackageDeps.
+        deps: vector<PackageDep>,
+        /// For future extension
+        extension: Option<Any>
+    }
+
+    /// A dependency to a package published at address
+    struct PackageDep has store, drop, copy {
+        account: address,
+        package_name: String
+    }
+
+    /// Metadata about a module in a package.
+    struct ModuleMetadata has copy, drop, store {
+        /// Name of the module.
+        name: String,
+        /// Source text, gzipped String. Empty if not provided.
+        source: vector<u8>,
+        /// Source map, in compressed BCS. Empty if not provided.
+        source_map: vector<u8>,
+        /// For future extensions.
+        extension: Option<Any>,
+    }
+
+    /// Describes an upgrade policy
+    struct UpgradePolicy has store, copy, drop {
+        policy: u8
+    }
+
+    #[event]
+    /// Event emitted when code is published to an address.
+    struct PublishPackage has drop, store {
+        code_address: address,
+        is_upgrade: bool,
+    }
+
+    /// Package contains duplicate module names with existing modules publised in other packages on this address
+    const EMODULE_NAME_CLASH: u64 = 0x1;
+
+    /// Cannot upgrade an immutable package
+    const EUPGRADE_IMMUTABLE: u64 = 0x2;
+
+    /// Cannot downgrade a package's upgradability policy
+    const EUPGRADE_WEAKER_POLICY: u64 = 0x3;
+
+    /// Cannot delete a module that was published in the same package
+    const EMODULE_MISSING: u64 = 0x4;
+
+    /// Dependency could not be resolved to any published package.
+    const EPACKAGE_DEP_MISSING: u64 = 0x5;
+
+    /// A dependency cannot have a weaker upgrade policy.
+    const EDEP_WEAKER_POLICY: u64 = 0x6;
+
+    /// A dependency to an `arbitrary` package must be on the same address.
+    const EDEP_ARBITRARY_NOT_SAME_ADDRESS: u64 = 0x7;
+
+    /// Creating a package with incompatible upgrade policy is disabled.
+    const EINCOMPATIBLE_POLICY_DISABLED: u64 = 0x8;
+
+    /// Not the owner of the package registry.
+    const ENOT_PACKAGE_OWNER: u64 = 0x9;
+
+    /// `code_object` does not exist.
+    const ECODE_OBJECT_DOES_NOT_EXIST: u64 = 0xA;
+
+    /// Whether unconditional code upgrade with no compatibility check is allowed. This
+    /// publication mode should only be used for modules which aren't shared with user others.
+    /// The developer is responsible for not breaking memory layout of any resources he already
+    /// stored on chain.
+    public fun upgrade_policy_arbitrary(): UpgradePolicy {
+        UpgradePolicy { policy: 0 }
+    }
+
+    /// Whether a compatibility check should be performed for upgrades. The check only passes if
+    /// a new module has (a) the same public functions (b) for existing resources, no layout change.
+    public fun upgrade_policy_compat(): UpgradePolicy {
+        UpgradePolicy { policy: 1 }
+    }
+
+    /// Whether the modules in the package are immutable and cannot be upgraded.
+    public fun upgrade_policy_immutable(): UpgradePolicy {
+        UpgradePolicy { policy: 2 }
+    }
+
+    /// Whether the upgrade policy can be changed. In general, the policy can be only
+    /// strengthened but not weakened.
+    public fun can_change_upgrade_policy_to(from: UpgradePolicy, to: UpgradePolicy): bool {
+        from.policy <= to.policy
+    }
+
+    /// Initialize package metadata for Genesis.
+    fun initialize(aptos_framework: &signer, package_owner: &signer, metadata: PackageMetadata)
+    acquires PackageRegistry {
+        system_addresses::assert_aptos_framework(aptos_framework);
+        let addr = signer::address_of(package_owner);
+        if (!exists<PackageRegistry>(addr)) {
+            move_to(package_owner, PackageRegistry { packages: vector[metadata] })
+        } else {
+            vector::push_back(&mut borrow_global_mut<PackageRegistry>(addr).packages, metadata)
+        }
+    }
+
+    /// Publishes a package at the given signer's address. The caller must provide package metadata describing the
+    /// package.
+    public fun publish_package(owner: &signer, pack: PackageMetadata, code: vector<vector<u8>>) acquires PackageRegistry {
+        // Disallow incompatible upgrade mode. Governance can decide later if this should be reconsidered.
+        assert!(
+            pack.upgrade_policy.policy > upgrade_policy_arbitrary().policy,
+            error::invalid_argument(EINCOMPATIBLE_POLICY_DISABLED),
+        );
+
+        let addr = signer::address_of(owner);
+        if (!exists<PackageRegistry>(addr)) {
+            move_to(owner, PackageRegistry { packages: vector::empty() })
+        };
+
+        // Checks for valid dependencies to other packages
+        let allowed_deps = check_dependencies(addr, &pack);
+
+        // Check package against conflicts
+        // To avoid prover compiler error on spec
+        // the package need to be an immutable variable
+        let module_names = get_module_names(&pack);
+        let package_immutable = &borrow_global<PackageRegistry>(addr).packages;
+        let len = vector::length(package_immutable);
+        let index = len;
+        let upgrade_number = 0;
+        vector::enumerate_ref(package_immutable
+        , |i, old| {
+            let old: &PackageMetadata = old;
+            if (old.name == pack.name) {
+                upgrade_number = old.upgrade_number + 1;
+                check_upgradability(old, &pack, &module_names);
+                index = i;
+            } else {
+                check_coexistence(old, &module_names)
+            };
+        });
+
+        // Assign the upgrade counter.
+        pack.upgrade_number = upgrade_number;
+
+        let packages = &mut borrow_global_mut<PackageRegistry>(addr).packages;
+        // Update registry
+        let policy = pack.upgrade_policy;
+        if (index < len) {
+            *vector::borrow_mut(packages, index) = pack
+        } else {
+            vector::push_back(packages, pack)
+        };
+
+        event::emit(PublishPackage {
+            code_address: addr,
+            is_upgrade: upgrade_number > 0
+        });
+
+        // Request publish
+        if (features::code_dependency_check_enabled())
+            request_publish_with_allowed_deps(addr, module_names, allowed_deps, code, policy.policy)
+        else
+        // The new `request_publish_with_allowed_deps` has not yet rolled out, so call downwards
+        // compatible code.
+            request_publish(addr, module_names, code, policy.policy)
+    }
+
+    public fun freeze_code_object(publisher: &signer, code_object: Object<PackageRegistry>) acquires PackageRegistry {
+        let code_object_addr = object::object_address(&code_object);
+        assert!(exists<PackageRegistry>(code_object_addr), error::not_found(ECODE_OBJECT_DOES_NOT_EXIST));
+        assert!(
+            object::is_owner(code_object, signer::address_of(publisher)),
+            error::permission_denied(ENOT_PACKAGE_OWNER)
+        );
+
+        let registry = borrow_global_mut<PackageRegistry>(code_object_addr);
+        vector::for_each_mut(&mut registry.packages, |pack| {
+            let package: &mut PackageMetadata = pack;
+            package.upgrade_policy = upgrade_policy_immutable();
+        });
+
+        // We unfortunately have to make a copy of each package to avoid borrow checker issues as check_dependencies
+        // needs to borrow PackageRegistry from the dependency packages.
+        // This would increase the amount of gas used, but this is a rare operation and it's rare to have many packages
+        // in a single code object.
+        vector::for_each(registry.packages, |pack| {
+            check_dependencies(code_object_addr, &pack);
+        });
+    }
+
+    /// Same as `publish_package` but as an entry function which can be called as a transaction. Because
+    /// of current restrictions for txn parameters, the metadata needs to be passed in serialized form.
+    public entry fun publish_package_txn(owner: &signer, metadata_serialized: vector<u8>, code: vector<vector<u8>>)
+    acquires PackageRegistry {
+        publish_package(owner, util::from_bytes<PackageMetadata>(metadata_serialized), code)
+    }
+
+    // Helpers
+    // -------
+
+    /// Checks whether the given package is upgradable, and returns true if a compatibility check is needed.
+    fun check_upgradability(
+        old_pack: &PackageMetadata, new_pack: &PackageMetadata, new_modules: &vector<String>) {
+        assert!(old_pack.upgrade_policy.policy < upgrade_policy_immutable().policy,
+            error::invalid_argument(EUPGRADE_IMMUTABLE));
+        assert!(can_change_upgrade_policy_to(old_pack.upgrade_policy, new_pack.upgrade_policy),
+            error::invalid_argument(EUPGRADE_WEAKER_POLICY));
+        let old_modules = get_module_names(old_pack);
+
+        vector::for_each_ref(&old_modules, |old_module| {
+            assert!(
+                vector::contains(new_modules, old_module),
+                EMODULE_MISSING
+            );
+        });
+    }
+
+    /// Checks whether a new package with given names can co-exist with old package.
+    fun check_coexistence(old_pack: &PackageMetadata, new_modules: &vector<String>) {
+        // The modules introduced by each package must not overlap with `names`.
+        vector::for_each_ref(&old_pack.modules, |old_mod| {
+            let old_mod: &ModuleMetadata = old_mod;
+            let j = 0;
+            while (j < vector::length(new_modules)) {
+                let name = vector::borrow(new_modules, j);
+                assert!(&old_mod.name != name, error::already_exists(EMODULE_NAME_CLASH));
+                j = j + 1;
+            };
+        });
+    }
+
+    /// Check that the upgrade policies of all packages are equal or higher quality than this package. Also
+    /// compute the list of module dependencies which are allowed by the package metadata. The later
+    /// is passed on to the native layer to verify that bytecode dependencies are actually what is pretended here.
+    fun check_dependencies(publish_address: address, pack: &PackageMetadata): vector<AllowedDep>
+    acquires PackageRegistry {
+        let allowed_module_deps = vector::empty();
+        let deps = &pack.deps;
+        vector::for_each_ref(deps, |dep| {
+            let dep: &PackageDep = dep;
+            assert!(exists<PackageRegistry>(dep.account), error::not_found(EPACKAGE_DEP_MISSING));
+            if (is_policy_exempted_address(dep.account)) {
+                // Allow all modules from this address, by using "" as a wildcard in the AllowedDep
+                let account: address = dep.account;
+                let module_name = string::utf8(b"");
+                vector::push_back(&mut allowed_module_deps, AllowedDep { account, module_name });
+            } else {
+                let registry = borrow_global<PackageRegistry>(dep.account);
+                let found = vector::any(&registry.packages, |dep_pack| {
+                    let dep_pack: &PackageMetadata = dep_pack;
+                    if (dep_pack.name == dep.package_name) {
+                        // Check policy
+                        assert!(
+                            dep_pack.upgrade_policy.policy >= pack.upgrade_policy.policy,
+                            error::invalid_argument(EDEP_WEAKER_POLICY)
+                        );
+                        if (dep_pack.upgrade_policy == upgrade_policy_arbitrary()) {
+                            assert!(
+                                dep.account == publish_address,
+                                error::invalid_argument(EDEP_ARBITRARY_NOT_SAME_ADDRESS)
+                            )
+                        };
+                        // Add allowed deps
+                        let account = dep.account;
+                        let k = 0;
+                        let r = vector::length(&dep_pack.modules);
+                        while (k < r) {
+                            let module_name = vector::borrow(&dep_pack.modules, k).name;
+                            vector::push_back(&mut allowed_module_deps, AllowedDep { account, module_name });
+                            k = k + 1;
+                        };
+                        true
+                    } else {
+                        false
+                    }
+                });
+                assert!(found, error::not_found(EPACKAGE_DEP_MISSING));
+            };
+        });
+        allowed_module_deps
+    }
+
+    /// Core addresses which are exempted from the check that their policy matches the referring package. Without
+    /// this exemption, it would not be possible to define an immutable package based on the core system, which
+    /// requires to be upgradable for maintenance and evolution, and is configured to be `compatible`.
+    fun is_policy_exempted_address(addr: address): bool {
+        addr == @1 || addr == @2 || addr == @3 || addr == @4 || addr == @5 ||
+            addr == @6 || addr == @7 || addr == @8 || addr == @9 || addr == @10
+    }
+
+    /// Get the names of the modules in a package.
+    fun get_module_names(pack: &PackageMetadata): vector<String> {
+        let module_names = vector::empty();
+        vector::for_each_ref(&pack.modules, |pack_module| {
+            let pack_module: &ModuleMetadata = pack_module;
+            vector::push_back(&mut module_names, pack_module.name);
+        });
+        module_names
+    }
+
+    /// Native function to initiate module loading
+    native fun request_publish(
+        owner: address,
+        expected_modules: vector<String>,
+        bundle: vector<vector<u8>>,
+        policy: u8
+    );
+
+    /// A helper type for request_publish_with_allowed_deps
+    struct AllowedDep has drop {
+        /// Address of the module.
+        account: address,
+        /// Name of the module. If this is the empty string, then this serves as a wildcard for
+        /// all modules from this address. This is used for speeding up dependency checking for packages from
+        /// well-known framework addresses, where we can assume that there are no malicious packages.
+        module_name: String
+    }
+
+    /// Native function to initiate module loading, including a list of allowed dependencies.
+    native fun request_publish_with_allowed_deps(
+        owner: address,
+        expected_modules: vector<String>,
+        allowed_deps: vector<AllowedDep>,
+        bundle: vector<vector<u8>>,
+        policy: u8
+    );
+}