@aptos-labs/ts-sdk 3.1.0 → 3.1.1

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

@@ -1,550 +0,0 @@
-module aptos_framework::genesis {
-    use std::error;
-    use std::fixed_point32;
-    use std::vector;
-
-    use aptos_std::simple_map;
-
-    use aptos_framework::account;
-    use aptos_framework::aggregator_factory;
-    use aptos_framework::aptos_account;
-    use aptos_framework::aptos_coin::{Self, AptosCoin};
-    use aptos_framework::aptos_governance;
-    use aptos_framework::block;
-    use aptos_framework::chain_id;
-    use aptos_framework::chain_status;
-    use aptos_framework::coin;
-    use aptos_framework::consensus_config;
-    use aptos_framework::execution_config;
-    use aptos_framework::create_signer::create_signer;
-    use aptos_framework::gas_schedule;
-    use aptos_framework::reconfiguration;
-    use aptos_framework::stake;
-    use aptos_framework::staking_contract;
-    use aptos_framework::staking_config;
-    use aptos_framework::state_storage;
-    use aptos_framework::storage_gas;
-    use aptos_framework::timestamp;
-    use aptos_framework::transaction_fee;
-    use aptos_framework::transaction_validation;
-    use aptos_framework::version;
-    use aptos_framework::vesting;
-
-    const EDUPLICATE_ACCOUNT: u64 = 1;
-    const EACCOUNT_DOES_NOT_EXIST: u64 = 2;
-
-    struct AccountMap has drop {
-        account_address: address,
-        balance: u64,
-    }
-
-    struct EmployeeAccountMap has copy, drop {
-        accounts: vector<address>,
-        validator: ValidatorConfigurationWithCommission,
-        vesting_schedule_numerator: vector<u64>,
-        vesting_schedule_denominator: u64,
-        beneficiary_resetter: address,
-    }
-
-    struct ValidatorConfiguration has copy, drop {
-        owner_address: address,
-        operator_address: address,
-        voter_address: address,
-        stake_amount: u64,
-        consensus_pubkey: vector<u8>,
-        proof_of_possession: vector<u8>,
-        network_addresses: vector<u8>,
-        full_node_network_addresses: vector<u8>,
-    }
-
-    struct ValidatorConfigurationWithCommission has copy, drop {
-        validator_config: ValidatorConfiguration,
-        commission_percentage: u64,
-        join_during_genesis: bool,
-    }
-
-    /// Genesis step 1: Initialize aptos framework account and core modules on chain.
-    fun initialize(
-        gas_schedule: vector<u8>,
-        chain_id: u8,
-        initial_version: u64,
-        consensus_config: vector<u8>,
-        execution_config: vector<u8>,
-        epoch_interval_microsecs: u64,
-        minimum_stake: u64,
-        maximum_stake: u64,
-        recurring_lockup_duration_secs: u64,
-        allow_validator_set_change: bool,
-        rewards_rate: u64,
-        rewards_rate_denominator: u64,
-        voting_power_increase_limit: u64,
-    ) {
-        // Initialize the aptos framework account. This is the account where system resources and modules will be
-        // deployed to. This will be entirely managed by on-chain governance and no entities have the key or privileges
-        // to use this account.
-        let (aptos_framework_account, aptos_framework_signer_cap) = account::create_framework_reserved_account(@aptos_framework);
-        // Initialize account configs on aptos framework account.
-        account::initialize(&aptos_framework_account);
-
-        transaction_validation::initialize(
-            &aptos_framework_account,
-            b"script_prologue",
-            b"module_prologue",
-            b"multi_agent_script_prologue",
-            b"epilogue",
-        );
-
-        // Give the decentralized on-chain governance control over the core framework account.
-        aptos_governance::store_signer_cap(&aptos_framework_account, @aptos_framework, aptos_framework_signer_cap);
-
-        // put reserved framework reserved accounts under aptos governance
-        let framework_reserved_addresses = vector<address>[@0x2, @0x3, @0x4, @0x5, @0x6, @0x7, @0x8, @0x9, @0xa];
-        while (!vector::is_empty(&framework_reserved_addresses)) {
-            let address = vector::pop_back<address>(&mut framework_reserved_addresses);
-            let (_, framework_signer_cap) = account::create_framework_reserved_account(address);
-            aptos_governance::store_signer_cap(&aptos_framework_account, address, framework_signer_cap);
-        };
-
-        consensus_config::initialize(&aptos_framework_account, consensus_config);
-        execution_config::set(&aptos_framework_account, execution_config);
-        version::initialize(&aptos_framework_account, initial_version);
-        stake::initialize(&aptos_framework_account);
-        staking_config::initialize(
-            &aptos_framework_account,
-            minimum_stake,
-            maximum_stake,
-            recurring_lockup_duration_secs,
-            allow_validator_set_change,
-            rewards_rate,
-            rewards_rate_denominator,
-            voting_power_increase_limit,
-        );
-        storage_gas::initialize(&aptos_framework_account);
-        gas_schedule::initialize(&aptos_framework_account, gas_schedule);
-
-        // Ensure we can create aggregators for supply, but not enable it for common use just yet.
-        aggregator_factory::initialize_aggregator_factory(&aptos_framework_account);
-        coin::initialize_supply_config(&aptos_framework_account);
-
-        chain_id::initialize(&aptos_framework_account, chain_id);
-        reconfiguration::initialize(&aptos_framework_account);
-        block::initialize(&aptos_framework_account, epoch_interval_microsecs);
-        state_storage::initialize(&aptos_framework_account);
-        timestamp::set_time_has_started(&aptos_framework_account);
-    }
-
-    /// Genesis step 2: Initialize Aptos coin.
-    fun initialize_aptos_coin(aptos_framework: &signer) {
-        let (burn_cap, mint_cap) = aptos_coin::initialize(aptos_framework);
-
-        coin::create_coin_conversion_map(aptos_framework);
-        coin::create_pairing<AptosCoin>(aptos_framework);
-
-        // Give stake module MintCapability<AptosCoin> so it can mint rewards.
-        stake::store_aptos_coin_mint_cap(aptos_framework, mint_cap);
-        // Give transaction_fee module BurnCapability<AptosCoin> so it can burn gas.
-        transaction_fee::store_aptos_coin_burn_cap(aptos_framework, burn_cap);
-        // Give transaction_fee module MintCapability<AptosCoin> so it can mint refunds.
-        transaction_fee::store_aptos_coin_mint_cap(aptos_framework, mint_cap);
-    }
-
-    /// Only called for testnets and e2e tests.
-    fun initialize_core_resources_and_aptos_coin(
-        aptos_framework: &signer,
-        core_resources_auth_key: vector<u8>,
-    ) {
-        let (burn_cap, mint_cap) = aptos_coin::initialize(aptos_framework);
-
-        coin::create_coin_conversion_map(aptos_framework);
-        coin::create_pairing<AptosCoin>(aptos_framework);
-
-        // Give stake module MintCapability<AptosCoin> so it can mint rewards.
-        stake::store_aptos_coin_mint_cap(aptos_framework, mint_cap);
-        // Give transaction_fee module BurnCapability<AptosCoin> so it can burn gas.
-        transaction_fee::store_aptos_coin_burn_cap(aptos_framework, burn_cap);
-        // Give transaction_fee module MintCapability<AptosCoin> so it can mint refunds.
-        transaction_fee::store_aptos_coin_mint_cap(aptos_framework, mint_cap);
-
-        let core_resources = account::create_account(@core_resources);
-        account::rotate_authentication_key_internal(&core_resources, core_resources_auth_key);
-        aptos_account::register_apt(&core_resources); // registers APT store
-        aptos_coin::configure_accounts_for_test(aptos_framework, &core_resources, mint_cap);
-    }
-
-    fun create_accounts(aptos_framework: &signer, accounts: vector<AccountMap>) {
-        let unique_accounts = vector::empty();
-        vector::for_each_ref(&accounts, |account_map| {
-            let account_map: &AccountMap = account_map;
-            assert!(
-                !vector::contains(&unique_accounts, &account_map.account_address),
-                error::already_exists(EDUPLICATE_ACCOUNT),
-            );
-            vector::push_back(&mut unique_accounts, account_map.account_address);
-
-            create_account(
-                aptos_framework,
-                account_map.account_address,
-                account_map.balance,
-            );
-        });
-    }
-
-    /// This creates an funds an account if it doesn't exist.
-    /// If it exists, it just returns the signer.
-    fun create_account(aptos_framework: &signer, account_address: address, balance: u64): signer {
-        if (account::exists_at(account_address)) {
-            create_signer(account_address)
-        } else {
-            let account = account::create_account(account_address);
-            coin::register<AptosCoin>(&account);
-            aptos_coin::mint(aptos_framework, account_address, balance);
-            account
-        }
-    }
-
-    fun create_employee_validators(
-        employee_vesting_start: u64,
-        employee_vesting_period_duration: u64,
-        employees: vector<EmployeeAccountMap>,
-    ) {
-        let unique_accounts = vector::empty();
-
-        vector::for_each_ref(&employees, |employee_group| {
-            let j = 0;
-            let employee_group: &EmployeeAccountMap = employee_group;
-            let num_employees_in_group = vector::length(&employee_group.accounts);
-
-            let buy_ins = simple_map::create();
-
-            while (j < num_employees_in_group) {
-                let account = vector::borrow(&employee_group.accounts, j);
-                assert!(
-                    !vector::contains(&unique_accounts, account),
-                    error::already_exists(EDUPLICATE_ACCOUNT),
-                );
-                vector::push_back(&mut unique_accounts, *account);
-
-                let employee = create_signer(*account);
-                let total = coin::balance<AptosCoin>(*account);
-                let coins = coin::withdraw<AptosCoin>(&employee, total);
-                simple_map::add(&mut buy_ins, *account, coins);
-
-                j = j + 1;
-            };
-
-            let j = 0;
-            let num_vesting_events = vector::length(&employee_group.vesting_schedule_numerator);
-            let schedule = vector::empty();
-
-            while (j < num_vesting_events) {
-                let numerator = vector::borrow(&employee_group.vesting_schedule_numerator, j);
-                let event = fixed_point32::create_from_rational(*numerator, employee_group.vesting_schedule_denominator);
-                vector::push_back(&mut schedule, event);
-
-                j = j + 1;
-            };
-
-            let vesting_schedule = vesting::create_vesting_schedule(
-                schedule,
-                employee_vesting_start,
-                employee_vesting_period_duration,
-            );
-
-            let admin = employee_group.validator.validator_config.owner_address;
-            let admin_signer = &create_signer(admin);
-            let contract_address = vesting::create_vesting_contract(
-                admin_signer,
-                &employee_group.accounts,
-                buy_ins,
-                vesting_schedule,
-                admin,
-                employee_group.validator.validator_config.operator_address,
-                employee_group.validator.validator_config.voter_address,
-                employee_group.validator.commission_percentage,
-                x"",
-            );
-            let pool_address = vesting::stake_pool_address(contract_address);
-
-            if (employee_group.beneficiary_resetter != @0x0) {
-                vesting::set_beneficiary_resetter(admin_signer, contract_address, employee_group.beneficiary_resetter);
-            };
-
-            let validator = &employee_group.validator.validator_config;
-            assert!(
-                account::exists_at(validator.owner_address),
-                error::not_found(EACCOUNT_DOES_NOT_EXIST),
-            );
-            assert!(
-                account::exists_at(validator.operator_address),
-                error::not_found(EACCOUNT_DOES_NOT_EXIST),
-            );
-            assert!(
-                account::exists_at(validator.voter_address),
-                error::not_found(EACCOUNT_DOES_NOT_EXIST),
-            );
-            if (employee_group.validator.join_during_genesis) {
-                initialize_validator(pool_address, validator);
-            };
-        });
-    }
-
-    fun create_initialize_validators_with_commission(
-        aptos_framework: &signer,
-        use_staking_contract: bool,
-        validators: vector<ValidatorConfigurationWithCommission>,
-    ) {
-        vector::for_each_ref(&validators, |validator| {
-            let validator: &ValidatorConfigurationWithCommission = validator;
-            create_initialize_validator(aptos_framework, validator, use_staking_contract);
-        });
-
-        // Destroy the aptos framework account's ability to mint coins now that we're done with setting up the initial
-        // validators.
-        aptos_coin::destroy_mint_cap(aptos_framework);
-
-        stake::on_new_epoch();
-    }
-
-    /// Sets up the initial validator set for the network.
-    /// The validator "owner" accounts, and their authentication
-    /// Addresses (and keys) are encoded in the `owners`
-    /// Each validator signs consensus messages with the private key corresponding to the Ed25519
-    /// public key in `consensus_pubkeys`.
-    /// Finally, each validator must specify the network address
-    /// (see types/src/network_address/mod.rs) for itself and its full nodes.
-    ///
-    /// Network address fields are a vector per account, where each entry is a vector of addresses
-    /// encoded in a single BCS byte array.
-    fun create_initialize_validators(aptos_framework: &signer, validators: vector<ValidatorConfiguration>) {
-        let validators_with_commission = vector::empty();
-        vector::for_each_reverse(validators, |validator| {
-            let validator_with_commission = ValidatorConfigurationWithCommission {
-                validator_config: validator,
-                commission_percentage: 0,
-                join_during_genesis: true,
-            };
-            vector::push_back(&mut validators_with_commission, validator_with_commission);
-        });
-
-        create_initialize_validators_with_commission(aptos_framework, false, validators_with_commission);
-    }
-
-    fun create_initialize_validator(
-        aptos_framework: &signer,
-        commission_config: &ValidatorConfigurationWithCommission,
-        use_staking_contract: bool,
-    ) {
-        let validator = &commission_config.validator_config;
-
-        let owner = &create_account(aptos_framework, validator.owner_address, validator.stake_amount);
-        create_account(aptos_framework, validator.operator_address, 0);
-        create_account(aptos_framework, validator.voter_address, 0);
-
-        // Initialize the stake pool and join the validator set.
-        let pool_address = if (use_staking_contract) {
-            staking_contract::create_staking_contract(
-                owner,
-                validator.operator_address,
-                validator.voter_address,
-                validator.stake_amount,
-                commission_config.commission_percentage,
-                x"",
-            );
-            staking_contract::stake_pool_address(validator.owner_address, validator.operator_address)
-        } else {
-            stake::initialize_stake_owner(
-                owner,
-                validator.stake_amount,
-                validator.operator_address,
-                validator.voter_address,
-            );
-            validator.owner_address
-        };
-
-        if (commission_config.join_during_genesis) {
-            initialize_validator(pool_address, validator);
-        };
-    }
-
-    fun initialize_validator(pool_address: address, validator: &ValidatorConfiguration) {
-        let operator = &create_signer(validator.operator_address);
-
-        stake::rotate_consensus_key(
-            operator,
-            pool_address,
-            validator.consensus_pubkey,
-            validator.proof_of_possession,
-        );
-        stake::update_network_and_fullnode_addresses(
-            operator,
-            pool_address,
-            validator.network_addresses,
-            validator.full_node_network_addresses,
-        );
-        stake::join_validator_set_internal(operator, pool_address);
-    }
-
-    /// The last step of genesis.
-    fun set_genesis_end(aptos_framework: &signer) {
-        chain_status::set_genesis_end(aptos_framework);
-    }
-
-    #[verify_only]
-    use std::features;
-
-    #[verify_only]
-    fun initialize_for_verification(
-        gas_schedule: vector<u8>,
-        chain_id: u8,
-        initial_version: u64,
-        consensus_config: vector<u8>,
-        execution_config: vector<u8>,
-        epoch_interval_microsecs: u64,
-        minimum_stake: u64,
-        maximum_stake: u64,
-        recurring_lockup_duration_secs: u64,
-        allow_validator_set_change: bool,
-        rewards_rate: u64,
-        rewards_rate_denominator: u64,
-        voting_power_increase_limit: u64,
-        aptos_framework: &signer,
-        min_voting_threshold: u128,
-        required_proposer_stake: u64,
-        voting_duration_secs: u64,
-        accounts: vector<AccountMap>,
-        employee_vesting_start: u64,
-        employee_vesting_period_duration: u64,
-        employees: vector<EmployeeAccountMap>,
-        validators: vector<ValidatorConfigurationWithCommission>
-    ) {
-        initialize(
-            gas_schedule,
-            chain_id,
-            initial_version,
-            consensus_config,
-            execution_config,
-            epoch_interval_microsecs,
-            minimum_stake,
-            maximum_stake,
-            recurring_lockup_duration_secs,
-            allow_validator_set_change,
-            rewards_rate,
-            rewards_rate_denominator,
-            voting_power_increase_limit
-        );
-        features::change_feature_flags_for_verification(aptos_framework, vector[1, 2], vector[]);
-        initialize_aptos_coin(aptos_framework);
-        aptos_governance::initialize_for_verification(
-            aptos_framework,
-            min_voting_threshold,
-            required_proposer_stake,
-            voting_duration_secs
-        );
-        create_accounts(aptos_framework, accounts);
-        create_employee_validators(employee_vesting_start, employee_vesting_period_duration, employees);
-        create_initialize_validators_with_commission(aptos_framework, true, validators);
-        set_genesis_end(aptos_framework);
-    }
-
-    #[test_only]
-    public fun setup() {
-        initialize(
-            x"000000000000000000", // empty gas schedule
-            4u8, // TESTING chain ID
-            0,
-            x"12",
-            x"13",
-            1,
-            0,
-            1,
-            1,
-            true,
-            1,
-            1,
-            30,
-        )
-    }
-
-    #[test]
-    fun test_setup() {
-        setup();
-        assert!(account::exists_at(@aptos_framework), 1);
-        assert!(account::exists_at(@0x2), 1);
-        assert!(account::exists_at(@0x3), 1);
-        assert!(account::exists_at(@0x4), 1);
-        assert!(account::exists_at(@0x5), 1);
-        assert!(account::exists_at(@0x6), 1);
-        assert!(account::exists_at(@0x7), 1);
-        assert!(account::exists_at(@0x8), 1);
-        assert!(account::exists_at(@0x9), 1);
-        assert!(account::exists_at(@0xa), 1);
-    }
-
-    #[test(aptos_framework = @0x1)]
-    fun test_create_account(aptos_framework: &signer) {
-        setup();
-        initialize_aptos_coin(aptos_framework);
-
-        let addr = @0x121341; // 01 -> 0a are taken
-        let test_signer_before = create_account(aptos_framework, addr, 15);
-        let test_signer_after = create_account(aptos_framework, addr, 500);
-        assert!(test_signer_before == test_signer_after, 0);
-        assert!(coin::balance<AptosCoin>(addr) == 15, 1);
-    }
-
-    #[test(aptos_framework = @0x1)]
-    fun test_create_accounts(aptos_framework: &signer) {
-        setup();
-        initialize_aptos_coin(aptos_framework);
-
-        // 01 -> 0a are taken
-        let addr0 = @0x121341;
-        let addr1 = @0x121345;
-
-        let accounts = vector[
-            AccountMap {
-                account_address: addr0,
-                balance: 12345,
-            },
-            AccountMap {
-                account_address: addr1,
-                balance: 67890,
-            },
-        ];
-
-        create_accounts(aptos_framework, accounts);
-        assert!(coin::balance<AptosCoin>(addr0) == 12345, 0);
-        assert!(coin::balance<AptosCoin>(addr1) == 67890, 1);
-
-        create_account(aptos_framework, addr0, 23456);
-        assert!(coin::balance<AptosCoin>(addr0) == 12345, 2);
-    }
-
-    #[test(aptos_framework = @0x1, root = @0xabcd)]
-    fun test_create_root_account(aptos_framework: &signer) {
-        use aptos_framework::aggregator_factory;
-        use aptos_framework::object;
-        use aptos_framework::primary_fungible_store;
-        use aptos_framework::fungible_asset::Metadata;
-        use std::features;
-
-        let feature = features::get_new_accounts_default_to_fa_apt_store_feature();
-        features::change_feature_flags_for_testing(aptos_framework, vector[feature], vector[]);
-
-        aggregator_factory::initialize_aggregator_factory_for_test(aptos_framework);
-
-        let (burn_cap, mint_cap) = aptos_coin::initialize(aptos_framework);
-        aptos_coin::ensure_initialized_with_apt_fa_metadata_for_test();
-
-        let core_resources = account::create_account(@core_resources);
-        aptos_account::register_apt(&core_resources); // registers APT store
-
-        let apt_metadata = object::address_to_object<Metadata>(@aptos_fungible_asset);
-        assert!(primary_fungible_store::primary_store_exists(@core_resources, apt_metadata), 2);
-
-        aptos_coin::configure_accounts_for_test(aptos_framework, &core_resources, mint_cap);
-
-        coin::destroy_burn_cap(burn_cap);
-        coin::destroy_mint_cap(mint_cap);
-    }
-}

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

@@ -1,23 +0,0 @@
-/// Define the GovernanceProposal that will be used as part of on-chain governance by AptosGovernance.
-///
-/// This is separate from the AptosGovernance module to avoid circular dependency between AptosGovernance and Stake.
-module aptos_framework::governance_proposal {
-    friend aptos_framework::aptos_governance;
-
-    struct GovernanceProposal has store, drop {}
-
-    /// Create and return a GovernanceProposal resource. Can only be called by AptosGovernance
-    public(friend) fun create_proposal(): GovernanceProposal {
-        GovernanceProposal {}
-    }
-
-    /// Useful for AptosGovernance to create an empty proposal as proof.
-    public(friend) fun create_empty_proposal(): GovernanceProposal {
-        create_proposal()
-    }
-
-    #[test_only]
-    public fun create_test_proposal(): GovernanceProposal {
-        create_empty_proposal()
-    }
-}

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

@@ -1,68 +0,0 @@
-/// A module for generating globally unique identifiers
-module aptos_framework::guid {
-    friend aptos_framework::account;
-    friend aptos_framework::object;
-
-    /// A globally unique identifier derived from the sender's address and a counter
-    struct GUID has drop, store {
-        id: ID
-    }
-
-    /// A non-privileged identifier that can be freely created by anyone. Useful for looking up GUID's.
-    struct ID has copy, drop, store {
-        /// If creation_num is `i`, this is the `i+1`th GUID created by `addr`
-        creation_num: u64,
-        /// Address that created the GUID
-        addr: address
-    }
-
-    /// GUID generator must be published ahead of first usage of `create_with_capability` function.
-    const EGUID_GENERATOR_NOT_PUBLISHED: u64 = 0;
-
-    /// Create and return a new GUID from a trusted module.
-    public(friend) fun create(addr: address, creation_num_ref: &mut u64): GUID {
-        let creation_num = *creation_num_ref;
-        *creation_num_ref = creation_num + 1;
-        GUID {
-            id: ID {
-                creation_num,
-                addr,
-            }
-        }
-    }
-
-    /// Create a non-privileged id from `addr` and `creation_num`
-    public fun create_id(addr: address, creation_num: u64): ID {
-        ID { creation_num, addr }
-    }
-
-    /// Get the non-privileged ID associated with a GUID
-    public fun id(guid: &GUID): ID {
-        guid.id
-    }
-
-    /// Return the account address that created the GUID
-    public fun creator_address(guid: &GUID): address {
-        guid.id.addr
-    }
-
-    /// Return the account address that created the guid::ID
-    public fun id_creator_address(id: &ID): address {
-        id.addr
-    }
-
-    /// Return the creation number associated with the GUID
-    public fun creation_num(guid: &GUID): u64 {
-        guid.id.creation_num
-    }
-
-    /// Return the creation number associated with the guid::ID
-    public fun id_creation_num(id: &ID): u64 {
-        id.creation_num
-    }
-
-    /// Return true if the GUID's ID is `id`
-    public fun eq_id(guid: &GUID, id: &ID): bool {
-        &guid.id == id
-    }
-}