From d78bb497e4cd14d8f79c587b60792851dfad046b Mon Sep 17 00:00:00 2001
From: Victor Gao <vgao1996@gmail.com>
Date: Mon, 26 Jun 2023 23:24:05 +0000
Subject: [PATCH 1/4] [gas] abstract gas algebra part 1 -- instructions &
 operations

---
 Cargo.lock                                    |   2 +
 aptos-move/aptos-debugger/src/lib.rs          |  17 +-
 .../aptos-gas-profiling/src/profiler.rs       |  53 +-
 aptos-move/aptos-gas/Cargo.toml               |   2 +
 aptos-move/aptos-gas/src/abstract_algebra.rs  | 359 ++++++++++
 aptos-move/aptos-gas/src/gas_meter.rs         | 666 +++++++++++-------
 aptos-move/aptos-gas/src/instr.rs             |  67 +-
 aptos-move/aptos-gas/src/lib.rs               |   7 +-
 aptos-move/aptos-gas/src/misc.rs              |   1 +
 aptos-move/aptos-gas/src/params.rs            |  61 +-
 aptos-move/aptos-gas/src/transaction/mod.rs   |  31 +-
 .../aptos-gas/src/transaction/storage.rs      |  76 +-
 .../aptos-memory-usage-tracker/src/lib.rs     |  29 +-
 aptos-move/aptos-vm/src/aptos_vm.rs           |  46 +-
 aptos-move/aptos-vm/src/aptos_vm_impl.rs      |   8 +-
 .../src/account_universe/bad_transaction.rs   |  11 +-
 aptos-move/e2e-tests/src/executor.rs          |  17 +-
 .../src/tests/failed_transaction_tests.rs     |   7 +-
 .../move/move-core/types/src/gas_algebra.rs   |  12 +
 19 files changed, 1004 insertions(+), 468 deletions(-)
 create mode 100644 aptos-move/aptos-gas/src/abstract_algebra.rs

diff --git a/Cargo.lock b/Cargo.lock
index 04e8f76c7264c..5ed1cef2bf5af 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1540,11 +1540,13 @@ dependencies = [
  "aptos-vm-types",
  "bcs 0.1.4",
  "clap 4.3.5",
+ "either",
  "move-binary-format",
  "move-core-types",
  "move-model",
  "move-table-extension",
  "move-vm-types",
+ "paste",
  "tempfile",
 ]
 
diff --git a/aptos-move/aptos-debugger/src/lib.rs b/aptos-move/aptos-debugger/src/lib.rs
index 7fbd9a6517922..028d9c6791319 100644
--- a/aptos-move/aptos-debugger/src/lib.rs
+++ b/aptos-move/aptos-debugger/src/lib.rs
@@ -3,8 +3,8 @@
 
 use anyhow::{format_err, Result};
 use aptos_gas::{
-    AbstractValueSizeGasParameters, ChangeSetConfigs, NativeGasParameters, StandardGasMeter,
-    LATEST_GAS_FEATURE_VERSION,
+    AbstractValueSizeGasParameters, ChangeSetConfigs, NativeGasParameters, StandardGasAlgebra,
+    StandardGasMeter, LATEST_GAS_FEATURE_VERSION,
 };
 use aptos_gas_profiling::{GasProfiler, TransactionGasLog};
 use aptos_memory_usage_tracker::MemoryTrackedGasMeter;
@@ -80,12 +80,13 @@ impl AptosDebugger {
                 &txn,
                 &log_context,
                 |gas_feature_version, gas_params, storage_gas_params, balance| {
-                    let gas_meter = MemoryTrackedGasMeter::new(StandardGasMeter::new(
-                        gas_feature_version,
-                        gas_params,
-                        storage_gas_params,
-                        balance,
-                    ));
+                    let gas_meter =
+                        MemoryTrackedGasMeter::new(StandardGasMeter::new(StandardGasAlgebra::new(
+                            gas_feature_version,
+                            gas_params,
+                            storage_gas_params,
+                            balance,
+                        )));
                     let gas_profiler = match txn.payload() {
                         TransactionPayload::Script(_) => GasProfiler::new_script(gas_meter),
                         TransactionPayload::EntryFunction(entry_func) => GasProfiler::new_function(
diff --git a/aptos-move/aptos-gas-profiling/src/profiler.rs b/aptos-move/aptos-gas-profiling/src/profiler.rs
index c0ec30250ef9a..b13a6cdabee5e 100644
--- a/aptos-move/aptos-gas-profiling/src/profiler.rs
+++ b/aptos-move/aptos-gas-profiling/src/profiler.rs
@@ -5,7 +5,7 @@ use crate::log::{
     CallFrame, EventStorage, ExecutionAndIOCosts, ExecutionGasEvent, FrameName, StorageFees,
     TransactionGasLog, WriteOpType, WriteStorage, WriteTransient,
 };
-use aptos_gas::{AptosGasMeter, AptosGasParameters, Fee, Gas, GasScalingFactor};
+use aptos_gas::{AptosGasMeter, Fee};
 use aptos_types::{
     contract_event::ContractEvent, state_store::state_key::StateKey, write_set::WriteOp,
 };
@@ -474,16 +474,10 @@ impl<G> AptosGasMeter for GasProfiler<G>
 where
     G: AptosGasMeter,
 {
-    delegate! {
-        fn feature_version(&self) -> u64;
-
-        fn gas_params(&self) -> &AptosGasParameters;
-
-        fn balance(&self) -> Gas;
+    type Algebra = G::Algebra;
 
-        fn gas_unit_scaling_factor(&self) -> GasScalingFactor;
-
-        fn io_gas_per_write(&self, key: &StateKey, op: &WriteOp) -> InternalGas;
+    delegate! {
+        fn algebra(&self) -> &Self::Algebra;
 
         fn storage_fee_per_write(&self, key: &StateKey, op: &WriteOp) -> Fee;
 
@@ -492,20 +486,10 @@ where
         fn storage_discount_for_events(&self, total_cost: Fee) -> Fee;
 
         fn storage_fee_for_transaction_storage(&self, txn_size: NumBytes) -> Fee;
-
-        fn execution_gas_used(&self) -> Gas;
-
-        fn io_gas_used(&self) -> Gas;
-
-        fn storage_fee_used_in_gas_units(&self) -> Gas;
-
-        fn storage_fee_used(&self) -> Fee;
     }
 
     delegate_mut! {
-        fn charge_execution(&mut self, amount: InternalGas) -> PartialVMResult<()>;
-
-        fn charge_io(&mut self, amount: InternalGas) -> PartialVMResult<()>;
+        fn algebra_mut(&mut self) -> &mut Self::Algebra;
 
         fn charge_storage_fee(
             &mut self,
@@ -514,22 +498,17 @@ where
         ) -> PartialVMResult<()>;
     }
 
-    fn charge_io_gas_for_write_set<'a>(
-        &mut self,
-        ops: impl IntoIterator<Item = (&'a StateKey, &'a WriteOp)>,
-    ) -> VMResult<()> {
-        for (key, op) in ops {
-            let cost = self.io_gas_per_write(key, op);
-            self.total_exec_io += cost;
-            self.write_set_transient.push(WriteTransient {
-                key: key.clone(),
-                cost,
-                op_type: write_op_type(op),
-            });
-            self.charge_io(cost)
-                .map_err(|e| e.finish(Location::Undefined))?;
-        }
-        Ok(())
+    fn charge_io_gas_for_write(&mut self, key: &StateKey, op: &WriteOp) -> VMResult<()> {
+        let (cost, res) = self.delegate_charge(|base| base.charge_io_gas_for_write(key, op));
+
+        self.total_exec_io += cost;
+        self.write_set_transient.push(WriteTransient {
+            key: key.clone(),
+            cost,
+            op_type: write_op_type(op),
+        });
+
+        res
     }
 
     fn charge_storage_fee_for_all<'a>(
diff --git a/aptos-move/aptos-gas/Cargo.toml b/aptos-move/aptos-gas/Cargo.toml
index 1747b41664da9..f58f07037a36a 100644
--- a/aptos-move/aptos-gas/Cargo.toml
+++ b/aptos-move/aptos-gas/Cargo.toml
@@ -24,11 +24,13 @@ aptos-types = { workspace = true }
 aptos-vm-types = { workspace = true }
 bcs = { workspace = true }
 clap = { workspace = true }
+either = { workspace = true }
 move-binary-format = { workspace = true }
 move-core-types = { workspace = true }
 move-model = { workspace = true }
 move-table-extension = { workspace = true }
 move-vm-types = { workspace = true }
+paste = { workspace = true }
 
 [dev-dependencies]
 tempfile = { workspace = true }
diff --git a/aptos-move/aptos-gas/src/abstract_algebra.rs b/aptos-move/aptos-gas/src/abstract_algebra.rs
new file mode 100644
index 0000000000000..bff698ba7f5fe
--- /dev/null
+++ b/aptos-move/aptos-gas/src/abstract_algebra.rs
@@ -0,0 +1,359 @@
+use crate::{AptosGasParameters, Fee, FeePerGasUnit, Octa, StorageGasParameters};
+use either::Either;
+use move_binary_format::errors::PartialVMResult;
+use move_core_types::gas_algebra::{GasQuantity, InternalGas, InternalGasUnit};
+use std::ops::{Add, Mul};
+
+pub trait GasExpressionVisitor {
+    fn add(&mut self);
+
+    fn mul(&mut self);
+
+    fn gas_param<P>(&mut self);
+
+    fn quantity<U>(&mut self, quantity: GasQuantity<U>);
+}
+
+/// Abstraction over a gas expression.
+pub trait GasExpression {
+    type Unit;
+
+    fn materialize(
+        &self,
+        feature_version: u64,
+        gas_params: &AptosGasParameters,
+    ) -> GasQuantity<Self::Unit>;
+
+    fn visit(&self, visitor: &mut impl GasExpressionVisitor);
+}
+
+pub trait GasAlgebra {
+    fn feature_version(&self) -> u64;
+
+    fn gas_params(&self) -> &AptosGasParameters;
+
+    fn storage_gas_params(&self) -> &StorageGasParameters;
+
+    fn balance_internal(&self) -> InternalGas;
+
+    fn charge_execution(
+        &mut self,
+        abstract_amount: impl GasExpression<Unit = InternalGasUnit>,
+    ) -> PartialVMResult<()>;
+
+    fn charge_io(
+        &mut self,
+        abstract_amount: impl GasExpression<Unit = InternalGasUnit>,
+    ) -> PartialVMResult<()>;
+
+    fn charge_storage_fee(
+        &mut self,
+        abstract_amount: impl GasExpression<Unit = Octa>,
+        gas_unit_price: FeePerGasUnit,
+    ) -> PartialVMResult<()>;
+
+    fn execution_gas_used(&self) -> InternalGas;
+
+    fn io_gas_used(&self) -> InternalGas;
+
+    fn storage_fee_used_in_gas_units(&self) -> InternalGas;
+
+    fn storage_fee_used(&self) -> Fee;
+}
+
+pub struct GasAdd<L, R> {
+    pub left: L,
+    pub right: R,
+}
+
+pub struct GasMul<L, R> {
+    pub left: L,
+    pub right: R,
+}
+
+pub struct GasOptional<F, E> {
+    pub predicate: F,
+    pub exp: E,
+}
+
+impl<L, R, U> GasExpression for GasAdd<L, R>
+where
+    L: GasExpression<Unit = U>,
+    R: GasExpression<Unit = U>,
+{
+    type Unit = U;
+
+    #[inline]
+    fn materialize(
+        &self,
+        feature_version: u64,
+        gas_params: &AptosGasParameters,
+    ) -> GasQuantity<Self::Unit> {
+        self.left.materialize(feature_version, gas_params)
+            + self.right.materialize(feature_version, gas_params)
+    }
+
+    #[inline]
+    fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
+        self.left.visit(visitor);
+        self.right.visit(visitor);
+        visitor.add();
+    }
+}
+
+impl<L, R, UL, UR, O> GasExpression for GasMul<L, R>
+where
+    L: GasExpression<Unit = UL>,
+    R: GasExpression<Unit = UR>,
+    GasQuantity<UL>: Mul<GasQuantity<UR>, Output = GasQuantity<O>>,
+{
+    type Unit = O;
+
+    #[inline]
+    fn materialize(
+        &self,
+        feature_version: u64,
+        gas_params: &AptosGasParameters,
+    ) -> GasQuantity<Self::Unit> {
+        self.left.materialize(feature_version, gas_params)
+            * self.right.materialize(feature_version, gas_params)
+    }
+
+    #[inline]
+    fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
+        self.left.visit(visitor);
+        self.right.visit(visitor);
+        visitor.mul();
+    }
+}
+
+impl<U> GasExpression for GasQuantity<U> {
+    type Unit = U;
+
+    #[inline]
+    fn materialize(
+        &self,
+        _feature_version: u64,
+        _gas_params: &AptosGasParameters,
+    ) -> GasQuantity<Self::Unit> {
+        *self
+    }
+
+    #[inline]
+    fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
+        visitor.quantity(*self)
+    }
+}
+
+impl<F, E> GasExpression for GasOptional<F, E>
+where
+    F: Fn() -> bool,
+    E: GasExpression,
+{
+    type Unit = E::Unit;
+
+    #[inline]
+    fn materialize(
+        &self,
+        feature_version: u64,
+        gas_params: &AptosGasParameters,
+    ) -> GasQuantity<Self::Unit> {
+        if (self.predicate)() {
+            self.exp.materialize(feature_version, gas_params)
+        } else {
+            0.into()
+        }
+    }
+
+    #[inline]
+    fn visit(&self, _visitor: &mut impl GasExpressionVisitor) {}
+}
+
+impl<L, R, T> Add<T> for GasAdd<L, R>
+where
+    Self: GasExpression,
+    T: GasExpression,
+{
+    type Output = GasAdd<Self, T>;
+
+    fn add(self, rhs: T) -> Self::Output {
+        GasAdd {
+            left: self,
+            right: rhs,
+        }
+    }
+}
+
+impl<L, R, T> Mul<T> for GasAdd<L, R>
+where
+    Self: GasExpression,
+    T: GasExpression,
+{
+    type Output = GasMul<Self, T>;
+
+    fn mul(self, rhs: T) -> Self::Output {
+        GasMul {
+            left: self,
+            right: rhs,
+        }
+    }
+}
+
+impl<L, R, T> Add<T> for GasMul<L, R>
+where
+    Self: GasExpression,
+    T: GasExpression,
+{
+    type Output = GasAdd<Self, T>;
+
+    fn add(self, rhs: T) -> Self::Output {
+        GasAdd {
+            left: self,
+            right: rhs,
+        }
+    }
+}
+
+impl<L, R, T> Mul<T> for GasMul<L, R>
+where
+    Self: GasExpression,
+    T: GasExpression,
+{
+    type Output = GasMul<Self, T>;
+
+    fn mul(self, rhs: T) -> Self::Output {
+        GasMul {
+            left: self,
+            right: rhs,
+        }
+    }
+}
+
+impl<F, E, T> Add<T> for GasOptional<F, E>
+where
+    Self: GasExpression,
+    T: GasExpression,
+{
+    type Output = GasAdd<Self, T>;
+
+    fn add(self, rhs: T) -> Self::Output {
+        GasAdd {
+            left: self,
+            right: rhs,
+        }
+    }
+}
+
+impl<F, E, T> Mul<T> for GasOptional<F, E>
+where
+    Self: GasExpression,
+    T: GasExpression,
+{
+    type Output = GasMul<Self, T>;
+
+    fn mul(self, rhs: T) -> Self::Output {
+        GasMul {
+            left: self,
+            right: rhs,
+        }
+    }
+}
+
+impl<L, R, U> GasExpression for Either<L, R>
+where
+    L: GasExpression<Unit = U>,
+    R: GasExpression<Unit = U>,
+{
+    type Unit = U;
+
+    #[inline]
+    fn materialize(
+        &self,
+        feature_version: u64,
+        gas_params: &AptosGasParameters,
+    ) -> GasQuantity<Self::Unit> {
+        match self {
+            Either::Left(left) => left.materialize(feature_version, gas_params),
+            Either::Right(right) => right.materialize(feature_version, gas_params),
+        }
+    }
+
+    #[inline]
+    fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
+        match self {
+            Either::Left(left) => left.visit(visitor),
+            Either::Right(right) => right.visit(visitor),
+        }
+    }
+}
+
+pub mod gas_switches {
+    use super::*;
+
+    macro_rules! define_gas_switch {
+        ($tn: ident < $($tp: ident),* $(,)? >) => {
+            #[allow(unused)]
+            pub enum $tn<$($tp),*> {
+                $(
+                    $tp($tp)
+                ),*
+            }
+
+            impl<U, $($tp),*> GasExpression for $tn<$($tp),*>
+            where
+                $($tp: GasExpression<Unit = U>),*
+            {
+                type Unit = U;
+
+                #[inline]
+                fn materialize(
+                    &self,
+                    feature_version: u64,
+                    gas_params: &AptosGasParameters,
+                ) -> GasQuantity<Self::Unit> {
+                    match self {
+                        $(
+                            $tn::$tp(e) => e.materialize(feature_version, gas_params)
+                        ),*
+                    }
+                }
+
+                #[inline]
+                fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
+                    match self {
+                        $(
+                            $tn::$tp(e) => e.visit(visitor)
+                        ),*
+                    }
+                }
+            }
+        };
+    }
+
+    define_gas_switch!(GasSwitch2<E1, E2>);
+    define_gas_switch!(GasSwitch3<E1, E2, E3>);
+    define_gas_switch!(GasSwitch4<E1, E2, E3, E4>);
+    define_gas_switch!(GasSwitch5<E1, E2, E3, E4, E5>);
+    define_gas_switch!(GasSwitch6<E1, E2, E3, E4, E5, E6>);
+    define_gas_switch!(GasSwitch7<E1, E2, E3, E4, E5, E6, E7>);
+    define_gas_switch!(GasSwitch8<E1, E2, E3, E4, E5, E6, E7, E8>);
+}
+
+impl<T> GasExpression for &T
+where
+    T: GasExpression,
+{
+    type Unit = T::Unit;
+
+    fn materialize(
+        &self,
+        feature_version: u64,
+        gas_params: &AptosGasParameters,
+    ) -> GasQuantity<Self::Unit> {
+        (*self).materialize(feature_version, gas_params)
+    }
+
+    fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
+        (*self).visit(visitor)
+    }
+}
diff --git a/aptos-move/aptos-gas/src/gas_meter.rs b/aptos-move/aptos-gas/src/gas_meter.rs
index e36cebb0454b1..f07ab27e0d32b 100644
--- a/aptos-move/aptos-gas/src/gas_meter.rs
+++ b/aptos-move/aptos-gas/src/gas_meter.rs
@@ -5,10 +5,11 @@
 //! parameters and traits to help manipulate them.
 
 use crate::{
+    abstract_algebra::{GasAlgebra, GasExpression},
     algebra::{Fee, Gas},
-    instr::InstructionGasParameters,
+    instr::{gas_params::*, InstructionGasParameters},
     misc::MiscGasParameters,
-    transaction::TransactionGasParameters,
+    transaction::{gas_params::*, TransactionGasParameters},
     FeePerGasUnit, GasScalingFactor, StorageGasParameters,
 };
 use aptos_logger::error;
@@ -21,7 +22,7 @@ use move_binary_format::{
 };
 use move_core_types::{
     account_address::AccountAddress,
-    gas_algebra::{InternalGas, NumArgs, NumBytes},
+    gas_algebra::{InternalGas, InternalGasUnit, NumArgs, NumBytes},
     language_storage::ModuleId,
     vm_status::StatusCode,
 };
@@ -224,27 +225,15 @@ impl InitialGasSchedule for AptosGasParameters {
 /// It extends Move VM's `GasMeter` trait with a few Aptos-specific callbacks, along with
 /// some primitives that would allow gas meters to be composable.
 pub trait AptosGasMeter: MoveGasMeter {
-    /// Returns the gas feature version.
-    fn feature_version(&self) -> u64;
-
-    /// Returns the struct that contains all (non-storage) gas parameters.
-    fn gas_params(&self) -> &AptosGasParameters;
-
-    /// Returns the remaining balance, measured in (external) gas units.
-    ///
-    /// The number should be rounded down when converting from internal to external gas units.
-    fn balance(&self) -> Gas;
-
-    /// Returns the scaling factor between internal and external gas units.
-    fn gas_unit_scaling_factor(&self) -> GasScalingFactor;
+    type Algebra: GasAlgebra;
 
-    /// Charges gas for performing operations that fall under the execution category.
-    fn charge_execution(&mut self, amount: InternalGas) -> PartialVMResult<()>;
+    /// Returns a reference to the underlying algebra object.
+    fn algebra(&self) -> &Self::Algebra;
 
-    /// Charges gas for performing operations that fall under the IO category.
-    fn charge_io(&mut self, amount: InternalGas) -> PartialVMResult<()>;
+    /// Returns a mutable reference to the underlying algebra object.
+    fn algebra_mut(&mut self) -> &mut Self::Algebra;
 
-    /// Charges fee for utlizing short-term or long-term storage.
+    /// Charges fee for utilizing short-term or long-term storage.
     ///
     /// Since the fee is measured in APT/Octa, it needs to be converted into gas units
     /// according to the given unit price.
@@ -254,31 +243,17 @@ pub trait AptosGasMeter: MoveGasMeter {
         gas_unit_price: FeePerGasUnit,
     ) -> PartialVMResult<()>;
 
-    /// Charge an intrinsic cost for executing the transaction.
+    /// Charges an intrinsic cost for executing the transaction.
     ///
     /// The cost stays constant for transactions below a certain size, but will grow proportionally
     /// for bigger ones.
     fn charge_intrinsic_gas_for_transaction(&mut self, txn_size: NumBytes) -> VMResult<()>;
 
-    /// Calculates the IO gas cost required to perform a write operation.
-    fn io_gas_per_write(&self, key: &StateKey, op: &WriteOp) -> InternalGas;
-
-    /// Charges IO gas for all items in the specified write set.
+    /// Charges IO gas for an item in the write set.
     ///
-    /// The contract requires that this function behaviors in a way that is consistent to
-    /// `fn io_gas_per_write`.
-    /// Due to this reason, you should normally not override the default implementation,
-    /// unless you are doing something special, such as injecting additional logging logic.
-    fn charge_io_gas_for_write_set<'a>(
-        &mut self,
-        ops: impl IntoIterator<Item = (&'a StateKey, &'a WriteOp)>,
-    ) -> VMResult<()> {
-        for (key, op) in ops {
-            self.charge_io(self.io_gas_per_write(key, op))
-                .map_err(|e| e.finish(Location::Undefined))?;
-        }
-        Ok(())
-    }
+    /// This is to be differentiated from the storage fee, which is meant to cover the long-term
+    /// storage costs.
+    fn charge_io_gas_for_write(&mut self, key: &StateKey, op: &WriteOp) -> VMResult<()>;
 
     /// Calculates the storage fee for a write operation.
     fn storage_fee_per_write(&self, key: &StateKey, op: &WriteOp) -> Fee;
@@ -338,26 +313,70 @@ pub trait AptosGasMeter: MoveGasMeter {
         Ok(())
     }
 
+    // Below are getters reexported from the gas algebra.
+    // Gas meter instances should not reimplement these themselves.
+
+    /// Returns the gas feature version.
+    fn feature_version(&self) -> u64 {
+        self.algebra().feature_version()
+    }
+
+    /// Returns the struct that contains all (non-storage) gas parameters.
+    fn gas_params(&self) -> &AptosGasParameters {
+        self.algebra().gas_params()
+    }
+
+    // Returns a reference to the struct containing all storage gas parameters.
+    fn storage_gas_params(&self) -> &StorageGasParameters {
+        self.algebra().storage_gas_params()
+    }
+
+    /// Returns the remaining balance, measured in (external) gas units.
+    ///
+    /// The number should be rounded down when converting from internal to external gas units.
+    fn balance(&self) -> Gas {
+        self.algebra()
+            .balance_internal()
+            .to_unit_round_down_with_params(&self.gas_params().txn)
+    }
+
+    /// Returns the scaling factor between internal and external gas units.
+    fn gas_unit_scaling_factor(&self) -> GasScalingFactor {
+        self.algebra().gas_params().txn.scaling_factor()
+    }
+
     /// Return the total gas used for execution.
-    fn execution_gas_used(&self) -> Gas;
+    fn execution_gas_used(&self) -> Gas {
+        self.algebra()
+            .execution_gas_used()
+            .to_unit_round_up_with_params(&self.gas_params().txn)
+    }
 
     /// Return the total gas used for io.
-    fn io_gas_used(&self) -> Gas;
+    fn io_gas_used(&self) -> Gas {
+        self.algebra()
+            .io_gas_used()
+            .to_unit_round_up_with_params(&self.gas_params().txn)
+    }
 
     /// Return the total gas used for storage.
-    fn storage_fee_used_in_gas_units(&self) -> Gas;
+    fn storage_fee_used_in_gas_units(&self) -> Gas {
+        self.algebra()
+            .storage_fee_used_in_gas_units()
+            .to_unit_round_up_with_params(&self.gas_params().txn)
+    }
 
     /// Return the total fee used for storage.
-    fn storage_fee_used(&self) -> Fee;
+    fn storage_fee_used(&self) -> Fee {
+        self.algebra().storage_fee_used()
+    }
 }
 
-/// The official gas meter used inside the Aptos VM.
-/// It maintains an internal gas counter, measured in internal gas units, and carries an environment
-/// consisting all the gas parameters, which it can lookup when performing gas calculations.
-pub struct StandardGasMeter {
+pub struct StandardGasAlgebra {
     feature_version: u64,
     gas_params: AptosGasParameters,
     storage_gas_params: StorageGasParameters,
+
     balance: InternalGas,
 
     execution_gas_used: InternalGas,
@@ -368,7 +387,7 @@ pub struct StandardGasMeter {
     storage_fee_used: Fee,
 }
 
-impl StandardGasMeter {
+impl StandardGasAlgebra {
     pub fn new(
         gas_feature_version: u64,
         gas_params: AptosGasParameters,
@@ -388,8 +407,9 @@ impl StandardGasMeter {
             storage_fee_used: 0.into(),
         }
     }
+}
 
-    #[inline]
+impl StandardGasAlgebra {
     fn charge(&mut self, amount: InternalGas) -> PartialVMResult<()> {
         match self.balance.checked_sub(amount) {
             Some(new_balance) => {
@@ -402,37 +422,230 @@ impl StandardGasMeter {
             },
         }
     }
+}
 
-    pub fn feature_version(&self) -> u64 {
+impl GasAlgebra for StandardGasAlgebra {
+    fn feature_version(&self) -> u64 {
         self.feature_version
     }
+
+    fn gas_params(&self) -> &AptosGasParameters {
+        &self.gas_params
+    }
+
+    fn storage_gas_params(&self) -> &StorageGasParameters {
+        &self.storage_gas_params
+    }
+
+    fn balance_internal(&self) -> InternalGas {
+        self.balance
+    }
+
+    fn charge_execution(
+        &mut self,
+        abstract_amount: impl GasExpression<Unit = InternalGasUnit>,
+    ) -> PartialVMResult<()> {
+        let amount = abstract_amount.materialize(self.feature_version, &self.gas_params);
+
+        self.charge(amount)?;
+
+        self.execution_gas_used += amount;
+        if self.feature_version >= 7
+            && self.execution_gas_used > self.gas_params.txn.max_execution_gas
+        {
+            Err(PartialVMError::new(StatusCode::EXECUTION_LIMIT_REACHED))
+        } else {
+            Ok(())
+        }
+    }
+
+    fn charge_io(
+        &mut self,
+        abstract_amount: impl GasExpression<Unit = InternalGasUnit>,
+    ) -> PartialVMResult<()> {
+        let amount = abstract_amount.materialize(self.feature_version, &self.gas_params);
+
+        self.charge(amount)?;
+
+        self.io_gas_used += amount;
+        if self.feature_version >= 7 && self.io_gas_used > self.gas_params.txn.max_io_gas {
+            Err(PartialVMError::new(StatusCode::IO_LIMIT_REACHED))
+        } else {
+            Ok(())
+        }
+    }
+
+    fn charge_storage_fee(
+        &mut self,
+        abstract_amount: impl GasExpression<Unit = crate::Octa>,
+        gas_unit_price: FeePerGasUnit,
+    ) -> PartialVMResult<()> {
+        let amount = abstract_amount.materialize(self.feature_version, &self.gas_params);
+
+        let txn_params = &self.gas_params.txn;
+
+        // Because the storage fees are defined in terms of fixed APT costs, we need
+        // to convert them into gas units.
+        //
+        // u128 is used to protect against overflow and preserve as much precision as
+        // possible in the extreme cases.
+        fn div_ceil(n: u128, d: u128) -> u128 {
+            if n % d == 0 {
+                n / d
+            } else {
+                n / d + 1
+            }
+        }
+        let gas_consumed_internal = div_ceil(
+            (u64::from(amount) as u128) * (u64::from(txn_params.gas_unit_scaling_factor) as u128),
+            u64::from(gas_unit_price) as u128,
+        );
+        let gas_consumed_internal = InternalGas::new(
+            if gas_consumed_internal > u64::MAX as u128 {
+                error!(
+                    "Something's wrong in the gas schedule: gas_consumed_internal ({}) > u64::MAX",
+                    gas_consumed_internal
+                );
+                u64::MAX
+            } else {
+                gas_consumed_internal as u64
+            },
+        );
+
+        self.charge(gas_consumed_internal)?;
+
+        self.storage_fee_in_internal_units += gas_consumed_internal;
+        self.storage_fee_used += amount;
+        if self.feature_version >= 7 && self.storage_fee_used > self.gas_params.txn.max_storage_fee
+        {
+            return Err(PartialVMError::new(StatusCode::STORAGE_LIMIT_REACHED));
+        }
+
+        Ok(())
+    }
+
+    fn execution_gas_used(&self) -> InternalGas {
+        self.execution_gas_used
+    }
+
+    fn io_gas_used(&self) -> InternalGas {
+        self.io_gas_used
+    }
+
+    fn storage_fee_used_in_gas_units(&self) -> InternalGas {
+        self.storage_fee_in_internal_units
+    }
+
+    fn storage_fee_used(&self) -> Fee {
+        self.storage_fee_used
+    }
 }
 
-impl MoveGasMeter for StandardGasMeter {
+/// The official gas meter used inside the Aptos VM.
+/// It maintains an internal gas counter, measured in internal gas units, and carries an environment
+/// consisting all the gas parameters, which it can lookup when performing gas calculations.
+pub struct StandardGasMeter<A> {
+    algebra: A,
+}
+
+impl<A> StandardGasMeter<A>
+where
+    A: GasAlgebra,
+{
+    pub fn new(algebra: A) -> Self {
+        Self { algebra }
+    }
+
+    pub fn feature_version(&self) -> u64 {
+        self.algebra.feature_version()
+    }
+}
+
+impl<A> MoveGasMeter for StandardGasMeter<A>
+where
+    A: GasAlgebra,
+{
     #[inline]
     fn balance_internal(&self) -> InternalGas {
-        self.balance
+        self.algebra.balance_internal()
     }
 
     #[inline]
     fn charge_br_false(&mut self, _target_offset: Option<CodeOffset>) -> PartialVMResult<()> {
-        self.charge_execution(self.gas_params.instr.br_false)
+        self.algebra.charge_execution(BR_FALSE)
     }
 
     #[inline]
     fn charge_br_true(&mut self, _target_offset: Option<CodeOffset>) -> PartialVMResult<()> {
-        self.charge_execution(self.gas_params.instr.br_true)
+        self.algebra.charge_execution(BR_TRUE)
     }
 
     #[inline]
     fn charge_branch(&mut self, _target_offset: CodeOffset) -> PartialVMResult<()> {
-        self.charge_execution(self.gas_params.instr.branch)
+        self.algebra.charge_execution(BRANCH)
     }
 
     #[inline]
     fn charge_simple_instr(&mut self, instr: SimpleInstruction) -> PartialVMResult<()> {
-        let cost = self.gas_params.instr.simple_instr_cost(instr)?;
-        self.charge_execution(cost)
+        macro_rules! dispatch {
+            ($($name: ident => $cost: expr),* $(,)?) => {
+                match instr {
+                    $(SimpleInstruction::$name => self.algebra.charge_execution($cost)),*
+                }
+            };
+        }
+
+        dispatch! {
+            Nop => NOP,
+
+            Abort => ABORT,
+            Ret => RET,
+
+            LdU8 => LD_U8,
+            LdU16 => LD_U16,
+            LdU32 => LD_U32,
+            LdU64 => LD_U64,
+            LdU128 => LD_U128,
+            LdU256 => LD_U256,
+            LdTrue => LD_TRUE,
+            LdFalse => LD_FALSE,
+
+            ImmBorrowLoc => IMM_BORROW_LOC,
+            MutBorrowLoc => MUT_BORROW_LOC,
+            ImmBorrowField => IMM_BORROW_FIELD,
+            MutBorrowField => MUT_BORROW_FIELD,
+            ImmBorrowFieldGeneric => IMM_BORROW_FIELD_GENERIC,
+            MutBorrowFieldGeneric => MUT_BORROW_FIELD_GENERIC,
+            FreezeRef => FREEZE_REF,
+
+            CastU8 => CAST_U8,
+            CastU16 => CAST_U16,
+            CastU32 => CAST_U32,
+            CastU64 => CAST_U64,
+            CastU128 => CAST_U128,
+            CastU256 => CAST_U256,
+
+            Add => ADD,
+            Sub => SUB,
+            Mul => MUL,
+            Mod => MOD_,
+            Div => DIV,
+
+            BitOr => BIT_OR,
+            BitAnd => BIT_AND,
+            Xor => XOR,
+            Shl => SHL,
+            Shr => SHR,
+
+            Or => OR,
+            And => AND,
+            Not => NOT,
+
+            Lt => LT,
+            Gt => GT,
+            Le => LE,
+            Ge => GE,
+        }
     }
 
     #[inline]
@@ -450,7 +663,8 @@ impl MoveGasMeter for StandardGasMeter {
         amount: InternalGas,
         _ret_vals: Option<impl ExactSizeIterator<Item = impl ValueView>>,
     ) -> PartialVMResult<()> {
-        self.charge_execution(amount)
+        // TODO(Gas): Is this correct???
+        self.algebra.charge_execution(amount)
     }
 
     #[inline]
@@ -461,19 +675,20 @@ impl MoveGasMeter for StandardGasMeter {
         val: Option<impl ValueView>,
         bytes_loaded: NumBytes,
     ) -> PartialVMResult<()> {
-        if self.feature_version <= 8 && val.is_none() && bytes_loaded != 0.into() {
+        // TODO(Gas): check if this is correct.
+        if self.feature_version() <= 8 && val.is_none() && bytes_loaded != 0.into() {
             return Err(PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR).with_message("in legacy versions, number of bytes loaded must be zero when the resource does not exist ".to_string()));
         }
         let cost = self
-            .storage_gas_params
+            .storage_gas_params()
             .pricing
             .calculate_read_gas(val.is_some(), bytes_loaded);
-        self.charge_io(cost)
+        self.algebra.charge_io(cost)
     }
 
     #[inline]
     fn charge_pop(&mut self, _popped_val: impl ValueView) -> PartialVMResult<()> {
-        self.charge_execution(self.gas_params.instr.pop)
+        self.algebra.charge_execution(POP)
     }
 
     #[inline]
@@ -484,14 +699,14 @@ impl MoveGasMeter for StandardGasMeter {
         args: impl ExactSizeIterator<Item = impl ValueView>,
         num_locals: NumArgs,
     ) -> PartialVMResult<()> {
-        let params = &self.gas_params.instr;
+        let cost = CALL_BASE + CALL_PER_ARG * NumArgs::new(args.len() as u64);
 
-        let mut cost = params.call_base + params.call_per_arg * NumArgs::new(args.len() as u64);
-        if self.feature_version >= 3 {
-            cost += params.call_per_local * num_locals;
+        match self.feature_version() {
+            0..=2 => self.algebra.charge_execution(cost),
+            3.. => self
+                .algebra
+                .charge_execution(cost + CALL_PER_LOCAL * num_locals),
         }
-
-        self.charge_execution(cost)
     }
 
     #[inline]
@@ -503,22 +718,22 @@ impl MoveGasMeter for StandardGasMeter {
         args: impl ExactSizeIterator<Item = impl ValueView>,
         num_locals: NumArgs,
     ) -> PartialVMResult<()> {
-        let params = &self.gas_params.instr;
-
-        let mut cost = params.call_generic_base
-            + params.call_generic_per_ty_arg * NumArgs::new(ty_args.len() as u64)
-            + params.call_generic_per_arg * NumArgs::new(args.len() as u64);
-        if self.feature_version >= 3 {
-            cost += params.call_generic_per_local * num_locals;
+        let cost = CALL_GENERIC_BASE
+            + CALL_GENERIC_PER_TY_ARG * NumArgs::new(ty_args.len() as u64)
+            + CALL_GENERIC_PER_ARG * NumArgs::new(args.len() as u64);
+
+        match self.feature_version() {
+            0..=2 => self.algebra.charge_execution(cost),
+            3.. => self
+                .algebra
+                .charge_execution(cost + CALL_GENERIC_PER_LOCAL * num_locals),
         }
-
-        self.charge_execution(cost)
     }
 
     #[inline]
     fn charge_ld_const(&mut self, size: NumBytes) -> PartialVMResult<()> {
-        let instr = &self.gas_params.instr;
-        self.charge_execution(instr.ld_const_base + instr.ld_const_per_byte * size)
+        self.algebra
+            .charge_execution(LD_CONST_BASE + LD_CONST_PER_BYTE * size)
     }
 
     #[inline]
@@ -532,27 +747,24 @@ impl MoveGasMeter for StandardGasMeter {
     #[inline]
     fn charge_copy_loc(&mut self, val: impl ValueView) -> PartialVMResult<()> {
         let (stack_size, heap_size) = self
-            .gas_params
+            .gas_params()
             .misc
             .abs_val
-            .abstract_value_size_stack_and_heap(val, self.feature_version);
+            .abstract_value_size_stack_and_heap(val, self.feature_version());
 
         // Note(Gas): this makes a deep copy so we need to charge for the full value size
-        let instr_params = &self.gas_params.instr;
-        let cost = instr_params.copy_loc_base
-            + instr_params.copy_loc_per_abs_val_unit * (stack_size + heap_size);
-
-        self.charge_execution(cost)
+        self.algebra
+            .charge_execution(COPY_LOC_BASE + COPY_LOC_PER_ABS_VAL_UNIT * (stack_size + heap_size))
     }
 
     #[inline]
     fn charge_move_loc(&mut self, _val: impl ValueView) -> PartialVMResult<()> {
-        self.charge_execution(self.gas_params.instr.move_loc_base)
+        self.algebra.charge_execution(MOVE_LOC_BASE)
     }
 
     #[inline]
     fn charge_store_loc(&mut self, _val: impl ValueView) -> PartialVMResult<()> {
-        self.charge_execution(self.gas_params.instr.st_loc_base)
+        self.algebra.charge_execution(ST_LOC_BASE)
     }
 
     #[inline]
@@ -563,12 +775,14 @@ impl MoveGasMeter for StandardGasMeter {
     ) -> PartialVMResult<()> {
         let num_args = NumArgs::new(args.len() as u64);
 
-        let params = &self.gas_params.instr;
-        let cost = match is_generic {
-            false => params.pack_base + params.pack_per_field * num_args,
-            true => params.pack_generic_base + params.pack_generic_per_field * num_args,
-        };
-        self.charge_execution(cost)
+        match is_generic {
+            false => self
+                .algebra
+                .charge_execution(PACK_BASE + PACK_PER_FIELD * num_args),
+            true => self
+                .algebra
+                .charge_execution(PACK_GENERIC_BASE + PACK_GENERIC_PER_FIELD * num_args),
+        }
     }
 
     #[inline]
@@ -579,27 +793,27 @@ impl MoveGasMeter for StandardGasMeter {
     ) -> PartialVMResult<()> {
         let num_args = NumArgs::new(args.len() as u64);
 
-        let params = &self.gas_params.instr;
-        let cost = match is_generic {
-            false => params.unpack_base + params.unpack_per_field * num_args,
-            true => params.unpack_generic_base + params.unpack_generic_per_field * num_args,
-        };
-        self.charge_execution(cost)
+        match is_generic {
+            false => self
+                .algebra
+                .charge_execution(UNPACK_BASE + UNPACK_PER_FIELD * num_args),
+            true => self
+                .algebra
+                .charge_execution(UNPACK_GENERIC_BASE + UNPACK_GENERIC_PER_FIELD * num_args),
+        }
     }
 
     #[inline]
     fn charge_read_ref(&mut self, val: impl ValueView) -> PartialVMResult<()> {
         let (stack_size, heap_size) = self
-            .gas_params
+            .gas_params()
             .misc
             .abs_val
-            .abstract_value_size_stack_and_heap(val, self.feature_version);
+            .abstract_value_size_stack_and_heap(val, self.feature_version());
 
         // Note(Gas): this makes a deep copy so we need to charge for the full value size
-        let instr_params = &self.gas_params.instr;
-        let cost = instr_params.read_ref_base
-            + instr_params.read_ref_per_abs_val_unit * (stack_size + heap_size);
-        self.charge_execution(cost)
+        self.algebra
+            .charge_execution(READ_REF_BASE + READ_REF_PER_ABS_VAL_UNIT * (stack_size + heap_size))
     }
 
     #[inline]
@@ -608,35 +822,31 @@ impl MoveGasMeter for StandardGasMeter {
         _new_val: impl ValueView,
         _old_val: impl ValueView,
     ) -> PartialVMResult<()> {
-        self.charge_execution(self.gas_params.instr.write_ref_base)
+        self.algebra.charge_execution(WRITE_REF_BASE)
     }
 
     #[inline]
     fn charge_eq(&mut self, lhs: impl ValueView, rhs: impl ValueView) -> PartialVMResult<()> {
-        let instr_params = &self.gas_params.instr;
-        let abs_val_params = &self.gas_params.misc.abs_val;
-        let per_unit = instr_params.eq_per_abs_val_unit;
+        let abs_val_params = &self.gas_params().misc.abs_val;
 
-        let cost = instr_params.eq_base
-            + per_unit
-                * (abs_val_params.abstract_value_size_dereferenced(lhs, self.feature_version)
-                    + abs_val_params.abstract_value_size_dereferenced(rhs, self.feature_version));
+        let cost = EQ_BASE
+            + EQ_PER_ABS_VAL_UNIT
+                * (abs_val_params.abstract_value_size_dereferenced(lhs, self.feature_version())
+                    + abs_val_params.abstract_value_size_dereferenced(rhs, self.feature_version()));
 
-        self.charge_execution(cost)
+        self.algebra.charge_execution(cost)
     }
 
     #[inline]
     fn charge_neq(&mut self, lhs: impl ValueView, rhs: impl ValueView) -> PartialVMResult<()> {
-        let instr_params = &self.gas_params.instr;
-        let abs_val_params = &self.gas_params.misc.abs_val;
-        let per_unit = instr_params.neq_per_abs_val_unit;
+        let abs_val_params = &self.gas_params().misc.abs_val;
 
-        let cost = instr_params.neq_base
-            + per_unit
-                * (abs_val_params.abstract_value_size_dereferenced(lhs, self.feature_version)
-                    + abs_val_params.abstract_value_size_dereferenced(rhs, self.feature_version));
+        let cost = NEQ_BASE
+            + NEQ_PER_ABS_VAL_UNIT
+                * (abs_val_params.abstract_value_size_dereferenced(lhs, self.feature_version())
+                    + abs_val_params.abstract_value_size_dereferenced(rhs, self.feature_version()));
 
-        self.charge_execution(cost)
+        self.algebra.charge_execution(cost)
     }
 
     #[inline]
@@ -647,14 +857,16 @@ impl MoveGasMeter for StandardGasMeter {
         _ty: impl TypeView,
         _is_success: bool,
     ) -> PartialVMResult<()> {
-        let params = &self.gas_params.instr;
-        let cost = match (is_mut, is_generic) {
-            (false, false) => params.imm_borrow_global_base,
-            (false, true) => params.imm_borrow_global_generic_base,
-            (true, false) => params.mut_borrow_global_base,
-            (true, true) => params.mut_borrow_global_generic_base,
-        };
-        self.charge_execution(cost)
+        match (is_mut, is_generic) {
+            (false, false) => self.algebra.charge_execution(IMM_BORROW_GLOBAL_BASE),
+            (false, true) => self
+                .algebra
+                .charge_execution(IMM_BORROW_GLOBAL_GENERIC_BASE),
+            (true, false) => self.algebra.charge_execution(MUT_BORROW_GLOBAL_BASE),
+            (true, true) => self
+                .algebra
+                .charge_execution(MUT_BORROW_GLOBAL_GENERIC_BASE),
+        }
     }
 
     #[inline]
@@ -664,12 +876,10 @@ impl MoveGasMeter for StandardGasMeter {
         _ty: impl TypeView,
         _exists: bool,
     ) -> PartialVMResult<()> {
-        let params = &self.gas_params.instr;
-        let cost = match is_generic {
-            false => params.exists_base,
-            true => params.exists_generic_base,
-        };
-        self.charge_execution(cost)
+        match is_generic {
+            false => self.algebra.charge_execution(EXISTS_BASE),
+            true => self.algebra.charge_execution(EXISTS_GENERIC_BASE),
+        }
     }
 
     #[inline]
@@ -679,12 +889,10 @@ impl MoveGasMeter for StandardGasMeter {
         _ty: impl TypeView,
         _val: Option<impl ValueView>,
     ) -> PartialVMResult<()> {
-        let params = &self.gas_params.instr;
-        let cost = match is_generic {
-            false => params.move_from_base,
-            true => params.move_from_generic_base,
-        };
-        self.charge_execution(cost)
+        match is_generic {
+            false => self.algebra.charge_execution(MOVE_FROM_BASE),
+            true => self.algebra.charge_execution(MOVE_FROM_GENERIC_BASE),
+        }
     }
 
     #[inline]
@@ -695,12 +903,10 @@ impl MoveGasMeter for StandardGasMeter {
         _val: impl ValueView,
         _is_success: bool,
     ) -> PartialVMResult<()> {
-        let params = &self.gas_params.instr;
-        let cost = match is_generic {
-            false => params.move_to_base,
-            true => params.move_to_generic_base,
-        };
-        self.charge_execution(cost)
+        match is_generic {
+            false => self.algebra.charge_execution(MOVE_TO_BASE),
+            true => self.algebra.charge_execution(MOVE_TO_GENERIC_BASE),
+        }
     }
 
     #[inline]
@@ -711,9 +917,8 @@ impl MoveGasMeter for StandardGasMeter {
     ) -> PartialVMResult<()> {
         let num_args = NumArgs::new(args.len() as u64);
 
-        let params = &self.gas_params.instr;
-        let cost = params.vec_pack_base + params.vec_pack_per_elem * num_args;
-        self.charge_execution(cost)
+        self.algebra
+            .charge_execution(VEC_PACK_BASE + VEC_PACK_PER_ELEM * num_args)
     }
 
     #[inline]
@@ -723,15 +928,13 @@ impl MoveGasMeter for StandardGasMeter {
         expect_num_elements: NumArgs,
         _elems: impl ExactSizeIterator<Item = impl ValueView>,
     ) -> PartialVMResult<()> {
-        let params = &self.gas_params.instr;
-        let cost =
-            params.vec_unpack_base + params.vec_unpack_per_expected_elem * expect_num_elements;
-        self.charge_execution(cost)
+        self.algebra
+            .charge_execution(VEC_UNPACK_BASE + VEC_UNPACK_PER_EXPECTED_ELEM * expect_num_elements)
     }
 
     #[inline]
     fn charge_vec_len(&mut self, _ty: impl TypeView) -> PartialVMResult<()> {
-        self.charge_execution(self.gas_params.instr.vec_len_base)
+        self.algebra.charge_execution(VEC_LEN_BASE)
     }
 
     #[inline]
@@ -741,12 +944,10 @@ impl MoveGasMeter for StandardGasMeter {
         _ty: impl TypeView,
         _is_success: bool,
     ) -> PartialVMResult<()> {
-        let params = &self.gas_params.instr;
-        let cost = match is_mut {
-            false => params.vec_imm_borrow_base,
-            true => params.vec_mut_borrow_base,
-        };
-        self.charge_execution(cost)
+        match is_mut {
+            false => self.algebra.charge_execution(VEC_IMM_BORROW_BASE),
+            true => self.algebra.charge_execution(VEC_MUT_BORROW_BASE),
+        }
     }
 
     #[inline]
@@ -755,7 +956,7 @@ impl MoveGasMeter for StandardGasMeter {
         _ty: impl TypeView,
         _val: impl ValueView,
     ) -> PartialVMResult<()> {
-        self.charge_execution(self.gas_params.instr.vec_push_back_base)
+        self.algebra.charge_execution(VEC_PUSH_BACK_BASE)
     }
 
     #[inline]
@@ -764,12 +965,12 @@ impl MoveGasMeter for StandardGasMeter {
         _ty: impl TypeView,
         _val: Option<impl ValueView>,
     ) -> PartialVMResult<()> {
-        self.charge_execution(self.gas_params.instr.vec_pop_back_base)
+        self.algebra.charge_execution(VEC_POP_BACK_BASE)
     }
 
     #[inline]
     fn charge_vec_swap(&mut self, _ty: impl TypeView) -> PartialVMResult<()> {
-        self.charge_execution(self.gas_params.instr.vec_swap_base)
+        self.algebra.charge_execution(VEC_SWAP_BASE)
     }
 
     #[inline]
@@ -781,48 +982,20 @@ impl MoveGasMeter for StandardGasMeter {
     }
 }
 
-impl AptosGasMeter for StandardGasMeter {
-    fn feature_version(&self) -> u64 {
-        self.feature_version
-    }
-
-    fn gas_params(&self) -> &AptosGasParameters {
-        &self.gas_params
-    }
-
-    fn balance(&self) -> Gas {
-        self.balance
-            .to_unit_round_down_with_params(&self.gas_params.txn)
-    }
-
-    fn gas_unit_scaling_factor(&self) -> GasScalingFactor {
-        self.gas_params.txn.gas_unit_scaling_factor
-    }
+impl<A> AptosGasMeter for StandardGasMeter<A>
+where
+    A: GasAlgebra,
+{
+    type Algebra = A;
 
     #[inline]
-    fn charge_execution(&mut self, amount: InternalGas) -> PartialVMResult<()> {
-        self.charge(amount)?;
-
-        self.execution_gas_used += amount;
-        if self.feature_version >= 7
-            && self.execution_gas_used > self.gas_params.txn.max_execution_gas
-        {
-            Err(PartialVMError::new(StatusCode::EXECUTION_LIMIT_REACHED))
-        } else {
-            Ok(())
-        }
+    fn algebra(&self) -> &Self::Algebra {
+        &self.algebra
     }
 
     #[inline]
-    fn charge_io(&mut self, amount: InternalGas) -> PartialVMResult<()> {
-        self.charge(amount)?;
-
-        self.io_gas_used += amount;
-        if self.feature_version >= 7 && self.io_gas_used > self.gas_params.txn.max_io_gas {
-            Err(PartialVMError::new(StatusCode::IO_LIMIT_REACHED))
-        } else {
-            Ok(())
-        }
+    fn algebra_mut(&mut self) -> &mut Self::Algebra {
+        &mut self.algebra
     }
 
     #[inline]
@@ -831,92 +1004,43 @@ impl AptosGasMeter for StandardGasMeter {
         amount: Fee,
         gas_unit_price: FeePerGasUnit,
     ) -> PartialVMResult<()> {
-        let txn_params = &self.gas_params.txn;
-
-        // Because the storage fees are defined in terms of fixed APT costs, we need
-        // to convert them into gas units.
-        //
-        // u128 is used to protect against overflow and preserve as much precision as
-        // possible in the extreme cases.
-        fn div_ceil(n: u128, d: u128) -> u128 {
-            if n % d == 0 {
-                n / d
-            } else {
-                n / d + 1
-            }
-        }
-        let gas_consumed_internal = div_ceil(
-            (u64::from(amount) as u128) * (u64::from(txn_params.gas_unit_scaling_factor) as u128),
-            u64::from(gas_unit_price) as u128,
-        );
-        let gas_consumed_internal = InternalGas::new(
-            if gas_consumed_internal > u64::MAX as u128 {
-                error!(
-                    "Something's wrong in the gas schedule: gas_consumed_internal ({}) > u64::MAX",
-                    gas_consumed_internal
-                );
-                u64::MAX
-            } else {
-                gas_consumed_internal as u64
-            },
-        );
-
-        self.charge(gas_consumed_internal)?;
-
-        self.storage_fee_in_internal_units += gas_consumed_internal;
-        self.storage_fee_used += amount;
-        if self.feature_version >= 7 && self.storage_fee_used > self.gas_params.txn.max_storage_fee
-        {
-            return Err(PartialVMError::new(StatusCode::STORAGE_LIMIT_REACHED));
-        }
-
-        Ok(())
+        self.algebra.charge_storage_fee(amount, gas_unit_price)
     }
 
-    fn io_gas_per_write(&self, key: &StateKey, op: &WriteOp) -> InternalGas {
-        self.storage_gas_params.pricing.io_gas_per_write(key, op)
+    fn charge_io_gas_for_write(&mut self, key: &StateKey, op: &WriteOp) -> VMResult<()> {
+        let cost = self.storage_gas_params().pricing.io_gas_per_write(key, op);
+        self.algebra
+            .charge_io(cost)
+            .map_err(|e| e.finish(Location::Undefined))
     }
 
     fn storage_fee_per_write(&self, key: &StateKey, op: &WriteOp) -> Fee {
-        self.gas_params.txn.storage_fee_per_write(key, op)
+        self.gas_params().txn.storage_fee_per_write(key, op)
     }
 
     fn storage_fee_per_event(&self, event: &ContractEvent) -> Fee {
-        self.gas_params.txn.storage_fee_per_event(event)
+        self.gas_params().txn.storage_fee_per_event(event)
     }
 
     fn storage_discount_for_events(&self, total_cost: Fee) -> Fee {
-        self.gas_params.txn.storage_discount_for_events(total_cost)
+        self.gas_params()
+            .txn
+            .storage_discount_for_events(total_cost)
     }
 
     fn storage_fee_for_transaction_storage(&self, txn_size: NumBytes) -> Fee {
-        self.gas_params
+        self.gas_params()
             .txn
             .storage_fee_for_transaction_storage(txn_size)
     }
 
     fn charge_intrinsic_gas_for_transaction(&mut self, txn_size: NumBytes) -> VMResult<()> {
-        let cost = self.gas_params.txn.calculate_intrinsic_gas(txn_size);
-        self.charge_execution(cost)
-            .map_err(|e| e.finish(Location::Undefined))
-    }
-
-    fn execution_gas_used(&self) -> Gas {
-        self.execution_gas_used
-            .to_unit_round_up_with_params(&self.gas_params.txn)
-    }
-
-    fn io_gas_used(&self) -> Gas {
-        self.io_gas_used
-            .to_unit_round_up_with_params(&self.gas_params.txn)
-    }
-
-    fn storage_fee_used_in_gas_units(&self) -> Gas {
-        self.storage_fee_in_internal_units
-            .to_unit_round_up_with_params(&self.gas_params.txn)
-    }
+        let excess = txn_size
+            .checked_sub(self.gas_params().txn.large_transaction_cutoff)
+            .unwrap_or_else(|| 0.into());
 
-    fn storage_fee_used(&self) -> Fee {
-        self.storage_fee_used
+        self.algebra
+            .charge_execution(MIN_TRANSACTION_GAS_UNITS + INTRINSIC_GAS_PER_BYTE * excess)
+            .map_err(|e| e.finish(Location::Undefined))
     }
 }
diff --git a/aptos-move/aptos-gas/src/instr.rs b/aptos-move/aptos-gas/src/instr.rs
index aeea7f2ab09b7..f9940648348a0 100644
--- a/aptos-move/aptos-gas/src/instr.rs
+++ b/aptos-move/aptos-gas/src/instr.rs
@@ -6,13 +6,12 @@
 //! gas schedule.
 
 use crate::{algebra::InternalGasPerAbstractValueUnit, gas_meter::EXECUTION_GAS_MULTIPLIER as MUL};
-use move_binary_format::errors::PartialVMResult;
 use move_core_types::gas_algebra::{InternalGas, InternalGasPerArg, InternalGasPerByte};
-use move_vm_types::gas::SimpleInstruction;
 
 crate::params::define_gas_parameters!(
     InstructionGasParameters,
     "instr",
+    .instr,
     [
         // nop
         [nop: InternalGas, "nop", 10 * MUL],
@@ -40,7 +39,8 @@ crate::params::define_gas_parameters!(
         [
             ld_const_per_byte: InternalGasPerByte,
             "ld_const.per_byte",
-            35 * MUL
+            35 * MUL,
+            LD_CONST_PER_BYTE
         ],
         // borrow
         [imm_borrow_loc: InternalGas, "imm_borrow_loc", 60 * MUL],
@@ -204,64 +204,3 @@ crate::params::define_gas_parameters!(
         ],
     ]
 );
-
-impl InstructionGasParameters {
-    pub(crate) fn simple_instr_cost(
-        &self,
-        instr: SimpleInstruction,
-    ) -> PartialVMResult<InternalGas> {
-        use SimpleInstruction::*;
-
-        Ok(match instr {
-            Nop => self.nop,
-
-            Abort => self.abort,
-            Ret => self.ret,
-
-            LdU8 => self.ld_u8,
-            LdU16 => self.ld_u16,
-            LdU32 => self.ld_u32,
-            LdU64 => self.ld_u64,
-            LdU128 => self.ld_u128,
-            LdU256 => self.ld_u256,
-            LdTrue => self.ld_true,
-            LdFalse => self.ld_false,
-
-            ImmBorrowLoc => self.imm_borrow_loc,
-            MutBorrowLoc => self.mut_borrow_loc,
-            ImmBorrowField => self.imm_borrow_field,
-            MutBorrowField => self.mut_borrow_field,
-            ImmBorrowFieldGeneric => self.imm_borrow_field_generic,
-            MutBorrowFieldGeneric => self.mut_borrow_field_generic,
-            FreezeRef => self.freeze_ref,
-
-            CastU8 => self.cast_u8,
-            CastU16 => self.cast_u16,
-            CastU32 => self.cast_u32,
-            CastU64 => self.cast_u64,
-            CastU128 => self.cast_u128,
-            CastU256 => self.cast_u256,
-
-            Add => self.add,
-            Sub => self.sub,
-            Mul => self.mul,
-            Mod => self.mod_,
-            Div => self.div,
-
-            BitOr => self.bit_or,
-            BitAnd => self.bit_and,
-            Xor => self.xor,
-            Shl => self.shl,
-            Shr => self.shr,
-
-            Or => self.or,
-            And => self.and,
-            Not => self.not,
-
-            Lt => self.lt,
-            Gt => self.gt,
-            Le => self.le,
-            Ge => self.ge,
-        })
-    }
-}
diff --git a/aptos-move/aptos-gas/src/lib.rs b/aptos-move/aptos-gas/src/lib.rs
index e2a091c947d38..07f9de18a5947 100644
--- a/aptos-move/aptos-gas/src/lib.rs
+++ b/aptos-move/aptos-gas/src/lib.rs
@@ -24,6 +24,7 @@ mod natives;
 #[macro_use]
 mod params;
 
+mod abstract_algebra;
 mod algebra;
 mod aptos_framework;
 mod gas_meter;
@@ -34,10 +35,14 @@ mod move_stdlib;
 mod table;
 mod transaction;
 
+pub use abstract_algebra::{
+    gas_switches::*, GasAdd, GasAlgebra, GasExpression, GasExpressionVisitor, GasMul,
+};
 pub use algebra::*;
 pub use gas_meter::{
     AptosGasMeter, AptosGasParameters, FromOnChainGasSchedule, InitialGasSchedule,
-    NativeGasParameters, StandardGasMeter, ToOnChainGasSchedule, LATEST_GAS_FEATURE_VERSION,
+    NativeGasParameters, StandardGasAlgebra, StandardGasMeter, ToOnChainGasSchedule,
+    LATEST_GAS_FEATURE_VERSION,
 };
 pub use instr::InstructionGasParameters;
 pub use misc::{AbstractValueSizeGasParameters, MiscGasParameters};
diff --git a/aptos-move/aptos-gas/src/misc.rs b/aptos-move/aptos-gas/src/misc.rs
index 66e07e37aaa3b..0f148cd5bc3bb 100644
--- a/aptos-move/aptos-gas/src/misc.rs
+++ b/aptos-move/aptos-gas/src/misc.rs
@@ -12,6 +12,7 @@ use std::collections::BTreeMap;
 crate::params::define_gas_parameters!(
     AbstractValueSizeGasParameters,
     "misc.abs_val",
+    .misc.abs_val,
     [
         // abstract value size
         [u8: AbstractValueSize, "u8", 40],
diff --git a/aptos-move/aptos-gas/src/params.rs b/aptos-move/aptos-gas/src/params.rs
index 5f2603c8e2549..1bd3f40012a29 100644
--- a/aptos-move/aptos-gas/src/params.rs
+++ b/aptos-move/aptos-gas/src/params.rs
@@ -19,8 +19,9 @@ macro_rules! define_gas_parameters {
     (
         $params_name: ident,
         $prefix: literal,
+        $(.$field: ident)*,
         [$(
-            [$name: ident: $ty: ty, $key_bindings: tt, $initial: expr $(, $tn: ident)? $(,)?]
+            [$name: ident: $ty: ident, $key_bindings: tt, $initial: expr $(, $tn: ident)? $(,)?]
         ),* $(,)?]
     ) => {
         #[derive(Debug, Clone)]
@@ -76,12 +77,62 @@ macro_rules! define_gas_parameters {
         }
 
         pub mod gas_params {
+            use $crate::abstract_algebra::{GasExpression, GasExpressionVisitor, GasMul, GasAdd};
+            use std::ops::{Add, Mul};
+            use move_core_types::gas_algebra::{GasQuantity, GasQuantityGetUnit};
+
+            macro_rules! get {
+                ($gas_params: expr, $leaf: ident) => {
+                    $gas_params $(.$field)* .$leaf
+                }
+            }
+
             $(
-                $(
-                    /// Marker type representing the corresponding gas parameter.
+                paste::paste! {
+                    #[doc = "Type representing the `" $name "` gas parameter."]
                     #[allow(non_camel_case_types)]
-                    pub enum $tn {}
-                )?
+                    pub struct [<$name:upper>];
+
+                    impl GasExpression for [<$name:upper>] {
+                        type Unit =  <super::$ty as GasQuantityGetUnit>::Unit;
+
+                        fn materialize(
+                            &self,
+                            _feature_version: u64,
+                            gas_params: &$crate::gas_meter::AptosGasParameters,
+                        ) -> GasQuantity<Self::Unit> {
+                            get!(gas_params, $name)
+                        }
+
+                        fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
+                            visitor.gas_param::<Self>();
+                        }
+                    }
+
+                    impl<T> Add<T> for [<$name:upper>]
+                    where
+                        Self: GasExpression,
+                        T: GasExpression,
+                    {
+                        type Output = GasAdd<Self, T>;
+
+                        fn add(self, rhs: T) -> Self::Output {
+                            GasAdd { left: self, right: rhs }
+                        }
+                    }
+
+                    impl<T> Mul<T> for [<$name:upper>]
+                    where
+                        Self: GasExpression,
+                        T: GasExpression,
+                    {
+                        type Output = GasMul<Self, T>;
+
+                        fn mul(self, rhs: T) -> Self::Output {
+                            GasMul { left: self, right: rhs }
+                        }
+                    }
+                }
             )*
         }
 
diff --git a/aptos-move/aptos-gas/src/transaction/mod.rs b/aptos-move/aptos-gas/src/transaction/mod.rs
index df8f71898ef3f..98ef94481d0f4 100644
--- a/aptos-move/aptos-gas/src/transaction/mod.rs
+++ b/aptos-move/aptos-gas/src/transaction/mod.rs
@@ -4,9 +4,12 @@
 //! This module defines all the gas parameters for transactions, along with their initial values
 //! in the genesis and a mapping between the Rust representation and the on-chain gas schedule.
 
-use crate::algebra::{
-    AbstractValueSize, Fee, FeePerByte, FeePerGasUnit, FeePerSlot, Gas, GasScalingFactor, GasUnit,
-    NumSlots,
+use crate::{
+    abstract_algebra::GasExpression,
+    algebra::{
+        AbstractValueSize, Fee, FeePerByte, FeePerGasUnit, FeePerSlot, Gas, GasScalingFactor,
+        GasUnit, NumSlots,
+    },
 };
 use aptos_types::{
     contract_event::ContractEvent, state_store::state_key::StateKey, write_set::WriteOp,
@@ -18,6 +21,7 @@ use move_core_types::gas_algebra::{
 
 mod storage;
 
+use self::gas_params::{INTRINSIC_GAS_PER_BYTE, MIN_TRANSACTION_GAS_UNITS};
 pub use storage::{ChangeSetConfigs, StorageGasParameters, StoragePricing};
 
 const GAS_SCALING_FACTOR: u64 = 1_000_000;
@@ -25,6 +29,7 @@ const GAS_SCALING_FACTOR: u64 = 1_000_000;
 crate::params::define_gas_parameters!(
     TransactionGasParameters,
     "txn",
+    .txn,
     [
         // The flat minimum amount of gas required for any transaction.
         // Charged at the start of execution.
@@ -183,7 +188,7 @@ crate::params::define_gas_parameters!(
 impl TransactionGasParameters {
     // TODO(Gas): Right now we are relying on this to avoid div by zero errors when using the all-zero
     //            gas parameters. See if there's a better way we can handle this.
-    fn scaling_factor(&self) -> GasScalingFactor {
+    pub(crate) fn scaling_factor(&self) -> GasScalingFactor {
         match u64::from(self.gas_unit_scaling_factor) {
             0 => 1.into(),
             x => x.into(),
@@ -232,17 +237,15 @@ impl TransactionGasParameters {
     }
 
     /// Calculate the intrinsic gas for the transaction based upon its size in bytes.
-    pub fn calculate_intrinsic_gas(&self, transaction_size: NumBytes) -> InternalGas {
-        let min_transaction_fee = self.min_transaction_gas_units;
+    pub fn calculate_intrinsic_gas(
+        &self,
+        transaction_size: NumBytes,
+    ) -> impl GasExpression<Unit = InternalGasUnit> {
+        let excess = transaction_size
+            .checked_sub(self.large_transaction_cutoff)
+            .unwrap_or_else(|| 0.into());
 
-        if transaction_size > self.large_transaction_cutoff {
-            let excess = transaction_size
-                .checked_sub(self.large_transaction_cutoff)
-                .unwrap();
-            min_transaction_fee + (excess * self.intrinsic_gas_per_byte)
-        } else {
-            min_transaction_fee
-        }
+        MIN_TRANSACTION_GAS_UNITS + INTRINSIC_GAS_PER_BYTE * excess
     }
 }
 
diff --git a/aptos-move/aptos-gas/src/transaction/storage.rs b/aptos-move/aptos-gas/src/transaction/storage.rs
index eee9a9b78ca49..bcbe33e1a1fab 100644
--- a/aptos-move/aptos-gas/src/transaction/storage.rs
+++ b/aptos-move/aptos-gas/src/transaction/storage.rs
@@ -1,15 +1,21 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{AptosGasParameters, LATEST_GAS_FEATURE_VERSION};
+use crate::{
+    abstract_algebra::GasExpression, transaction::gas_params::*, AptosGasParameters,
+    LATEST_GAS_FEATURE_VERSION,
+};
 use aptos_types::{
     on_chain_config::{ConfigStorage, OnChainConfig, StorageGasSchedule},
     state_store::state_key::StateKey,
     write_set::WriteOp,
 };
 use aptos_vm_types::{change_set::VMChangeSet, check_change_set::CheckChangeSet};
+use either::Either;
 use move_core_types::{
-    gas_algebra::{InternalGas, InternalGasPerArg, InternalGasPerByte, NumArgs, NumBytes},
+    gas_algebra::{
+        InternalGas, InternalGasPerArg, InternalGasPerByte, InternalGasUnit, NumArgs, NumBytes,
+    },
     vm_status::{StatusCode, VMStatus},
 };
 use std::fmt::Debug;
@@ -178,10 +184,52 @@ impl StoragePricingV2 {
     }
 }
 
+// No storage curve. New gas parameter representation.
+#[derive(Debug, Clone)]
+pub struct StoragePricingV3 {
+    pub feature_version: u64,
+    pub free_write_bytes_quota: NumBytes,
+}
+
+impl StoragePricingV3 {
+    fn calculate_read_gas(&self, loaded: NumBytes) -> impl GasExpression<Unit = InternalGasUnit> {
+        STORAGE_IO_PER_STATE_SLOT_READ * NumArgs::from(1) + STORAGE_IO_PER_STATE_BYTE_READ * loaded
+    }
+
+    fn write_op_size(&self, key: &StateKey, value: &[u8]) -> NumBytes {
+        let value_size = NumBytes::new(value.len() as u64);
+        let key_size = NumBytes::new(key.size() as u64);
+
+        (key_size + value_size)
+            .checked_sub(self.free_write_bytes_quota)
+            .unwrap_or(NumBytes::zero())
+    }
+
+    fn io_gas_per_write(
+        &self,
+        key: &StateKey,
+        op: &WriteOp,
+    ) -> impl GasExpression<Unit = InternalGasUnit> {
+        use WriteOp::*;
+
+        match op {
+            Creation(data)
+            | CreationWithMetadata { data, .. }
+            | Modification(data)
+            | ModificationWithMetadata { data, .. } => Either::Left(
+                STORAGE_IO_PER_STATE_SLOT_WRITE * NumArgs::new(1)
+                    + STORAGE_IO_PER_STATE_BYTE_WRITE * self.write_op_size(key, data),
+            ),
+            Deletion | DeletionWithMetadata { .. } => Either::Right(InternalGas::zero()),
+        }
+    }
+}
+
 #[derive(Clone, Debug)]
 pub enum StoragePricing {
     V1(StoragePricingV1),
     V2(StoragePricingV2),
+    V3(StoragePricingV3),
 }
 
 impl StoragePricing {
@@ -209,27 +257,37 @@ impl StoragePricing {
         }
     }
 
-    pub fn calculate_read_gas(&self, resource_exists: bool, bytes_loaded: NumBytes) -> InternalGas {
+    pub fn calculate_read_gas(
+        &self,
+        resource_exists: bool,
+        bytes_loaded: NumBytes,
+    ) -> impl GasExpression<Unit = InternalGasUnit> {
         use StoragePricing::*;
 
         match self {
-            V1(v1) => v1.calculate_read_gas(
+            V1(v1) => Either::Left(v1.calculate_read_gas(
                 if resource_exists {
                     Some(bytes_loaded)
                 } else {
                     None
                 },
-            ),
-            V2(v2) => v2.calculate_read_gas(bytes_loaded),
+            )),
+            V2(v2) => Either::Left(v2.calculate_read_gas(bytes_loaded)),
+            V3(v3) => Either::Right(v3.calculate_read_gas(bytes_loaded)),
         }
     }
 
-    pub fn io_gas_per_write(&self, key: &StateKey, op: &WriteOp) -> InternalGas {
+    pub fn io_gas_per_write(
+        &self,
+        key: &StateKey,
+        op: &WriteOp,
+    ) -> impl GasExpression<Unit = InternalGasUnit> {
         use StoragePricing::*;
 
         match self {
-            V1(v1) => v1.io_gas_per_write(key, op),
-            V2(v2) => v2.io_gas_per_write(key, op),
+            V1(v1) => Either::Left(v1.io_gas_per_write(key, op)),
+            V2(v2) => Either::Left(v2.io_gas_per_write(key, op)),
+            V3(v3) => Either::Right(v3.io_gas_per_write(key, op)),
         }
     }
 }
diff --git a/aptos-move/aptos-memory-usage-tracker/src/lib.rs b/aptos-move/aptos-memory-usage-tracker/src/lib.rs
index ab5832ebe9484..b7e1d40eef8d6 100644
--- a/aptos-move/aptos-memory-usage-tracker/src/lib.rs
+++ b/aptos-move/aptos-memory-usage-tracker/src/lib.rs
@@ -2,8 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use aptos_gas::{
-    AbstractValueSize, AptosGasMeter, AptosGasParameters, Fee, FeePerGasUnit, Gas,
-    GasScalingFactor, InternalGas, NumArgs, NumBytes,
+    AbstractValueSize, AptosGasMeter, Fee, FeePerGasUnit, InternalGas, NumArgs, NumBytes,
 };
 use aptos_types::{
     account_config::CORE_CODE_ADDRESS, contract_event::ContractEvent,
@@ -460,16 +459,10 @@ impl<G> AptosGasMeter for MemoryTrackedGasMeter<G>
 where
     G: AptosGasMeter,
 {
-    delegate! {
-        fn feature_version(&self) -> u64;
-
-        fn gas_params(&self) -> &AptosGasParameters;
-
-        fn balance(&self) -> Gas;
+    type Algebra = G::Algebra;
 
-        fn gas_unit_scaling_factor(&self) -> GasScalingFactor;
-
-        fn io_gas_per_write(&self, key: &StateKey, op: &WriteOp) -> InternalGas;
+    delegate! {
+        fn algebra(&self) -> &Self::Algebra;
 
         fn storage_fee_per_write(&self, key: &StateKey, op: &WriteOp) -> Fee;
 
@@ -478,20 +471,12 @@ where
         fn storage_discount_for_events(&self, total_cost: Fee) -> Fee;
 
         fn storage_fee_for_transaction_storage(&self, txn_size: NumBytes) -> Fee;
-
-        fn execution_gas_used(&self) -> Gas;
-
-        fn io_gas_used(&self) -> Gas;
-
-        fn storage_fee_used_in_gas_units(&self) -> Gas;
-
-        fn storage_fee_used(&self) -> Fee;
     }
 
     delegate_mut! {
-        fn charge_execution(&mut self, amount: InternalGas) -> PartialVMResult<()>;
+        fn algebra_mut(&mut self) -> &mut Self::Algebra;
 
-        fn charge_io(&mut self, amount: InternalGas) -> PartialVMResult<()>;
+        fn charge_io_gas_for_write(&mut self, key: &StateKey, op: &WriteOp) -> VMResult<()>;
 
         fn charge_storage_fee(
             &mut self,
@@ -500,7 +485,5 @@ where
         ) -> PartialVMResult<()>;
 
         fn charge_intrinsic_gas_for_transaction(&mut self, txn_size: NumBytes) -> VMResult<()>;
-
-
     }
 }
diff --git a/aptos-move/aptos-vm/src/aptos_vm.rs b/aptos-move/aptos-vm/src/aptos_vm.rs
index 215348768f9bf..9e48fb4a0574f 100644
--- a/aptos-move/aptos-vm/src/aptos_vm.rs
+++ b/aptos-move/aptos-vm/src/aptos_vm.rs
@@ -23,7 +23,7 @@ use aptos_block_executor::txn_commit_hook::NoOpTransactionCommitHook;
 use aptos_crypto::HashValue;
 use aptos_framework::natives::code::PublishRequest;
 use aptos_gas::{
-    AptosGasMeter, AptosGasParameters, ChangeSetConfigs, Gas, StandardGasMeter,
+    AptosGasMeter, AptosGasParameters, ChangeSetConfigs, Gas, StandardGasAlgebra, StandardGasMeter,
     StorageGasParameters,
 };
 use aptos_logger::{enabled, prelude::*, Level};
@@ -489,7 +489,11 @@ impl AptosVM {
         txn_data: &TransactionMetadata,
     ) -> Result<RespawnedSession<'r, 'l>, VMStatus> {
         let change_set = session.finish(&mut (), change_set_configs)?;
-        gas_meter.charge_io_gas_for_write_set(change_set.write_set().iter())?;
+
+        for (key, op) in change_set.write_set() {
+            gas_meter.charge_io_gas_for_write(key, op)?;
+        }
+
         gas_meter.charge_storage_fee_for_all(
             change_set.write_set().iter(),
             change_set.events(),
@@ -1007,12 +1011,14 @@ impl AptosVM {
         &self,
         balance: Gas,
         log_context: &AdapterLogSchema,
-    ) -> Result<MemoryTrackedGasMeter<StandardGasMeter>, VMStatus> {
+    ) -> Result<MemoryTrackedGasMeter<StandardGasMeter<StandardGasAlgebra>>, VMStatus> {
         Ok(MemoryTrackedGasMeter::new(StandardGasMeter::new(
-            self.0.get_gas_feature_version(),
-            self.0.get_gas_parameters(log_context)?.clone(),
-            self.0.get_storage_gas_parameters(log_context)?.clone(),
-            balance,
+            StandardGasAlgebra::new(
+                self.0.get_gas_feature_version(),
+                self.0.get_gas_parameters(log_context)?.clone(),
+                self.0.get_storage_gas_parameters(log_context)?.clone(),
+                balance,
+            ),
         )))
     }
 
@@ -1398,12 +1404,13 @@ impl AptosVM {
     ) -> Result<Vec<Vec<u8>>> {
         let vm = AptosVM::new(state_view);
         let log_context = AdapterLogSchema::new(state_view.id(), 0);
-        let mut gas_meter = MemoryTrackedGasMeter::new(StandardGasMeter::new(
-            vm.0.get_gas_feature_version(),
-            vm.0.get_gas_parameters(&log_context)?.clone(),
-            vm.0.get_storage_gas_parameters(&log_context)?.clone(),
-            gas_budget,
-        ));
+        let mut gas_meter =
+            MemoryTrackedGasMeter::new(StandardGasMeter::new(StandardGasAlgebra::new(
+                vm.0.get_gas_feature_version(),
+                vm.0.get_gas_parameters(&log_context)?.clone(),
+                vm.0.get_storage_gas_parameters(&log_context)?.clone(),
+                gas_budget,
+            )));
         let resolver = vm.as_move_resolver(state_view);
         let mut session = vm.new_session(&resolver, SessionId::Void, true);
 
@@ -1840,12 +1847,13 @@ impl AptosSimulationVM {
             Ok(s) => s,
         };
 
-        let mut gas_meter = MemoryTrackedGasMeter::new(StandardGasMeter::new(
-            self.0 .0.get_gas_feature_version(),
-            gas_params.clone(),
-            storage_gas_params.clone(),
-            txn_data.max_gas_amount(),
-        ));
+        let mut gas_meter =
+            MemoryTrackedGasMeter::new(StandardGasMeter::new(StandardGasAlgebra::new(
+                self.0 .0.get_gas_feature_version(),
+                gas_params.clone(),
+                storage_gas_params.clone(),
+                txn_data.max_gas_amount(),
+            )));
 
         let mut new_published_modules_loaded = false;
         let result = match txn.payload() {
diff --git a/aptos-move/aptos-vm/src/aptos_vm_impl.rs b/aptos-move/aptos-vm/src/aptos_vm_impl.rs
index c701190a8ac3f..71c0ea2d70f29 100644
--- a/aptos-move/aptos-vm/src/aptos_vm_impl.rs
+++ b/aptos-move/aptos-vm/src/aptos_vm_impl.rs
@@ -14,7 +14,7 @@ use crate::{
 use aptos_framework::RuntimeModuleMetadataV1;
 use aptos_gas::{
     AbstractValueSizeGasParameters, AptosGasParameters, ChangeSetConfigs, FromOnChainGasSchedule,
-    Gas, NativeGasParameters, StorageGasParameters, StoragePricing,
+    Gas, GasExpression, NativeGasParameters, StorageGasParameters, StoragePricing,
 };
 use aptos_logger::{enabled, prelude::*, Level};
 use aptos_state_view::StateView;
@@ -211,7 +211,8 @@ impl AptosVMImpl {
         txn_data: &TransactionMetadata,
         log_context: &AdapterLogSchema,
     ) -> Result<(), VMStatus> {
-        let txn_gas_params = &self.get_gas_parameters(log_context)?.txn;
+        let gas_params = self.get_gas_parameters(log_context)?;
+        let txn_gas_params = &gas_params.txn;
         let raw_bytes_len = txn_data.transaction_size;
         // The transaction is too large.
         if txn_data.transaction_size > txn_gas_params.max_transaction_size_in_bytes {
@@ -278,8 +279,9 @@ impl AptosVMImpl {
         // The submitted transactions max gas units needs to be at least enough to cover the
         // intrinsic cost of the transaction as calculated against the size of the
         // underlying `RawTransaction`
-        let intrinsic_gas: Gas = txn_gas_params
+        let intrinsic_gas = txn_gas_params
             .calculate_intrinsic_gas(raw_bytes_len)
+            .materialize(self.gas_feature_version, gas_params)
             .to_unit_round_up_with_params(txn_gas_params);
 
         if txn_data.max_gas_amount() < intrinsic_gas {
diff --git a/aptos-move/e2e-tests/src/account_universe/bad_transaction.rs b/aptos-move/e2e-tests/src/account_universe/bad_transaction.rs
index ee504bb93f9f0..4990ab5be1426 100644
--- a/aptos-move/e2e-tests/src/account_universe/bad_transaction.rs
+++ b/aptos-move/e2e-tests/src/account_universe/bad_transaction.rs
@@ -11,7 +11,10 @@ use aptos_crypto::{
     ed25519::{Ed25519PrivateKey, Ed25519PublicKey},
     test_utils::KeyPair,
 };
-use aptos_gas::{FeePerGasUnit, Gas, InitialGasSchedule, TransactionGasParameters};
+use aptos_gas::{
+    AptosGasParameters, FeePerGasUnit, Gas, GasExpression, InitialGasSchedule,
+    LATEST_GAS_FEATURE_VERSION,
+};
 use aptos_proptest_helpers::Index;
 use aptos_types::{
     transaction::{Script, SignedTransaction, TransactionStatus},
@@ -87,11 +90,13 @@ impl AUTransactionGen for InsufficientBalanceGen {
         );
 
         // TODO: Move such config to AccountUniverse
-        let txn_gas_params = TransactionGasParameters::initial();
+        let gas_params = AptosGasParameters::initial();
+        let txn_gas_params = &gas_params.txn;
         let raw_bytes_len = txn.raw_txn_bytes_len() as u64;
         let min_cost: Gas = txn_gas_params
             .calculate_intrinsic_gas(raw_bytes_len.into())
-            .to_unit_round_up_with_params(&txn_gas_params);
+            .materialize(LATEST_GAS_FEATURE_VERSION, &gas_params)
+            .to_unit_round_up_with_params(txn_gas_params);
 
         (
             txn,
diff --git a/aptos-move/e2e-tests/src/executor.rs b/aptos-move/e2e-tests/src/executor.rs
index ad4034bb9a8f1..3fb51e7cc852b 100644
--- a/aptos-move/e2e-tests/src/executor.rs
+++ b/aptos-move/e2e-tests/src/executor.rs
@@ -18,8 +18,8 @@ use aptos_block_executor::txn_commit_hook::NoOpTransactionCommitHook;
 use aptos_crypto::HashValue;
 use aptos_framework::ReleaseBundle;
 use aptos_gas::{
-    AbstractValueSizeGasParameters, ChangeSetConfigs, NativeGasParameters, StandardGasMeter,
-    LATEST_GAS_FEATURE_VERSION,
+    AbstractValueSizeGasParameters, ChangeSetConfigs, NativeGasParameters, StandardGasAlgebra,
+    StandardGasMeter, LATEST_GAS_FEATURE_VERSION,
 };
 use aptos_gas_profiling::{GasProfiler, TransactionGasLog};
 use aptos_keygen::KeyGen;
@@ -512,12 +512,13 @@ impl FakeExecutor {
                 &txn,
                 &log_context,
                 |gas_feature_version, gas_params, storage_gas_params, balance| {
-                    let gas_meter = MemoryTrackedGasMeter::new(StandardGasMeter::new(
-                        gas_feature_version,
-                        gas_params,
-                        storage_gas_params,
-                        balance,
-                    ));
+                    let gas_meter =
+                        MemoryTrackedGasMeter::new(StandardGasMeter::new(StandardGasAlgebra::new(
+                            gas_feature_version,
+                            gas_params,
+                            storage_gas_params,
+                            balance,
+                        )));
                     let gas_profiler = match txn.payload() {
                         TransactionPayload::Script(_) => GasProfiler::new_script(gas_meter),
                         TransactionPayload::EntryFunction(entry_func) => GasProfiler::new_function(
diff --git a/aptos-move/e2e-testsuite/src/tests/failed_transaction_tests.rs b/aptos-move/e2e-testsuite/src/tests/failed_transaction_tests.rs
index e4d829276815d..e83317d44c2b0 100644
--- a/aptos-move/e2e-testsuite/src/tests/failed_transaction_tests.rs
+++ b/aptos-move/e2e-testsuite/src/tests/failed_transaction_tests.rs
@@ -3,7 +3,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use aptos_gas::{
-    AptosGasParameters, StandardGasMeter, StorageGasParameters, LATEST_GAS_FEATURE_VERSION,
+    AptosGasParameters, StandardGasAlgebra, StandardGasMeter, StorageGasParameters,
+    LATEST_GAS_FEATURE_VERSION,
 };
 use aptos_language_e2e_tests::{common_transactions::peer_to_peer_txn, executor::FakeExecutor};
 use aptos_memory_usage_tracker::MemoryTrackedGasMeter;
@@ -40,12 +41,12 @@ fn failed_transaction_cleanup_test() {
 
     let change_set_configs = storage_gas_params.change_set_configs.clone();
 
-    let mut gas_meter = MemoryTrackedGasMeter::new(StandardGasMeter::new(
+    let mut gas_meter = MemoryTrackedGasMeter::new(StandardGasMeter::new(StandardGasAlgebra::new(
         LATEST_GAS_FEATURE_VERSION,
         gas_params,
         storage_gas_params,
         10_000,
-    ));
+    )));
 
     // TYPE_MISMATCH should be kept and charged.
     let out1 = aptos_vm.failed_transaction_cleanup(
diff --git a/third_party/move/move-core/types/src/gas_algebra.rs b/third_party/move/move-core/types/src/gas_algebra.rs
index c6231a011e41f..60bbaa8b0c65f 100644
--- a/third_party/move/move-core/types/src/gas_algebra.rs
+++ b/third_party/move/move-core/types/src/gas_algebra.rs
@@ -77,6 +77,18 @@ pub type InternalGasPerAbstractMemoryUnit =
 
 pub type InternalGasPerArg = GasQuantity<UnitDiv<InternalGasUnit, Arg>>;
 
+/***************************************************************************************************
+ * Get Unit
+ *
+ **************************************************************************************************/
+pub trait GasQuantityGetUnit {
+    type Unit;
+}
+
+impl<U> GasQuantityGetUnit for GasQuantity<U> {
+    type Unit = U;
+}
+
 /***************************************************************************************************
  * Constructors
  *

From 5ed4e00b53ea2b174f8c02c66b96367cde6f31c5 Mon Sep 17 00:00:00 2001
From: Victor Gao <vgao1996@gmail.com>
Date: Sun, 9 Jul 2023 10:21:42 +0000
Subject: [PATCH 2/4] [gas] abstract gas algebra part 2 -- move algebra & gas
 params into separate crates

---
 Cargo.lock                                    |  34 +-
 Cargo.toml                                    |   6 +-
 aptos-move/aptos-debugger/Cargo.toml          |   1 +
 aptos-move/aptos-debugger/src/lib.rs          |   3 +-
 .../Cargo.toml                                |   5 +-
 .../aptos-gas-algebra/src/abstract_algebra.rs | 211 ++++++++++
 aptos-move/aptos-gas-algebra/src/algebra.rs   |  56 +++
 aptos-move/aptos-gas-algebra/src/lib.rs       |   8 +
 aptos-move/aptos-gas-profiling/Cargo.toml     |   1 +
 .../aptos-gas-profiling/src/aggregate.rs      |   2 +-
 aptos-move/aptos-gas-profiling/src/erased.rs  |   2 +-
 aptos-move/aptos-gas-profiling/src/log.rs     |   3 +-
 .../aptos-gas-profiling/src/profiler.rs       |  10 +-
 .../aptos-gas-profiling/src/textualize.rs     |   2 +-
 aptos-move/aptos-gas-schedule/Cargo.toml      |  22 ++
 .../instr.rs => aptos-gas-schedule/run.py}    |  28 +-
 .../src/gas_params/instr.rs                   | 203 ++++++++++
 .../src/gas_params/macros.rs}                 |  32 +-
 .../src/gas_params}/misc.rs                   |   8 +-
 .../aptos-gas-schedule/src/gas_params/mod.rs  |  73 ++++
 .../src/gas_params}/storage.rs                |  16 +-
 .../src/gas_params/transaction.rs}            |  36 +-
 aptos-move/aptos-gas-schedule/src/lib.rs      |  10 +
 aptos-move/aptos-gas-schedule/src/traits.rs   |  29 ++
 aptos-move/aptos-gas-schedule/src/ver.rs      |  36 ++
 aptos-move/aptos-gas/Cargo.toml               |   3 +-
 aptos-move/aptos-gas/src/abstract_algebra.rs  | 359 ------------------
 aptos-move/aptos-gas/src/algebra.rs           |  30 --
 aptos-move/aptos-gas/src/gas_meter.rs         | 111 ++----
 aptos-move/aptos-gas/src/gen.rs               |   5 +-
 aptos-move/aptos-gas/src/lib.rs               |  22 --
 aptos-move/aptos-gas/src/natives.rs           |   2 +-
 .../aptos-memory-usage-tracker/Cargo.toml     |   1 +
 .../aptos-memory-usage-tracker/src/lib.rs     |   9 +-
 aptos-move/aptos-vm/Cargo.toml                |   2 +
 aptos-move/aptos-vm/src/aptos_vm.rs           |   3 +-
 aptos-move/aptos-vm/src/aptos_vm_impl.rs      |   3 +-
 aptos-move/aptos-vm/src/natives.rs            |   3 +-
 .../aptos-vm/src/transaction_metadata.rs      |   2 +-
 aptos-move/e2e-move-tests/Cargo.toml          |   1 +
 .../src/tests/per_category_gas_limits.rs      |   2 +-
 aptos-move/e2e-tests/Cargo.toml               |   2 +
 .../src/account_universe/bad_transaction.rs   |   7 +-
 aptos-move/e2e-tests/src/executor.rs          |   3 +-
 aptos-move/framework/Cargo.toml               |   2 +-
 aptos-move/framework/src/natives/event.rs     |   2 +-
 aptos-move/framework/src/natives/helpers.rs   |  11 +-
 aptos-move/framework/src/natives/mod.rs       |   2 +-
 aptos-move/gas-algebra-ext/src/lib.rs         |  13 -
 aptos-move/move-examples/Cargo.toml           |   1 +
 .../move-examples/tests/move_unit_tests.rs    |   3 +-
 aptos-move/vm-genesis/Cargo.toml              |   1 +
 aptos-move/vm-genesis/src/lib.rs              |   5 +-
 crates/aptos/Cargo.toml                       |   1 +
 .../src/move_tool/aptos_debug_natives.rs      |   3 +-
 testsuite/smoke-test/Cargo.toml               |   1 +
 testsuite/smoke-test/src/upgrade.rs           |   3 +-
 .../move/move-core/types/src/gas_algebra.rs   |  39 +-
 58 files changed, 859 insertions(+), 635 deletions(-)
 rename aptos-move/{gas-algebra-ext => aptos-gas-algebra}/Cargo.toml (78%)
 create mode 100644 aptos-move/aptos-gas-algebra/src/abstract_algebra.rs
 create mode 100644 aptos-move/aptos-gas-algebra/src/algebra.rs
 create mode 100644 aptos-move/aptos-gas-algebra/src/lib.rs
 create mode 100644 aptos-move/aptos-gas-schedule/Cargo.toml
 rename aptos-move/{aptos-gas/src/instr.rs => aptos-gas-schedule/run.py} (92%)
 create mode 100644 aptos-move/aptos-gas-schedule/src/gas_params/instr.rs
 rename aptos-move/{aptos-gas/src/params.rs => aptos-gas-schedule/src/gas_params/macros.rs} (79%)
 rename aptos-move/{aptos-gas/src => aptos-gas-schedule/src/gas_params}/misc.rs (98%)
 create mode 100644 aptos-move/aptos-gas-schedule/src/gas_params/mod.rs
 rename aptos-move/{aptos-gas/src/transaction => aptos-gas-schedule/src/gas_params}/storage.rs (96%)
 rename aptos-move/{aptos-gas/src/transaction/mod.rs => aptos-gas-schedule/src/gas_params/transaction.rs} (91%)
 create mode 100644 aptos-move/aptos-gas-schedule/src/lib.rs
 create mode 100644 aptos-move/aptos-gas-schedule/src/traits.rs
 create mode 100644 aptos-move/aptos-gas-schedule/src/ver.rs
 delete mode 100644 aptos-move/aptos-gas/src/abstract_algebra.rs
 delete mode 100644 aptos-move/aptos-gas/src/algebra.rs
 delete mode 100644 aptos-move/gas-algebra-ext/src/lib.rs

diff --git a/Cargo.lock b/Cargo.lock
index 5ed1cef2bf5af..81fc6f5bede6d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -208,6 +208,7 @@ dependencies = [
  "aptos-framework",
  "aptos-gas",
  "aptos-gas-profiling",
+ "aptos-gas-schedule",
  "aptos-genesis",
  "aptos-github-client",
  "aptos-global-constants",
@@ -1008,6 +1009,7 @@ dependencies = [
  "aptos-crypto",
  "aptos-gas",
  "aptos-gas-profiling",
+ "aptos-gas-schedule",
  "aptos-logger",
  "aptos-memory-usage-tracker",
  "aptos-resource-viewer",
@@ -1413,7 +1415,7 @@ dependencies = [
  "aptos-aggregator",
  "aptos-crypto",
  "aptos-gas",
- "aptos-gas-algebra-ext",
+ "aptos-gas-algebra",
  "aptos-language-e2e-tests",
  "aptos-move-stdlib",
  "aptos-sdk-builder",
@@ -1531,7 +1533,8 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "aptos-framework",
- "aptos-gas-algebra-ext",
+ "aptos-gas-algebra",
+ "aptos-gas-schedule",
  "aptos-global-constants",
  "aptos-logger",
  "aptos-move-stdlib",
@@ -1551,9 +1554,10 @@ dependencies = [
 ]
 
 [[package]]
-name = "aptos-gas-algebra-ext"
+name = "aptos-gas-algebra"
 version = "0.0.1"
 dependencies = [
+ "either",
  "move-core-types",
 ]
 
@@ -1564,6 +1568,7 @@ dependencies = [
  "anyhow",
  "aptos-framework",
  "aptos-gas",
+ "aptos-gas-algebra",
  "aptos-package-builder",
  "aptos-types",
  "inferno",
@@ -1574,6 +1579,20 @@ dependencies = [
  "smallvec",
 ]
 
+[[package]]
+name = "aptos-gas-schedule"
+version = "0.1.0"
+dependencies = [
+ "aptos-gas-algebra",
+ "aptos-global-constants",
+ "aptos-types",
+ "aptos-vm-types",
+ "either",
+ "move-core-types",
+ "move-vm-types",
+ "paste",
+]
+
 [[package]]
 name = "aptos-genesis"
 version = "0.1.0"
@@ -2028,7 +2047,9 @@ dependencies = [
  "aptos-crypto",
  "aptos-framework",
  "aptos-gas",
+ "aptos-gas-algebra",
  "aptos-gas-profiling",
+ "aptos-gas-schedule",
  "aptos-keygen",
  "aptos-memory-usage-tracker",
  "aptos-proptest-helpers",
@@ -2107,6 +2128,7 @@ name = "aptos-memory-usage-tracker"
 version = "0.1.0"
 dependencies = [
  "aptos-gas",
+ "aptos-gas-algebra",
  "aptos-types",
  "move-binary-format",
  "move-core-types",
@@ -2196,6 +2218,7 @@ name = "aptos-move-examples"
 version = "0.1.0"
 dependencies = [
  "aptos-gas",
+ "aptos-gas-schedule",
  "aptos-types",
  "aptos-vm",
  "clap 4.3.5",
@@ -3518,6 +3541,8 @@ dependencies = [
  "aptos-crypto-derive",
  "aptos-framework",
  "aptos-gas",
+ "aptos-gas-algebra",
+ "aptos-gas-schedule",
  "aptos-infallible",
  "aptos-language-e2e-tests",
  "aptos-logger",
@@ -3580,6 +3605,7 @@ dependencies = [
  "aptos-crypto",
  "aptos-framework",
  "aptos-gas",
+ "aptos-gas-schedule",
  "aptos-proptest-helpers",
  "aptos-state-view",
  "aptos-types",
@@ -5747,6 +5773,7 @@ dependencies = [
  "aptos-crypto",
  "aptos-framework",
  "aptos-gas",
+ "aptos-gas-algebra",
  "aptos-gas-profiling",
  "aptos-keygen",
  "aptos-language-e2e-tests",
@@ -11632,6 +11659,7 @@ dependencies = [
  "aptos-forge",
  "aptos-framework",
  "aptos-gas",
+ "aptos-gas-algebra",
  "aptos-genesis",
  "aptos-global-constants",
  "aptos-indexer",
diff --git a/Cargo.toml b/Cargo.toml
index 39ec40a446bda..7ba6bbfe0c660 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,7 +9,9 @@ members = [
     "aptos-move/aptos-aggregator",
     "aptos-move/aptos-debugger",
     "aptos-move/aptos-gas",
+    "aptos-move/aptos-gas-algebra",
     "aptos-move/aptos-gas-profiling",
+    "aptos-move/aptos-gas-schedule",
     "aptos-move/aptos-memory-usage-tracker",
     "aptos-move/aptos-release-builder",
     "aptos-move/aptos-resource-viewer",
@@ -28,7 +30,6 @@ members = [
     "aptos-move/e2e-testsuite",
     "aptos-move/framework",
     "aptos-move/framework/cached-packages",
-    "aptos-move/gas-algebra-ext",
     "aptos-move/move-examples",
     "aptos-move/mvhashmap",
     "aptos-move/package-builder",
@@ -297,8 +298,9 @@ aptos-framework = { path = "aptos-move/framework" }
 aptos-fuzzer = { path = "testsuite/aptos-fuzzer" }
 fuzzer = { path = "testsuite/fuzzer" }
 aptos-gas = { path = "aptos-move/aptos-gas" }
-aptos-gas-algebra-ext = { path = "aptos-move/gas-algebra-ext" }
+aptos-gas-algebra = { path = "aptos-move/aptos-gas-algebra" }
 aptos-gas-profiling = { path = "aptos-move/aptos-gas-profiling" }
+aptos-gas-schedule = { path = "aptos-move/aptos-gas-schedule" }
 aptos-genesis = { path = "crates/aptos-genesis" }
 aptos-github-client = { path = "crates/aptos-github-client" }
 aptos-global-constants = { path = "config/global-constants" }
diff --git a/aptos-move/aptos-debugger/Cargo.toml b/aptos-move/aptos-debugger/Cargo.toml
index de1dd8c28aa26..e41975f907771 100644
--- a/aptos-move/aptos-debugger/Cargo.toml
+++ b/aptos-move/aptos-debugger/Cargo.toml
@@ -12,6 +12,7 @@ edition = "2021"
 [dependencies]
 anyhow = { workspace = true }
 aptos-crypto = { workspace = true }
+aptos-gas-schedule = { workspace = true }
 aptos-gas = { workspace = true }
 aptos-gas-profiling = { workspace = true }
 aptos-logger = { workspace = true }
diff --git a/aptos-move/aptos-debugger/src/lib.rs b/aptos-move/aptos-debugger/src/lib.rs
index 028d9c6791319..f00512646a62b 100644
--- a/aptos-move/aptos-debugger/src/lib.rs
+++ b/aptos-move/aptos-debugger/src/lib.rs
@@ -4,9 +4,10 @@
 use anyhow::{format_err, Result};
 use aptos_gas::{
     AbstractValueSizeGasParameters, ChangeSetConfigs, NativeGasParameters, StandardGasAlgebra,
-    StandardGasMeter, LATEST_GAS_FEATURE_VERSION,
+    StandardGasMeter,
 };
 use aptos_gas_profiling::{GasProfiler, TransactionGasLog};
+use aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION;
 use aptos_memory_usage_tracker::MemoryTrackedGasMeter;
 use aptos_resource_viewer::{AnnotatedAccountStateBlob, AptosValueAnnotator};
 use aptos_rest_client::Client;
diff --git a/aptos-move/gas-algebra-ext/Cargo.toml b/aptos-move/aptos-gas-algebra/Cargo.toml
similarity index 78%
rename from aptos-move/gas-algebra-ext/Cargo.toml
rename to aptos-move/aptos-gas-algebra/Cargo.toml
index 122e5f3854805..c7d2077281514 100644
--- a/aptos-move/gas-algebra-ext/Cargo.toml
+++ b/aptos-move/aptos-gas-algebra/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
-name = "aptos-gas-algebra-ext"
-description = "Gas Algebra Ext"
+name = "aptos-gas-algebra"
+description = "Aptos Gas Algebra"
 version = "0.0.1"
 
 # Workspace inherited keys
@@ -13,4 +13,5 @@ repository = { workspace = true }
 rust-version = { workspace = true }
 
 [dependencies]
+either = { workspace = true }
 move-core-types = { workspace = true }
diff --git a/aptos-move/aptos-gas-algebra/src/abstract_algebra.rs b/aptos-move/aptos-gas-algebra/src/abstract_algebra.rs
new file mode 100644
index 0000000000000..6f95bfec2ea0f
--- /dev/null
+++ b/aptos-move/aptos-gas-algebra/src/abstract_algebra.rs
@@ -0,0 +1,211 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+use either::Either;
+use move_core_types::gas_algebra::GasQuantity;
+use std::ops::{Add, Mul};
+
+/***************************************************************************************************
+ * Gas Expression & Visitor
+ *
+ **************************************************************************************************/
+/// Trait representing an abstract view over an expression that is used to represent some
+/// gas amount.
+///
+/// It carries a type parameter `E`, indicating an environment in which the expression can be
+/// evaluated/materialized.
+pub trait GasExpression<E> {
+    type Unit;
+
+    fn materialize(&self, feature_version: u64, env: &E) -> GasQuantity<Self::Unit>;
+
+    fn visit(&self, visitor: &mut impl GasExpressionVisitor);
+}
+
+/// An interface for performing post-order traversal of the tree structure of a gas expression.
+///
+/// Alternatively, one could think that the callbacks are invoked following the Reverse Polish
+/// notation of the expression.
+///
+/// Here are a few examples:
+/// - `1 + 2`
+///   - `quantity(1)`
+///   - `quantity(2)`
+///   - `add()`
+/// - `A + B * 50`
+///   - `gas_param<A>()`
+///   - `gas_param<B>()`
+///   - `quantity(50)`
+///   - `mul()`
+///   - `add()`
+pub trait GasExpressionVisitor {
+    fn add(&mut self);
+
+    fn mul(&mut self);
+
+    fn gas_param<P>(&mut self);
+
+    fn quantity<U>(&mut self, quantity: GasQuantity<U>);
+}
+
+/***************************************************************************************************
+ * Built-in Gas Expressions
+ *
+ **************************************************************************************************/
+#[derive(Debug, Clone)]
+pub struct GasAdd<L, R> {
+    pub left: L,
+    pub right: R,
+}
+
+#[derive(Debug, Clone)]
+pub struct GasMul<L, R> {
+    pub left: L,
+    pub right: R,
+}
+
+/***************************************************************************************************
+ * Gas Expression Impl
+ *
+ **************************************************************************************************/
+impl<E, T> GasExpression<E> for &T
+where
+    T: GasExpression<E>,
+{
+    type Unit = T::Unit;
+
+    fn materialize(&self, feature_version: u64, env: &E) -> GasQuantity<Self::Unit> {
+        (*self).materialize(feature_version, env)
+    }
+
+    fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
+        (*self).visit(visitor)
+    }
+}
+
+impl<E, U> GasExpression<E> for GasQuantity<U> {
+    type Unit = U;
+
+    fn materialize(&self, _feature_version: u64, _env: &E) -> GasQuantity<Self::Unit> {
+        *self
+    }
+
+    fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
+        visitor.quantity(*self)
+    }
+}
+
+impl<E, L, R, U> GasExpression<E> for GasAdd<L, R>
+where
+    L: GasExpression<E, Unit = U>,
+    R: GasExpression<E, Unit = U>,
+{
+    type Unit = U;
+
+    #[inline]
+    fn materialize(&self, feature_version: u64, env: &E) -> GasQuantity<Self::Unit> {
+        self.left.materialize(feature_version, env) + self.right.materialize(feature_version, env)
+    }
+
+    #[inline]
+    fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
+        self.left.visit(visitor);
+        self.right.visit(visitor);
+        visitor.add();
+    }
+}
+
+impl<E, L, R, UL, UR, O> GasExpression<E> for GasMul<L, R>
+where
+    L: GasExpression<E, Unit = UL>,
+    R: GasExpression<E, Unit = UR>,
+    GasQuantity<UL>: Mul<GasQuantity<UR>, Output = GasQuantity<O>>,
+{
+    type Unit = O;
+
+    #[inline]
+    fn materialize(&self, feature_version: u64, env: &E) -> GasQuantity<Self::Unit> {
+        self.left.materialize(feature_version, env) * self.right.materialize(feature_version, env)
+    }
+
+    #[inline]
+    fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
+        self.left.visit(visitor);
+        self.right.visit(visitor);
+        visitor.mul();
+    }
+}
+
+impl<E, L, R, U> GasExpression<E> for Either<L, R>
+where
+    L: GasExpression<E, Unit = U>,
+    R: GasExpression<E, Unit = U>,
+{
+    type Unit = U;
+
+    #[inline]
+    fn materialize(&self, feature_version: u64, env: &E) -> GasQuantity<Self::Unit> {
+        match self {
+            Either::Left(left) => left.materialize(feature_version, env),
+            Either::Right(right) => right.materialize(feature_version, env),
+        }
+    }
+
+    #[inline]
+    fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
+        match self {
+            Either::Left(left) => left.visit(visitor),
+            Either::Right(right) => right.visit(visitor),
+        }
+    }
+}
+
+/***************************************************************************************************
+ * Arithmetic Operations
+ *
+ **************************************************************************************************/
+impl<L, R, T> Add<T> for GasAdd<L, R> {
+    type Output = GasAdd<Self, T>;
+
+    fn add(self, rhs: T) -> Self::Output {
+        GasAdd {
+            left: self,
+            right: rhs,
+        }
+    }
+}
+
+impl<L, R, T> Mul<T> for GasAdd<L, R> {
+    type Output = GasMul<Self, T>;
+
+    fn mul(self, rhs: T) -> Self::Output {
+        GasMul {
+            left: self,
+            right: rhs,
+        }
+    }
+}
+
+impl<L, R, T> Add<T> for GasMul<L, R> {
+    type Output = GasAdd<Self, T>;
+
+    fn add(self, rhs: T) -> Self::Output {
+        GasAdd {
+            left: self,
+            right: rhs,
+        }
+    }
+}
+
+impl<L, R, T> Mul<T> for GasMul<L, R> {
+    type Output = GasMul<Self, T>;
+
+    fn mul(self, rhs: T) -> Self::Output {
+        GasMul {
+            left: self,
+            right: rhs,
+        }
+    }
+}
+
+// TODO: Add/Mul GasQuantity T
diff --git a/aptos-move/aptos-gas-algebra/src/algebra.rs b/aptos-move/aptos-gas-algebra/src/algebra.rs
new file mode 100644
index 0000000000000..e9c1d570ee822
--- /dev/null
+++ b/aptos-move/aptos-gas-algebra/src/algebra.rs
@@ -0,0 +1,56 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+pub use move_core_types::gas_algebra::*;
+
+/***************************************************************************************************
+ * Units & Quantities
+ *
+ **************************************************************************************************/
+/// Unit of abstract value size -- a conceptual measurement of the memory space a Move value occupies.
+pub enum AbstractValueUnit {}
+
+pub type AbstractValueSize = GasQuantity<AbstractValueUnit>;
+
+pub type InternalGasPerAbstractValueUnit = GasQuantity<UnitDiv<InternalGasUnit, AbstractValueUnit>>;
+
+pub type AbstractValueSizePerArg = GasQuantity<UnitDiv<AbstractValueUnit, Arg>>;
+
+/// Unit of (external) gas.
+pub enum GasUnit {}
+
+/// Unit of Aptos's native coin.
+pub enum APT {}
+
+/// Unit of gas currency. 1 Octa = 10^-8 Aptos coins.
+pub enum Octa {}
+
+pub type Gas = GasQuantity<GasUnit>;
+
+pub type GasScalingFactor = GasQuantity<UnitDiv<InternalGasUnit, GasUnit>>;
+
+pub type Fee = GasQuantity<Octa>;
+
+pub type FeePerGasUnit = GasQuantity<UnitDiv<Octa, GasUnit>>;
+
+/// Unit of storage slot
+pub enum Slot {}
+
+pub type NumSlots = GasQuantity<Slot>;
+
+pub type FeePerSlot = GasQuantity<UnitDiv<Octa, Slot>>;
+
+pub type FeePerByte = GasQuantity<UnitDiv<Octa, Byte>>;
+
+/***************************************************************************************************
+ * Unit Conversion
+ *
+ **************************************************************************************************/
+impl ToUnit<Octa> for APT {
+    const MULTIPLIER: u64 = 1_0000_0000;
+}
+
+impl ToUnitFractional<APT> for Octa {
+    const DENOMINATOR: u64 = 1_0000_0000;
+    const NOMINATOR: u64 = 1;
+}
diff --git a/aptos-move/aptos-gas-algebra/src/lib.rs b/aptos-move/aptos-gas-algebra/src/lib.rs
new file mode 100644
index 0000000000000..f11215af71768
--- /dev/null
+++ b/aptos-move/aptos-gas-algebra/src/lib.rs
@@ -0,0 +1,8 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+mod abstract_algebra;
+mod algebra;
+
+pub use abstract_algebra::*;
+pub use algebra::*;
diff --git a/aptos-move/aptos-gas-profiling/Cargo.toml b/aptos-move/aptos-gas-profiling/Cargo.toml
index 1f9d000598c97..ecfd2f4053da0 100644
--- a/aptos-move/aptos-gas-profiling/Cargo.toml
+++ b/aptos-move/aptos-gas-profiling/Cargo.toml
@@ -19,6 +19,7 @@ smallvec = { workspace = true }
 
 aptos-framework = { workspace = true }
 aptos-gas = { workspace = true }
+aptos-gas-algebra = { workspace = true }
 aptos-package-builder = { workspace = true }
 aptos-types = { workspace = true }
 
diff --git a/aptos-move/aptos-gas-profiling/src/aggregate.rs b/aptos-move/aptos-gas-profiling/src/aggregate.rs
index 1d7319d1a764d..b57856f00774f 100644
--- a/aptos-move/aptos-gas-profiling/src/aggregate.rs
+++ b/aptos-move/aptos-gas-profiling/src/aggregate.rs
@@ -5,7 +5,7 @@ use crate::{
     log::{ExecutionAndIOCosts, ExecutionGasEvent},
     render::{Render, TableKey},
 };
-use aptos_gas::{GasQuantity, GasScalingFactor, InternalGas};
+use aptos_gas_algebra::{GasQuantity, GasScalingFactor, InternalGas};
 use aptos_types::state_store::state_key::StateKeyInner;
 use std::{
     collections::{btree_map, BTreeMap},
diff --git a/aptos-move/aptos-gas-profiling/src/erased.rs b/aptos-move/aptos-gas-profiling/src/erased.rs
index 5359a6134bbaf..db1d0a5945228 100644
--- a/aptos-move/aptos-gas-profiling/src/erased.rs
+++ b/aptos-move/aptos-gas-profiling/src/erased.rs
@@ -9,7 +9,7 @@ use crate::{
     render::Render,
     FrameName, TransactionGasLog,
 };
-use aptos_gas::{Fee, GasQuantity, GasScalingFactor, InternalGas, InternalGasUnit, Octa};
+use aptos_gas_algebra::{Fee, GasQuantity, GasScalingFactor, InternalGas, InternalGasUnit, Octa};
 
 /// Represents a node in a general tree structure with some text & cost attached to each node.
 pub struct Node<U> {
diff --git a/aptos-move/aptos-gas-profiling/src/log.rs b/aptos-move/aptos-gas-profiling/src/log.rs
index 1a34b926d6ccf..8cdf1bbbd0362 100644
--- a/aptos-move/aptos-gas-profiling/src/log.rs
+++ b/aptos-move/aptos-gas-profiling/src/log.rs
@@ -1,12 +1,11 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use aptos_gas::{Fee, GasScalingFactor};
+use aptos_gas_algebra::{Fee, GasScalingFactor, InternalGas};
 use aptos_types::state_store::state_key::StateKey;
 use move_binary_format::{file_format::CodeOffset, file_format_common::Opcodes};
 use move_core_types::{
     account_address::AccountAddress,
-    gas_algebra::InternalGas,
     identifier::Identifier,
     language_storage::{ModuleId, TypeTag},
 };
diff --git a/aptos-move/aptos-gas-profiling/src/profiler.rs b/aptos-move/aptos-gas-profiling/src/profiler.rs
index b13a6cdabee5e..bd00adb12bba2 100644
--- a/aptos-move/aptos-gas-profiling/src/profiler.rs
+++ b/aptos-move/aptos-gas-profiling/src/profiler.rs
@@ -5,7 +5,8 @@ use crate::log::{
     CallFrame, EventStorage, ExecutionAndIOCosts, ExecutionGasEvent, FrameName, StorageFees,
     TransactionGasLog, WriteOpType, WriteStorage, WriteTransient,
 };
-use aptos_gas::{AptosGasMeter, Fee};
+use aptos_gas::AptosGasMeter;
+use aptos_gas_algebra::{Fee, FeePerGasUnit, InternalGas, NumArgs, NumBytes};
 use aptos_types::{
     contract_event::ContractEvent, state_store::state_key::StateKey, write_set::WriteOp,
 };
@@ -16,7 +17,6 @@ use move_binary_format::{
 };
 use move_core_types::{
     account_address::AccountAddress,
-    gas_algebra::{InternalGas, NumArgs, NumBytes},
     identifier::Identifier,
     language_storage::{ModuleId, TypeTag},
 };
@@ -493,8 +493,8 @@ where
 
         fn charge_storage_fee(
             &mut self,
-            amount: aptos_gas::Fee,
-            gas_unit_price: aptos_gas::FeePerGasUnit,
+            amount: Fee,
+            gas_unit_price: FeePerGasUnit,
         ) -> PartialVMResult<()>;
     }
 
@@ -516,7 +516,7 @@ where
         write_ops: impl IntoIterator<Item = (&'a StateKey, &'a WriteOp)>,
         events: impl IntoIterator<Item = &'a ContractEvent>,
         txn_size: NumBytes,
-        gas_unit_price: aptos_gas::FeePerGasUnit,
+        gas_unit_price: FeePerGasUnit,
     ) -> VMResult<()> {
         // The new storage fee are only active since version 7.
         if self.feature_version() < 7 {
diff --git a/aptos-move/aptos-gas-profiling/src/textualize.rs b/aptos-move/aptos-gas-profiling/src/textualize.rs
index 62258ffa0e47d..c8894ad04157a 100644
--- a/aptos-move/aptos-gas-profiling/src/textualize.rs
+++ b/aptos-move/aptos-gas-profiling/src/textualize.rs
@@ -5,7 +5,7 @@ use crate::{
     aggregate::AggregatedExecutionGasEvents,
     erased::{Node, TypeErasedExecutionAndIoCosts, TypeErasedGasLog, TypeErasedStorageFees},
 };
-use aptos_gas::{GasQuantity, InternalGas};
+use aptos_gas_algebra::{GasQuantity, InternalGas};
 use std::fmt::{self, Write};
 
 fn indent(output: &mut impl Write, count: usize) -> fmt::Result {
diff --git a/aptos-move/aptos-gas-schedule/Cargo.toml b/aptos-move/aptos-gas-schedule/Cargo.toml
new file mode 100644
index 0000000000000..1560dd72ac5e8
--- /dev/null
+++ b/aptos-move/aptos-gas-schedule/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "aptos-gas-schedule"
+version = "0.1.0"
+
+# Workspace inherited keys
+authors = { workspace = true }
+edition = { workspace = true }
+homepage = { workspace = true }
+license = { workspace = true }
+publish = { workspace = true }
+repository = { workspace = true }
+rust-version = { workspace = true }
+
+[dependencies]
+either = { workspace = true }
+aptos-types = { workspace = true }
+aptos-vm-types = { workspace = true }
+aptos-gas-algebra = { workspace = true }
+aptos-global-constants = { workspace = true }
+move-core-types = { workspace = true }
+move-vm-types = { workspace = true }
+paste = { workspace = true }
diff --git a/aptos-move/aptos-gas/src/instr.rs b/aptos-move/aptos-gas-schedule/run.py
similarity index 92%
rename from aptos-move/aptos-gas/src/instr.rs
rename to aptos-move/aptos-gas-schedule/run.py
index f9940648348a0..f2f412b32c5c5 100644
--- a/aptos-move/aptos-gas/src/instr.rs
+++ b/aptos-move/aptos-gas-schedule/run.py
@@ -1,18 +1,6 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
+import re
 
-//! This module defines all the gas parameters and formulae for instructions, along with their
-//! initial values in the genesis and a mapping between the Rust representation and the on-chain
-//! gas schedule.
-
-use crate::{algebra::InternalGasPerAbstractValueUnit, gas_meter::EXECUTION_GAS_MULTIPLIER as MUL};
-use move_core_types::gas_algebra::{InternalGas, InternalGasPerArg, InternalGasPerByte};
-
-crate::params::define_gas_parameters!(
-    InstructionGasParameters,
-    "instr",
-    .instr,
-    [
+text = """
         // nop
         [nop: InternalGas, "nop", 10 * MUL],
         // control flow
@@ -202,5 +190,13 @@
             "vec_unpack.per_expected_elem",
             40 * MUL
         ],
-    ]
-);
+"""
+
+
+def replace(match):
+    return str(int(match.group(1)) * 20)
+
+
+res = re.sub("([0-9]+) *\* *MUL", replace, text)
+
+print(res)
diff --git a/aptos-move/aptos-gas-schedule/src/gas_params/instr.rs b/aptos-move/aptos-gas-schedule/src/gas_params/instr.rs
new file mode 100644
index 0000000000000..b8478972f388d
--- /dev/null
+++ b/aptos-move/aptos-gas-schedule/src/gas_params/instr.rs
@@ -0,0 +1,203 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+use aptos_gas_algebra::{
+    InternalGas, InternalGasPerAbstractValueUnit, InternalGasPerArg, InternalGasPerByte,
+};
+
+crate::gas_params::macros::define_gas_parameters!(
+    InstructionGasParameters,
+    "instr",
+    .instr,
+    [
+        // nop
+        [nop: InternalGas, "nop", 200],
+        // control flow
+        [ret: InternalGas, "ret", 1200],
+        [abort: InternalGas, "abort", 1200],
+
+        // Note(Gas): The costs of the branch instructions have been jacked up a bit intentionally
+        //            to prevent any single transaction from running for too long.
+        [br_true: InternalGas, "br_true", 2400],
+        [br_false: InternalGas, "br_false", 2400],
+        [branch: InternalGas, "branch", 1600],
+
+        // stack
+        [pop: InternalGas, "pop", 800],
+        [ld_u8: InternalGas, "ld_u8", 1200],
+        [ld_u16: InternalGas, { 5.. => "ld_u16" }, 1200],
+        [ld_u32: InternalGas, { 5.. => "ld_u32" }, 1200],
+        [ld_u64: InternalGas, "ld_u64", 1200],
+        [ld_u128: InternalGas, "ld_u128", 1600],
+        [ld_u256: InternalGas, { 5.. => "ld_u256" }, 1600],
+        [ld_true: InternalGas, "ld_true", 1200],
+        [ld_false: InternalGas, "ld_false", 1200],
+        [ld_const_base: InternalGas, "ld_const.base", 13000],
+        [
+            ld_const_per_byte: InternalGasPerByte,
+            "ld_const.per_byte",
+            700,
+            LD_CONST_PER_BYTE
+        ],
+        // borrow
+        [imm_borrow_loc: InternalGas, "imm_borrow_loc", 1200],
+        [mut_borrow_loc: InternalGas, "mut_borrow_loc", 1200],
+        [imm_borrow_field: InternalGas, "imm_borrow_field", 4000],
+        [mut_borrow_field: InternalGas, "mut_borrow_field", 4000],
+        [
+            imm_borrow_field_generic: InternalGas,
+            "imm_borrow_field_generic",
+            4000
+        ],
+        [
+            mut_borrow_field_generic: InternalGas,
+            "mut_borrow_field_generic",
+            4000
+        ],
+        // locals
+        [copy_loc_base: InternalGas, "copy_loc.base", 1600],
+        [
+            copy_loc_per_abs_val_unit: InternalGasPerAbstractValueUnit,
+            "copy_loc.per_abs_val_unit",
+            80
+        ],
+        [move_loc_base: InternalGas, "move_loc.base", 2400],
+        [st_loc_base: InternalGas, "st_loc.base", 2400],
+        // call
+        [call_base: InternalGas, "call.base", 20000],
+        [call_per_arg: InternalGasPerArg, "call.per_arg", 2000],
+        [call_per_local: InternalGasPerArg, { 1.. => "call.per_local" }, 2000],
+        [call_generic_base: InternalGas, "call_generic.base", 20000],
+        [
+            call_generic_per_ty_arg: InternalGasPerArg,
+            "call_generic.per_ty_arg",
+            2000
+        ],
+        [
+            call_generic_per_arg: InternalGasPerArg,
+            "call_generic.per_arg",
+            2000
+        ],
+        [call_generic_per_local: InternalGasPerArg, { 1.. => "call_generic.per_local" }, 2000],
+        // struct
+        [pack_base: InternalGas, "pack.base", 4400],
+        [pack_per_field: InternalGasPerArg, "pack.per_field", 800],
+        [pack_generic_base: InternalGas, "pack_generic.base", 4400],
+        [
+            pack_generic_per_field: InternalGasPerArg,
+            "pack_generic.per_field",
+            800
+        ],
+        [unpack_base: InternalGas, "unpack.base", 4400],
+        [unpack_per_field: InternalGasPerArg, "unpack.per_field", 800],
+        [unpack_generic_base: InternalGas, "unpack_generic.base", 4400],
+        [
+            unpack_generic_per_field: InternalGasPerArg,
+            "unpack_generic.per_field",
+            800
+        ],
+        // ref
+        [read_ref_base: InternalGas, "read_ref.base", 4000],
+        [
+            read_ref_per_abs_val_unit: InternalGasPerAbstractValueUnit,
+            "read_ref.per_abs_val_unit",
+            80
+        ],
+        [write_ref_base: InternalGas, "write_ref.base", 4000],
+        [freeze_ref: InternalGas, "freeze_ref", 200],
+        // casting
+        [cast_u8: InternalGas, "cast_u8", 2400],
+        [cast_u16: InternalGas, { 5.. => "cast_u16" }, 2400],
+        [cast_u32: InternalGas, { 5.. => "cast_u32" }, 2400],
+        [cast_u64: InternalGas, "cast_u64", 2400],
+        [cast_u128: InternalGas, "cast_u128", 2400],
+        [cast_u256: InternalGas, { 5.. => "cast_u256" }, 2400],
+        // arithmetic
+        [add: InternalGas, "add", 3200],
+        [sub: InternalGas, "sub", 3200],
+        [mul: InternalGas, "mul", 3200],
+        [mod_: InternalGas, "mod", 3200],
+        [div: InternalGas, "div", 3200],
+        // bitwise
+        [bit_or: InternalGas, "bit_or", 3200],
+        [bit_and: InternalGas, "bit_and", 3200],
+        [xor: InternalGas, "bit_xor", 3200],
+        [shl: InternalGas, "bit_shl", 3200],
+        [shr: InternalGas, "bit_shr", 3200],
+        // boolean
+        [or: InternalGas, "or", 3200],
+        [and: InternalGas, "and", 3200],
+        [not: InternalGas, "not", 3200],
+        // comparison
+        [lt: InternalGas, "lt", 3200],
+        [gt: InternalGas, "gt", 3200],
+        [le: InternalGas, "le", 3200],
+        [ge: InternalGas, "ge", 3200],
+        [eq_base: InternalGas, "eq.base", 2000],
+        [
+            eq_per_abs_val_unit: InternalGasPerAbstractValueUnit,
+            "eq.per_abs_val_unit",
+            80
+        ],
+        [neq_base: InternalGas, "neq.base", 2000],
+        [
+            neq_per_abs_val_unit: InternalGasPerAbstractValueUnit,
+            "neq.per_abs_val_unit",
+            80
+        ],
+        // global
+        [
+            imm_borrow_global_base: InternalGas,
+            "imm_borrow_global.base",
+            10000
+        ],
+        [
+            imm_borrow_global_generic_base: InternalGas,
+            "imm_borrow_global_generic.base",
+            10000
+        ],
+        [
+            mut_borrow_global_base: InternalGas,
+            "mut_borrow_global.base",
+            10000
+        ],
+        [
+            mut_borrow_global_generic_base: InternalGas,
+            "mut_borrow_global_generic.base",
+            10000
+        ],
+        [exists_base: InternalGas, "exists.base", 5000],
+        [exists_generic_base: InternalGas, "exists_generic.base", 5000],
+        [move_from_base: InternalGas, "move_from.base", 7000],
+        [
+            move_from_generic_base: InternalGas,
+            "move_from_generic.base",
+            7000
+        ],
+        [move_to_base: InternalGas, "move_to.base", 10000],
+        [
+            move_to_generic_base: InternalGas,
+            "move_to_generic.base",
+            10000
+        ],
+        // vec
+        [vec_len_base: InternalGas, "vec_len.base", 4400],
+        [vec_imm_borrow_base: InternalGas, "vec_imm_borrow.base", 6600],
+        [vec_mut_borrow_base: InternalGas, "vec_mut_borrow.base", 6600],
+        [vec_push_back_base: InternalGas, "vec_push_back.base", 7600],
+        [vec_pop_back_base: InternalGas, "vec_pop_back.base", 5200],
+        [vec_swap_base: InternalGas, "vec_swap.base", 6000],
+        [vec_pack_base: InternalGas, "vec_pack.base", 12000],
+        [
+            vec_pack_per_elem: InternalGasPerArg,
+            "vec_pack.per_elem",
+            800
+        ],
+        [vec_unpack_base: InternalGas, "vec_unpack.base", 10000],
+        [
+            vec_unpack_per_expected_elem: InternalGasPerArg,
+            "vec_unpack.per_expected_elem",
+            800
+        ],
+    ]
+);
diff --git a/aptos-move/aptos-gas/src/params.rs b/aptos-move/aptos-gas-schedule/src/gas_params/macros.rs
similarity index 79%
rename from aptos-move/aptos-gas/src/params.rs
rename to aptos-move/aptos-gas-schedule/src/gas_params/macros.rs
index 1bd3f40012a29..4f90780d8bf3f 100644
--- a/aptos-move/aptos-gas/src/params.rs
+++ b/aptos-move/aptos-gas-schedule/src/gas_params/macros.rs
@@ -29,13 +29,13 @@ macro_rules! define_gas_parameters {
             $(pub $name : $ty),*
         }
 
-        impl $crate::gas_meter::FromOnChainGasSchedule for $params_name {
-            #[allow(unused_variables)]
+        impl $crate::traits::FromOnChainGasSchedule for $params_name {
+            #[allow(unused)]
             fn from_on_chain_gas_schedule(gas_schedule: &std::collections::BTreeMap<String, u64>, feature_version: u64) -> Result<Self, String> {
                 let mut params = $params_name::zeros();
 
                 $(
-                    if let Some(key) = $crate::params::define_gas_parameters_extract_key_at_version!($key_bindings, feature_version) {
+                    if let Some(key) = $crate::gas_params::macros::define_gas_parameters_extract_key_at_version!($key_bindings, feature_version) {
                         let name = format!("{}.{}", $prefix, key);
                         params.$name = gas_schedule.get(&name).cloned().ok_or_else(|| format!("Gas parameter {} does not exist. Feature version: {}.", name, feature_version))?.into();
                     }
@@ -45,13 +45,13 @@ macro_rules! define_gas_parameters {
             }
         }
 
-        impl $crate::gas_meter::ToOnChainGasSchedule for $params_name {
-            #[allow(unused_variables)]
+        impl $crate::traits::ToOnChainGasSchedule for $params_name {
+            #[allow(unused)]
             fn to_on_chain_gas_schedule(&self, feature_version: u64) -> Vec<(String, u64)> {
                 let mut output = vec![];
 
                 $(
-                    if let Some(key) = $crate::params::define_gas_parameters_extract_key_at_version!($key_bindings, feature_version) {
+                    if let Some(key) = $crate::gas_params::macros::define_gas_parameters_extract_key_at_version!($key_bindings, feature_version) {
                         output.push((format!("{}.{}", $prefix, key), self.$name.into()))
                     }
                 )*
@@ -68,7 +68,7 @@ macro_rules! define_gas_parameters {
             }
         }
 
-        impl $crate::gas_meter::InitialGasSchedule for $params_name {
+        impl $crate::traits::InitialGasSchedule for $params_name {
             fn initial() -> Self {
                 Self {
                     $($name: $initial.into()),*
@@ -76,8 +76,12 @@ macro_rules! define_gas_parameters {
             }
         }
 
+        #[allow(unused)]
         pub mod gas_params {
-            use $crate::abstract_algebra::{GasExpression, GasExpressionVisitor, GasMul, GasAdd};
+            use aptos_gas_algebra::{GasExpression, GasExpressionVisitor, GasMul, GasAdd};
+            use $crate::{
+                gas_params::AptosGasParameters,
+            };
             use std::ops::{Add, Mul};
             use move_core_types::gas_algebra::{GasQuantity, GasQuantityGetUnit};
 
@@ -93,13 +97,13 @@ macro_rules! define_gas_parameters {
                     #[allow(non_camel_case_types)]
                     pub struct [<$name:upper>];
 
-                    impl GasExpression for [<$name:upper>] {
+                    impl GasExpression<AptosGasParameters> for [<$name:upper>] {
                         type Unit =  <super::$ty as GasQuantityGetUnit>::Unit;
 
                         fn materialize(
                             &self,
                             _feature_version: u64,
-                            gas_params: &$crate::gas_meter::AptosGasParameters,
+                            gas_params: &$crate::gas_params::AptosGasParameters,
                         ) -> GasQuantity<Self::Unit> {
                             get!(gas_params, $name)
                         }
@@ -110,9 +114,6 @@ macro_rules! define_gas_parameters {
                     }
 
                     impl<T> Add<T> for [<$name:upper>]
-                    where
-                        Self: GasExpression,
-                        T: GasExpression,
                     {
                         type Output = GasAdd<Self, T>;
 
@@ -122,9 +123,6 @@ macro_rules! define_gas_parameters {
                     }
 
                     impl<T> Mul<T> for [<$name:upper>]
-                    where
-                        Self: GasExpression,
-                        T: GasExpression,
                     {
                         type Output = GasMul<Self, T>;
 
@@ -138,7 +136,7 @@ macro_rules! define_gas_parameters {
 
         #[test]
         fn keys_should_be_unique_for_all_versions() {
-            for ver in 0..=$crate::gas_meter::LATEST_GAS_FEATURE_VERSION {
+            for ver in 0..=aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION {
                 let mut map = std::collections::BTreeMap::<&str, ()>::new();
 
                 $(
diff --git a/aptos-move/aptos-gas/src/misc.rs b/aptos-move/aptos-gas-schedule/src/gas_params/misc.rs
similarity index 98%
rename from aptos-move/aptos-gas/src/misc.rs
rename to aptos-move/aptos-gas-schedule/src/gas_params/misc.rs
index 0f148cd5bc3bb..b365689ebb977 100644
--- a/aptos-move/aptos-gas/src/misc.rs
+++ b/aptos-move/aptos-gas-schedule/src/gas_params/misc.rs
@@ -1,15 +1,13 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{
-    algebra::{AbstractValueSize, AbstractValueSizePerArg},
-    gas_meter::{FromOnChainGasSchedule, InitialGasSchedule, ToOnChainGasSchedule},
-};
+use crate::traits::{FromOnChainGasSchedule, InitialGasSchedule, ToOnChainGasSchedule};
+use aptos_gas_algebra::{AbstractValueSize, AbstractValueSizePerArg};
 use move_core_types::{account_address::AccountAddress, gas_algebra::NumArgs, u256::U256};
 use move_vm_types::views::{ValueView, ValueVisitor};
 use std::collections::BTreeMap;
 
-crate::params::define_gas_parameters!(
+crate::gas_params::macros::define_gas_parameters!(
     AbstractValueSizeGasParameters,
     "misc.abs_val",
     .misc.abs_val,
diff --git a/aptos-move/aptos-gas-schedule/src/gas_params/mod.rs b/aptos-move/aptos-gas-schedule/src/gas_params/mod.rs
new file mode 100644
index 0000000000000..a28a089def479
--- /dev/null
+++ b/aptos-move/aptos-gas-schedule/src/gas_params/mod.rs
@@ -0,0 +1,73 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::traits::{FromOnChainGasSchedule, InitialGasSchedule, ToOnChainGasSchedule};
+use std::collections::BTreeMap;
+
+mod instr;
+mod macros;
+mod misc;
+mod storage;
+mod transaction;
+
+pub use instr::{gas_params as instr_gas_params, InstructionGasParameters};
+pub use misc::{gas_params as misc_gas_params, AbstractValueSizeGasParameters, MiscGasParameters};
+pub use storage::*;
+pub use transaction::{gas_params as txn_gas_params, TransactionGasParameters};
+
+/// Gas parameters for everything that is needed to run the Aptos blockchain, including
+/// instructions, transactions and native functions from various packages.
+#[derive(Debug, Clone)]
+pub struct AptosGasParameters {
+    pub misc: MiscGasParameters,
+    pub instr: InstructionGasParameters,
+    pub txn: TransactionGasParameters,
+}
+
+impl FromOnChainGasSchedule for AptosGasParameters {
+    fn from_on_chain_gas_schedule(
+        gas_schedule: &BTreeMap<String, u64>,
+        feature_version: u64,
+    ) -> Result<Self, String> {
+        Ok(Self {
+            misc: FromOnChainGasSchedule::from_on_chain_gas_schedule(
+                gas_schedule,
+                feature_version,
+            )?,
+            instr: FromOnChainGasSchedule::from_on_chain_gas_schedule(
+                gas_schedule,
+                feature_version,
+            )?,
+            txn: FromOnChainGasSchedule::from_on_chain_gas_schedule(gas_schedule, feature_version)?,
+        })
+    }
+}
+
+impl ToOnChainGasSchedule for AptosGasParameters {
+    fn to_on_chain_gas_schedule(&self, feature_version: u64) -> Vec<(String, u64)> {
+        let mut entries = self.instr.to_on_chain_gas_schedule(feature_version);
+        entries.extend(self.txn.to_on_chain_gas_schedule(feature_version));
+        entries.extend(self.misc.to_on_chain_gas_schedule(feature_version));
+        entries
+    }
+}
+
+impl AptosGasParameters {
+    pub fn zeros() -> Self {
+        Self {
+            misc: MiscGasParameters::zeros(),
+            instr: InstructionGasParameters::zeros(),
+            txn: TransactionGasParameters::zeros(),
+        }
+    }
+}
+
+impl InitialGasSchedule for AptosGasParameters {
+    fn initial() -> Self {
+        Self {
+            misc: InitialGasSchedule::initial(),
+            instr: InitialGasSchedule::initial(),
+            txn: InitialGasSchedule::initial(),
+        }
+    }
+}
diff --git a/aptos-move/aptos-gas/src/transaction/storage.rs b/aptos-move/aptos-gas-schedule/src/gas_params/storage.rs
similarity index 96%
rename from aptos-move/aptos-gas/src/transaction/storage.rs
rename to aptos-move/aptos-gas-schedule/src/gas_params/storage.rs
index bcbe33e1a1fab..ef6ace1c29da8 100644
--- a/aptos-move/aptos-gas/src/transaction/storage.rs
+++ b/aptos-move/aptos-gas-schedule/src/gas_params/storage.rs
@@ -2,9 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{
-    abstract_algebra::GasExpression, transaction::gas_params::*, AptosGasParameters,
-    LATEST_GAS_FEATURE_VERSION,
+    gas_params::{transaction::gas_params::*, AptosGasParameters},
+    ver::LATEST_GAS_FEATURE_VERSION,
 };
+use aptos_gas_algebra::GasExpression;
 use aptos_types::{
     on_chain_config::{ConfigStorage, OnChainConfig, StorageGasSchedule},
     state_store::state_key::StateKey,
@@ -192,7 +193,10 @@ pub struct StoragePricingV3 {
 }
 
 impl StoragePricingV3 {
-    fn calculate_read_gas(&self, loaded: NumBytes) -> impl GasExpression<Unit = InternalGasUnit> {
+    fn calculate_read_gas(
+        &self,
+        loaded: NumBytes,
+    ) -> impl GasExpression<AptosGasParameters, Unit = InternalGasUnit> {
         STORAGE_IO_PER_STATE_SLOT_READ * NumArgs::from(1) + STORAGE_IO_PER_STATE_BYTE_READ * loaded
     }
 
@@ -209,7 +213,7 @@ impl StoragePricingV3 {
         &self,
         key: &StateKey,
         op: &WriteOp,
-    ) -> impl GasExpression<Unit = InternalGasUnit> {
+    ) -> impl GasExpression<AptosGasParameters, Unit = InternalGasUnit> {
         use WriteOp::*;
 
         match op {
@@ -261,7 +265,7 @@ impl StoragePricing {
         &self,
         resource_exists: bool,
         bytes_loaded: NumBytes,
-    ) -> impl GasExpression<Unit = InternalGasUnit> {
+    ) -> impl GasExpression<AptosGasParameters, Unit = InternalGasUnit> {
         use StoragePricing::*;
 
         match self {
@@ -281,7 +285,7 @@ impl StoragePricing {
         &self,
         key: &StateKey,
         op: &WriteOp,
-    ) -> impl GasExpression<Unit = InternalGasUnit> {
+    ) -> impl GasExpression<AptosGasParameters, Unit = InternalGasUnit> {
         use StoragePricing::*;
 
         match self {
diff --git a/aptos-move/aptos-gas/src/transaction/mod.rs b/aptos-move/aptos-gas-schedule/src/gas_params/transaction.rs
similarity index 91%
rename from aptos-move/aptos-gas/src/transaction/mod.rs
rename to aptos-move/aptos-gas-schedule/src/gas_params/transaction.rs
index 98ef94481d0f4..3fb1b5bcb03a6 100644
--- a/aptos-move/aptos-gas/src/transaction/mod.rs
+++ b/aptos-move/aptos-gas-schedule/src/gas_params/transaction.rs
@@ -1,15 +1,10 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
 //! This module defines all the gas parameters for transactions, along with their initial values
 //! in the genesis and a mapping between the Rust representation and the on-chain gas schedule.
 
-use crate::{
-    abstract_algebra::GasExpression,
-    algebra::{
-        AbstractValueSize, Fee, FeePerByte, FeePerGasUnit, FeePerSlot, Gas, GasScalingFactor,
-        GasUnit, NumSlots,
-    },
+use crate::gas_params::AptosGasParameters;
+use aptos_gas_algebra::{
+    AbstractValueSize, Fee, FeePerByte, FeePerGasUnit, FeePerSlot, Gas, GasExpression,
+    GasScalingFactor, GasUnit, NumSlots,
 };
 use aptos_types::{
     contract_event::ContractEvent, state_store::state_key::StateKey, write_set::WriteOp,
@@ -19,14 +14,9 @@ use move_core_types::gas_algebra::{
     ToUnitFractionalWithParams, ToUnitWithParams,
 };
 
-mod storage;
-
-use self::gas_params::{INTRINSIC_GAS_PER_BYTE, MIN_TRANSACTION_GAS_UNITS};
-pub use storage::{ChangeSetConfigs, StorageGasParameters, StoragePricing};
-
 const GAS_SCALING_FACTOR: u64 = 1_000_000;
 
-crate::params::define_gas_parameters!(
+crate::gas_params::macros::define_gas_parameters!(
     TransactionGasParameters,
     "txn",
     .txn,
@@ -185,6 +175,8 @@ crate::params::define_gas_parameters!(
     ]
 );
 
+use gas_params::*;
+
 impl TransactionGasParameters {
     // TODO(Gas): Right now we are relying on this to avoid div by zero errors when using the all-zero
     //            gas parameters. See if there's a better way we can handle this.
@@ -240,7 +232,7 @@ impl TransactionGasParameters {
     pub fn calculate_intrinsic_gas(
         &self,
         transaction_size: NumBytes,
-    ) -> impl GasExpression<Unit = InternalGasUnit> {
+    ) -> impl GasExpression<AptosGasParameters, Unit = InternalGasUnit> {
         let excess = transaction_size
             .checked_sub(self.large_transaction_cutoff)
             .unwrap_or_else(|| 0.into());
@@ -249,18 +241,14 @@ impl TransactionGasParameters {
     }
 }
 
-impl ToUnitWithParams<InternalGasUnit> for GasUnit {
-    type Params = TransactionGasParameters;
-
-    fn multiplier(params: &Self::Params) -> u64 {
+impl ToUnitWithParams<TransactionGasParameters, InternalGasUnit> for GasUnit {
+    fn multiplier(params: &TransactionGasParameters) -> u64 {
         params.scaling_factor().into()
     }
 }
 
-impl ToUnitFractionalWithParams<GasUnit> for InternalGasUnit {
-    type Params = TransactionGasParameters;
-
-    fn ratio(params: &Self::Params) -> (u64, u64) {
+impl ToUnitFractionalWithParams<TransactionGasParameters, GasUnit> for InternalGasUnit {
+    fn ratio(params: &TransactionGasParameters) -> (u64, u64) {
         (1, params.scaling_factor().into())
     }
 }
diff --git a/aptos-move/aptos-gas-schedule/src/lib.rs b/aptos-move/aptos-gas-schedule/src/lib.rs
new file mode 100644
index 0000000000000..77e22108326ce
--- /dev/null
+++ b/aptos-move/aptos-gas-schedule/src/lib.rs
@@ -0,0 +1,10 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+mod gas_params;
+mod traits;
+mod ver;
+
+pub use gas_params::*;
+pub use traits::{FromOnChainGasSchedule, InitialGasSchedule, ToOnChainGasSchedule};
+pub use ver::LATEST_GAS_FEATURE_VERSION;
diff --git a/aptos-move/aptos-gas-schedule/src/traits.rs b/aptos-move/aptos-gas-schedule/src/traits.rs
new file mode 100644
index 0000000000000..8cefd8fd582c7
--- /dev/null
+++ b/aptos-move/aptos-gas-schedule/src/traits.rs
@@ -0,0 +1,29 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+use std::collections::BTreeMap;
+
+/// A trait for converting from a map representation of the on-chain gas schedule.
+pub trait FromOnChainGasSchedule: Sized {
+    /// Constructs a value of this type from a map representation of the on-chain gas schedule.
+    /// `None` should be returned when the gas schedule is missing some required entries.
+    /// Unused entries should be safely ignored.
+    fn from_on_chain_gas_schedule(
+        gas_schedule: &BTreeMap<String, u64>,
+        feature_version: u64,
+    ) -> Result<Self, String>;
+}
+
+/// A trait for converting to a list of entries of the on-chain gas schedule.
+pub trait ToOnChainGasSchedule {
+    /// Converts `self` into a list of entries of the on-chain gas schedule.
+    /// Each entry is a key-value pair where the key is a string representing the name of the
+    /// parameter, where the value is the gas parameter itself.
+    fn to_on_chain_gas_schedule(&self, feature_version: u64) -> Vec<(String, u64)>;
+}
+
+/// A trait for defining an initial value to be used in the genesis.
+pub trait InitialGasSchedule: Sized {
+    /// Returns the initial value of this type, which is used in the genesis.
+    fn initial() -> Self;
+}
diff --git a/aptos-move/aptos-gas-schedule/src/ver.rs b/aptos-move/aptos-gas-schedule/src/ver.rs
new file mode 100644
index 0000000000000..5c30ebd932c2a
--- /dev/null
+++ b/aptos-move/aptos-gas-schedule/src/ver.rs
@@ -0,0 +1,36 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+// Change log:
+// - V10
+//   - Added generate_unique_address and get_txn_hash native functions
+//   - Storage gas charges (excluding "storage fees") stop respecting the storage gas curves
+// - V9
+//   - Accurate tracking of the cost of loading resource groups
+// - V8
+//   - Added BLS12-381 operations.
+// - V7
+//   - Native support for exists<T>
+//   - New formulae for storage fees based on fixed APT costs
+//   - Lower gas price (other than the newly introduced storage fees) by upping the scaling factor
+// - V6
+//   - Added a new native function - blake2b_256.
+// - V5
+//   - u16, u32, u256
+//   - free_write_bytes_quota
+//   - configurable ChangeSetConfigs
+// - V4
+//   - Consider memory leaked for event natives
+// - V3
+//   - Add memory quota
+//   - Storage charges:
+//     - Distinguish between new and existing resources
+//     - One item write comes with 1K free bytes
+//     - abort with STORAGE_WRITE_LIMIT_REACHED if WriteOps or Events are too large
+// - V2
+//   - Table
+//     - Fix the gas formula for loading resources so that they are consistent with other
+//       global operations.
+// - V1
+//   - TBA
+pub const LATEST_GAS_FEATURE_VERSION: u64 = 10;
diff --git a/aptos-move/aptos-gas/Cargo.toml b/aptos-move/aptos-gas/Cargo.toml
index f58f07037a36a..36ac56dbadb0a 100644
--- a/aptos-move/aptos-gas/Cargo.toml
+++ b/aptos-move/aptos-gas/Cargo.toml
@@ -15,7 +15,8 @@ rust-version = { workspace = true }
 [dependencies]
 anyhow = { workspace = true }
 aptos-framework = { workspace = true }
-aptos-gas-algebra-ext = { workspace = true }
+aptos-gas-algebra = { workspace = true }
+aptos-gas-schedule = { workspace = true }
 aptos-global-constants = { workspace = true }
 aptos-logger = { workspace = true }
 aptos-move-stdlib = { workspace = true }
diff --git a/aptos-move/aptos-gas/src/abstract_algebra.rs b/aptos-move/aptos-gas/src/abstract_algebra.rs
deleted file mode 100644
index bff698ba7f5fe..0000000000000
--- a/aptos-move/aptos-gas/src/abstract_algebra.rs
+++ /dev/null
@@ -1,359 +0,0 @@
-use crate::{AptosGasParameters, Fee, FeePerGasUnit, Octa, StorageGasParameters};
-use either::Either;
-use move_binary_format::errors::PartialVMResult;
-use move_core_types::gas_algebra::{GasQuantity, InternalGas, InternalGasUnit};
-use std::ops::{Add, Mul};
-
-pub trait GasExpressionVisitor {
-    fn add(&mut self);
-
-    fn mul(&mut self);
-
-    fn gas_param<P>(&mut self);
-
-    fn quantity<U>(&mut self, quantity: GasQuantity<U>);
-}
-
-/// Abstraction over a gas expression.
-pub trait GasExpression {
-    type Unit;
-
-    fn materialize(
-        &self,
-        feature_version: u64,
-        gas_params: &AptosGasParameters,
-    ) -> GasQuantity<Self::Unit>;
-
-    fn visit(&self, visitor: &mut impl GasExpressionVisitor);
-}
-
-pub trait GasAlgebra {
-    fn feature_version(&self) -> u64;
-
-    fn gas_params(&self) -> &AptosGasParameters;
-
-    fn storage_gas_params(&self) -> &StorageGasParameters;
-
-    fn balance_internal(&self) -> InternalGas;
-
-    fn charge_execution(
-        &mut self,
-        abstract_amount: impl GasExpression<Unit = InternalGasUnit>,
-    ) -> PartialVMResult<()>;
-
-    fn charge_io(
-        &mut self,
-        abstract_amount: impl GasExpression<Unit = InternalGasUnit>,
-    ) -> PartialVMResult<()>;
-
-    fn charge_storage_fee(
-        &mut self,
-        abstract_amount: impl GasExpression<Unit = Octa>,
-        gas_unit_price: FeePerGasUnit,
-    ) -> PartialVMResult<()>;
-
-    fn execution_gas_used(&self) -> InternalGas;
-
-    fn io_gas_used(&self) -> InternalGas;
-
-    fn storage_fee_used_in_gas_units(&self) -> InternalGas;
-
-    fn storage_fee_used(&self) -> Fee;
-}
-
-pub struct GasAdd<L, R> {
-    pub left: L,
-    pub right: R,
-}
-
-pub struct GasMul<L, R> {
-    pub left: L,
-    pub right: R,
-}
-
-pub struct GasOptional<F, E> {
-    pub predicate: F,
-    pub exp: E,
-}
-
-impl<L, R, U> GasExpression for GasAdd<L, R>
-where
-    L: GasExpression<Unit = U>,
-    R: GasExpression<Unit = U>,
-{
-    type Unit = U;
-
-    #[inline]
-    fn materialize(
-        &self,
-        feature_version: u64,
-        gas_params: &AptosGasParameters,
-    ) -> GasQuantity<Self::Unit> {
-        self.left.materialize(feature_version, gas_params)
-            + self.right.materialize(feature_version, gas_params)
-    }
-
-    #[inline]
-    fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
-        self.left.visit(visitor);
-        self.right.visit(visitor);
-        visitor.add();
-    }
-}
-
-impl<L, R, UL, UR, O> GasExpression for GasMul<L, R>
-where
-    L: GasExpression<Unit = UL>,
-    R: GasExpression<Unit = UR>,
-    GasQuantity<UL>: Mul<GasQuantity<UR>, Output = GasQuantity<O>>,
-{
-    type Unit = O;
-
-    #[inline]
-    fn materialize(
-        &self,
-        feature_version: u64,
-        gas_params: &AptosGasParameters,
-    ) -> GasQuantity<Self::Unit> {
-        self.left.materialize(feature_version, gas_params)
-            * self.right.materialize(feature_version, gas_params)
-    }
-
-    #[inline]
-    fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
-        self.left.visit(visitor);
-        self.right.visit(visitor);
-        visitor.mul();
-    }
-}
-
-impl<U> GasExpression for GasQuantity<U> {
-    type Unit = U;
-
-    #[inline]
-    fn materialize(
-        &self,
-        _feature_version: u64,
-        _gas_params: &AptosGasParameters,
-    ) -> GasQuantity<Self::Unit> {
-        *self
-    }
-
-    #[inline]
-    fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
-        visitor.quantity(*self)
-    }
-}
-
-impl<F, E> GasExpression for GasOptional<F, E>
-where
-    F: Fn() -> bool,
-    E: GasExpression,
-{
-    type Unit = E::Unit;
-
-    #[inline]
-    fn materialize(
-        &self,
-        feature_version: u64,
-        gas_params: &AptosGasParameters,
-    ) -> GasQuantity<Self::Unit> {
-        if (self.predicate)() {
-            self.exp.materialize(feature_version, gas_params)
-        } else {
-            0.into()
-        }
-    }
-
-    #[inline]
-    fn visit(&self, _visitor: &mut impl GasExpressionVisitor) {}
-}
-
-impl<L, R, T> Add<T> for GasAdd<L, R>
-where
-    Self: GasExpression,
-    T: GasExpression,
-{
-    type Output = GasAdd<Self, T>;
-
-    fn add(self, rhs: T) -> Self::Output {
-        GasAdd {
-            left: self,
-            right: rhs,
-        }
-    }
-}
-
-impl<L, R, T> Mul<T> for GasAdd<L, R>
-where
-    Self: GasExpression,
-    T: GasExpression,
-{
-    type Output = GasMul<Self, T>;
-
-    fn mul(self, rhs: T) -> Self::Output {
-        GasMul {
-            left: self,
-            right: rhs,
-        }
-    }
-}
-
-impl<L, R, T> Add<T> for GasMul<L, R>
-where
-    Self: GasExpression,
-    T: GasExpression,
-{
-    type Output = GasAdd<Self, T>;
-
-    fn add(self, rhs: T) -> Self::Output {
-        GasAdd {
-            left: self,
-            right: rhs,
-        }
-    }
-}
-
-impl<L, R, T> Mul<T> for GasMul<L, R>
-where
-    Self: GasExpression,
-    T: GasExpression,
-{
-    type Output = GasMul<Self, T>;
-
-    fn mul(self, rhs: T) -> Self::Output {
-        GasMul {
-            left: self,
-            right: rhs,
-        }
-    }
-}
-
-impl<F, E, T> Add<T> for GasOptional<F, E>
-where
-    Self: GasExpression,
-    T: GasExpression,
-{
-    type Output = GasAdd<Self, T>;
-
-    fn add(self, rhs: T) -> Self::Output {
-        GasAdd {
-            left: self,
-            right: rhs,
-        }
-    }
-}
-
-impl<F, E, T> Mul<T> for GasOptional<F, E>
-where
-    Self: GasExpression,
-    T: GasExpression,
-{
-    type Output = GasMul<Self, T>;
-
-    fn mul(self, rhs: T) -> Self::Output {
-        GasMul {
-            left: self,
-            right: rhs,
-        }
-    }
-}
-
-impl<L, R, U> GasExpression for Either<L, R>
-where
-    L: GasExpression<Unit = U>,
-    R: GasExpression<Unit = U>,
-{
-    type Unit = U;
-
-    #[inline]
-    fn materialize(
-        &self,
-        feature_version: u64,
-        gas_params: &AptosGasParameters,
-    ) -> GasQuantity<Self::Unit> {
-        match self {
-            Either::Left(left) => left.materialize(feature_version, gas_params),
-            Either::Right(right) => right.materialize(feature_version, gas_params),
-        }
-    }
-
-    #[inline]
-    fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
-        match self {
-            Either::Left(left) => left.visit(visitor),
-            Either::Right(right) => right.visit(visitor),
-        }
-    }
-}
-
-pub mod gas_switches {
-    use super::*;
-
-    macro_rules! define_gas_switch {
-        ($tn: ident < $($tp: ident),* $(,)? >) => {
-            #[allow(unused)]
-            pub enum $tn<$($tp),*> {
-                $(
-                    $tp($tp)
-                ),*
-            }
-
-            impl<U, $($tp),*> GasExpression for $tn<$($tp),*>
-            where
-                $($tp: GasExpression<Unit = U>),*
-            {
-                type Unit = U;
-
-                #[inline]
-                fn materialize(
-                    &self,
-                    feature_version: u64,
-                    gas_params: &AptosGasParameters,
-                ) -> GasQuantity<Self::Unit> {
-                    match self {
-                        $(
-                            $tn::$tp(e) => e.materialize(feature_version, gas_params)
-                        ),*
-                    }
-                }
-
-                #[inline]
-                fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
-                    match self {
-                        $(
-                            $tn::$tp(e) => e.visit(visitor)
-                        ),*
-                    }
-                }
-            }
-        };
-    }
-
-    define_gas_switch!(GasSwitch2<E1, E2>);
-    define_gas_switch!(GasSwitch3<E1, E2, E3>);
-    define_gas_switch!(GasSwitch4<E1, E2, E3, E4>);
-    define_gas_switch!(GasSwitch5<E1, E2, E3, E4, E5>);
-    define_gas_switch!(GasSwitch6<E1, E2, E3, E4, E5, E6>);
-    define_gas_switch!(GasSwitch7<E1, E2, E3, E4, E5, E6, E7>);
-    define_gas_switch!(GasSwitch8<E1, E2, E3, E4, E5, E6, E7, E8>);
-}
-
-impl<T> GasExpression for &T
-where
-    T: GasExpression,
-{
-    type Unit = T::Unit;
-
-    fn materialize(
-        &self,
-        feature_version: u64,
-        gas_params: &AptosGasParameters,
-    ) -> GasQuantity<Self::Unit> {
-        (*self).materialize(feature_version, gas_params)
-    }
-
-    fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
-        (*self).visit(visitor)
-    }
-}
diff --git a/aptos-move/aptos-gas/src/algebra.rs b/aptos-move/aptos-gas/src/algebra.rs
deleted file mode 100644
index bde9c7f77d315..0000000000000
--- a/aptos-move/aptos-gas/src/algebra.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
-pub use aptos_gas_algebra_ext::{
-    AbstractValueSize, AbstractValueSizePerArg, AbstractValueUnit, InternalGasPerAbstractValueUnit,
-};
-use move_core_types::gas_algebra::{Byte, GasQuantity, InternalGasUnit, UnitDiv};
-
-/// Unit of (external) gas.
-pub enum GasUnit {}
-
-/// Unit of gas currency. 1 Octa = 10^-8 Aptos coins.
-pub enum Octa {}
-
-pub type Gas = GasQuantity<GasUnit>;
-
-pub type GasScalingFactor = GasQuantity<UnitDiv<InternalGasUnit, GasUnit>>;
-
-pub type Fee = GasQuantity<Octa>;
-
-pub type FeePerGasUnit = GasQuantity<UnitDiv<Octa, GasUnit>>;
-
-/// Unit of storage slot
-pub enum Slot {}
-
-pub type NumSlots = GasQuantity<Slot>;
-
-pub type FeePerSlot = GasQuantity<UnitDiv<Octa, Slot>>;
-
-pub type FeePerByte = GasQuantity<UnitDiv<Octa, Byte>>;
diff --git a/aptos-move/aptos-gas/src/gas_meter.rs b/aptos-move/aptos-gas/src/gas_meter.rs
index f07ab27e0d32b..f0b492e7323b0 100644
--- a/aptos-move/aptos-gas/src/gas_meter.rs
+++ b/aptos-move/aptos-gas/src/gas_meter.rs
@@ -4,13 +4,11 @@
 //! This module contains the official gas meter implementation, along with some top-level gas
 //! parameters and traits to help manipulate them.
 
-use crate::{
-    abstract_algebra::{GasAlgebra, GasExpression},
-    algebra::{Fee, Gas},
-    instr::{gas_params::*, InstructionGasParameters},
-    misc::MiscGasParameters,
-    transaction::{gas_params::*, TransactionGasParameters},
-    FeePerGasUnit, GasScalingFactor, StorageGasParameters,
+use aptos_gas_algebra::{Fee, FeePerGasUnit, Gas, GasExpression, GasScalingFactor, Octa};
+use aptos_gas_schedule::{
+    instr_gas_params::*, txn_gas_params::*, FromOnChainGasSchedule, InitialGasSchedule,
+    InstructionGasParameters, MiscGasParameters, StorageGasParameters, ToOnChainGasSchedule,
+    TransactionGasParameters,
 };
 use aptos_logger::error;
 use aptos_types::{
@@ -32,67 +30,8 @@ use move_vm_types::{
 };
 use std::collections::BTreeMap;
 
-// Change log:
-// - V10
-//   - Added generate_unique_address and get_txn_hash native functions
-//   - Storage gas charges (excluding "storage fees") stop respecting the storage gas curves
-// - V9
-//   - Accurate tracking of the cost of loading resource groups
-// - V8
-//   - Added BLS12-381 operations.
-// - V7
-//   - Native support for exists<T>
-//   - New formulae for storage fees based on fixed APT costs
-//   - Lower gas price (other than the newly introduced storage fees) by upping the scaling factor
-// - V6
-//   - Added a new native function - blake2b_256.
-// - V5
-//   - u16, u32, u256
-//   - free_write_bytes_quota
-//   - configurable ChangeSetConfigs
-// - V4
-//   - Consider memory leaked for event natives
-// - V3
-//   - Add memory quota
-//   - Storage charges:
-//     - Distinguish between new and existing resources
-//     - One item write comes with 1K free bytes
-//     - abort with STORAGE_WRITE_LIMIT_REACHED if WriteOps or Events are too large
-// - V2
-//   - Table
-//     - Fix the gas formula for loading resources so that they are consistent with other
-//       global operations.
-// - V1
-//   - TBA
-pub const LATEST_GAS_FEATURE_VERSION: u64 = 10;
-
 pub(crate) const EXECUTION_GAS_MULTIPLIER: u64 = 20;
 
-/// A trait for converting from a map representation of the on-chain gas schedule.
-pub trait FromOnChainGasSchedule: Sized {
-    /// Constructs a value of this type from a map representation of the on-chain gas schedule.
-    /// `None` should be returned when the gas schedule is missing some required entries.
-    /// Unused entries should be safely ignored.
-    fn from_on_chain_gas_schedule(
-        gas_schedule: &BTreeMap<String, u64>,
-        feature_version: u64,
-    ) -> Result<Self, String>;
-}
-
-/// A trait for converting to a list of entries of the on-chain gas schedule.
-pub trait ToOnChainGasSchedule {
-    /// Converts `self` into a list of entries of the on-chain gas schedule.
-    /// Each entry is a key-value pair where the key is a string representing the name of the
-    /// parameter, where the value is the gas parameter itself.
-    fn to_on_chain_gas_schedule(&self, feature_version: u64) -> Vec<(String, u64)>;
-}
-
-/// A trait for defining an initial value to be used in the genesis.
-pub trait InitialGasSchedule: Sized {
-    /// Returns the initial value of this type, which is used in the genesis.
-    fn initial() -> Self;
-}
-
 /// Gas parameters for all native functions.
 #[derive(Debug, Clone)]
 pub struct NativeGasParameters {
@@ -372,6 +311,40 @@ pub trait AptosGasMeter: MoveGasMeter {
     }
 }
 
+pub trait GasAlgebra {
+    fn feature_version(&self) -> u64;
+
+    fn gas_params(&self) -> &AptosGasParameters;
+
+    fn storage_gas_params(&self) -> &StorageGasParameters;
+
+    fn balance_internal(&self) -> InternalGas;
+
+    fn charge_execution(
+        &mut self,
+        abstract_amount: impl GasExpression<AptosGasParameters, Unit = InternalGasUnit>,
+    ) -> PartialVMResult<()>;
+
+    fn charge_io(
+        &mut self,
+        abstract_amount: impl GasExpression<AptosGasParameters, Unit = InternalGasUnit>,
+    ) -> PartialVMResult<()>;
+
+    fn charge_storage_fee(
+        &mut self,
+        abstract_amount: impl GasExpression<AptosGasParameters, Unit = Octa>,
+        gas_unit_price: FeePerGasUnit,
+    ) -> PartialVMResult<()>;
+
+    fn execution_gas_used(&self) -> InternalGas;
+
+    fn io_gas_used(&self) -> InternalGas;
+
+    fn storage_fee_used_in_gas_units(&self) -> InternalGas;
+
+    fn storage_fee_used(&self) -> Fee;
+}
+
 pub struct StandardGasAlgebra {
     feature_version: u64,
     gas_params: AptosGasParameters,
@@ -443,7 +416,7 @@ impl GasAlgebra for StandardGasAlgebra {
 
     fn charge_execution(
         &mut self,
-        abstract_amount: impl GasExpression<Unit = InternalGasUnit>,
+        abstract_amount: impl GasExpression<AptosGasParameters, Unit = InternalGasUnit>,
     ) -> PartialVMResult<()> {
         let amount = abstract_amount.materialize(self.feature_version, &self.gas_params);
 
@@ -461,7 +434,7 @@ impl GasAlgebra for StandardGasAlgebra {
 
     fn charge_io(
         &mut self,
-        abstract_amount: impl GasExpression<Unit = InternalGasUnit>,
+        abstract_amount: impl GasExpression<AptosGasParameters, Unit = InternalGasUnit>,
     ) -> PartialVMResult<()> {
         let amount = abstract_amount.materialize(self.feature_version, &self.gas_params);
 
@@ -477,7 +450,7 @@ impl GasAlgebra for StandardGasAlgebra {
 
     fn charge_storage_fee(
         &mut self,
-        abstract_amount: impl GasExpression<Unit = crate::Octa>,
+        abstract_amount: impl GasExpression<AptosGasParameters, Unit = Octa>,
         gas_unit_price: FeePerGasUnit,
     ) -> PartialVMResult<()> {
         let amount = abstract_amount.materialize(self.feature_version, &self.gas_params);
diff --git a/aptos-move/aptos-gas/src/gen.rs b/aptos-move/aptos-gas/src/gen.rs
index c92786faa6419..556ea8bbbd66a 100644
--- a/aptos-move/aptos-gas/src/gen.rs
+++ b/aptos-move/aptos-gas/src/gen.rs
@@ -1,10 +1,9 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::gas_meter::{
-    AptosGasParameters, InitialGasSchedule, ToOnChainGasSchedule, LATEST_GAS_FEATURE_VERSION,
-};
+use crate::gas_meter::{AptosGasParameters, InitialGasSchedule, ToOnChainGasSchedule};
 use anyhow::Result;
+use aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION;
 use aptos_package_builder::PackageBuilder;
 use aptos_types::on_chain_config::GasScheduleV2;
 use clap::Parser;
diff --git a/aptos-move/aptos-gas/src/lib.rs b/aptos-move/aptos-gas/src/lib.rs
index 07f9de18a5947..163f14610f856 100644
--- a/aptos-move/aptos-gas/src/lib.rs
+++ b/aptos-move/aptos-gas/src/lib.rs
@@ -21,35 +21,13 @@
 #[macro_use]
 mod natives;
 
-#[macro_use]
-mod params;
-
-mod abstract_algebra;
-mod algebra;
 mod aptos_framework;
 mod gas_meter;
 pub mod gen;
-mod instr;
-mod misc;
 mod move_stdlib;
 mod table;
-mod transaction;
 
-pub use abstract_algebra::{
-    gas_switches::*, GasAdd, GasAlgebra, GasExpression, GasExpressionVisitor, GasMul,
-};
-pub use algebra::*;
 pub use gas_meter::{
     AptosGasMeter, AptosGasParameters, FromOnChainGasSchedule, InitialGasSchedule,
     NativeGasParameters, StandardGasAlgebra, StandardGasMeter, ToOnChainGasSchedule,
-    LATEST_GAS_FEATURE_VERSION,
-};
-pub use instr::InstructionGasParameters;
-pub use misc::{AbstractValueSizeGasParameters, MiscGasParameters};
-pub use move_core_types::gas_algebra::{
-    Arg, Byte, GasQuantity, InternalGas, InternalGasPerArg, InternalGasPerByte, InternalGasUnit,
-    NumArgs, NumBytes, UnitDiv,
-};
-pub use transaction::{
-    ChangeSetConfigs, StorageGasParameters, StoragePricing, TransactionGasParameters,
 };
diff --git a/aptos-move/aptos-gas/src/natives.rs b/aptos-move/aptos-gas/src/natives.rs
index 09d8d28172be9..e3f05f5229b7d 100644
--- a/aptos-move/aptos-gas/src/natives.rs
+++ b/aptos-move/aptos-gas/src/natives.rs
@@ -69,7 +69,7 @@ macro_rules! define_gas_parameters_for_natives {
 
         #[test]
         fn keys_should_be_unique_for_all_versions() {
-            for ver in 0..=$crate::gas_meter::LATEST_GAS_FEATURE_VERSION {
+            for ver in 0..=aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION {
                 let mut map = std::collections::BTreeMap::<&str, ()>::new();
 
                 $(
diff --git a/aptos-move/aptos-memory-usage-tracker/Cargo.toml b/aptos-move/aptos-memory-usage-tracker/Cargo.toml
index 18e883ac0f7d6..2daf424954945 100644
--- a/aptos-move/aptos-memory-usage-tracker/Cargo.toml
+++ b/aptos-move/aptos-memory-usage-tracker/Cargo.toml
@@ -13,6 +13,7 @@ rust-version = { workspace = true }
 
 [dependencies]
 aptos-gas = { workspace = true }
+aptos-gas-algebra = { workspace = true }
 aptos-types = { workspace = true }
 move-binary-format = { workspace = true }
 move-core-types = { workspace = true }
diff --git a/aptos-move/aptos-memory-usage-tracker/src/lib.rs b/aptos-move/aptos-memory-usage-tracker/src/lib.rs
index b7e1d40eef8d6..f3d5decacec09 100644
--- a/aptos-move/aptos-memory-usage-tracker/src/lib.rs
+++ b/aptos-move/aptos-memory-usage-tracker/src/lib.rs
@@ -1,9 +1,8 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use aptos_gas::{
-    AbstractValueSize, AptosGasMeter, Fee, FeePerGasUnit, InternalGas, NumArgs, NumBytes,
-};
+use aptos_gas::AptosGasMeter;
+use aptos_gas_algebra::{AbstractValueSize, Fee, FeePerGasUnit, InternalGas, NumArgs, NumBytes};
 use aptos_types::{
     account_config::CORE_CODE_ADDRESS, contract_event::ContractEvent,
     state_store::state_key::StateKey, write_set::WriteOp,
@@ -231,7 +230,7 @@ where
         addr: move_core_types::account_address::AccountAddress,
         ty: impl TypeView,
         val: Option<impl ValueView>,
-        bytes_loaded: aptos_gas::NumBytes,
+        bytes_loaded: NumBytes,
     ) -> PartialVMResult<()> {
         if self.feature_version() != 0 {
             // TODO(Gas): Rewrite this in a better way.
@@ -404,7 +403,7 @@ where
     fn charge_vec_unpack(
         &mut self,
         ty: impl TypeView,
-        expect_num_elements: aptos_gas::NumArgs,
+        expect_num_elements: NumArgs,
         elems: impl ExactSizeIterator<Item = impl ValueView> + Clone,
     ) -> PartialVMResult<()> {
         self.release_heap_memory(elems.clone().fold(AbstractValueSize::zero(), |acc, val| {
diff --git a/aptos-move/aptos-vm/Cargo.toml b/aptos-move/aptos-vm/Cargo.toml
index 60a3ae0b2b48c..46a1e0a69fb6d 100644
--- a/aptos-move/aptos-vm/Cargo.toml
+++ b/aptos-move/aptos-vm/Cargo.toml
@@ -21,6 +21,8 @@ aptos-crypto = { workspace = true }
 aptos-crypto-derive = { workspace = true }
 aptos-framework =  { workspace = true }
 aptos-gas = { workspace = true }
+aptos-gas-algebra = { workspace = true }
+aptos-gas-schedule = { workspace = true }
 aptos-infallible = { workspace = true }
 aptos-logger = { workspace = true }
 aptos-memory-usage-tracker = { workspace = true }
diff --git a/aptos-move/aptos-vm/src/aptos_vm.rs b/aptos-move/aptos-vm/src/aptos_vm.rs
index 9e48fb4a0574f..ec2ed57f61442 100644
--- a/aptos-move/aptos-vm/src/aptos_vm.rs
+++ b/aptos-move/aptos-vm/src/aptos_vm.rs
@@ -23,9 +23,10 @@ use aptos_block_executor::txn_commit_hook::NoOpTransactionCommitHook;
 use aptos_crypto::HashValue;
 use aptos_framework::natives::code::PublishRequest;
 use aptos_gas::{
-    AptosGasMeter, AptosGasParameters, ChangeSetConfigs, Gas, StandardGasAlgebra, StandardGasMeter,
+    AptosGasMeter, AptosGasParameters, ChangeSetConfigs, StandardGasAlgebra, StandardGasMeter,
     StorageGasParameters,
 };
+use aptos_gas_algebra::Gas;
 use aptos_logger::{enabled, prelude::*, Level};
 use aptos_memory_usage_tracker::MemoryTrackedGasMeter;
 use aptos_state_view::StateView;
diff --git a/aptos-move/aptos-vm/src/aptos_vm_impl.rs b/aptos-move/aptos-vm/src/aptos_vm_impl.rs
index 71c0ea2d70f29..a67f4dafc75ee 100644
--- a/aptos-move/aptos-vm/src/aptos_vm_impl.rs
+++ b/aptos-move/aptos-vm/src/aptos_vm_impl.rs
@@ -14,8 +14,9 @@ use crate::{
 use aptos_framework::RuntimeModuleMetadataV1;
 use aptos_gas::{
     AbstractValueSizeGasParameters, AptosGasParameters, ChangeSetConfigs, FromOnChainGasSchedule,
-    Gas, GasExpression, NativeGasParameters, StorageGasParameters, StoragePricing,
+    NativeGasParameters, StorageGasParameters, StoragePricing,
 };
+use aptos_gas_algebra::{Gas, GasExpression};
 use aptos_logger::{enabled, prelude::*, Level};
 use aptos_state_view::StateView;
 use aptos_types::{
diff --git a/aptos-move/aptos-vm/src/natives.rs b/aptos-move/aptos-vm/src/natives.rs
index 4ee79f9a027dc..de27dc288f01d 100644
--- a/aptos-move/aptos-vm/src/natives.rs
+++ b/aptos-move/aptos-vm/src/natives.rs
@@ -4,7 +4,8 @@
 
 #[cfg(feature = "testing")]
 use aptos_framework::natives::cryptography::algebra::AlgebraContext;
-use aptos_gas::{AbstractValueSizeGasParameters, NativeGasParameters, LATEST_GAS_FEATURE_VERSION};
+use aptos_gas::{AbstractValueSizeGasParameters, NativeGasParameters};
+use aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION;
 #[cfg(feature = "testing")]
 use aptos_types::chain_id::ChainId;
 use aptos_types::{
diff --git a/aptos-move/aptos-vm/src/transaction_metadata.rs b/aptos-move/aptos-vm/src/transaction_metadata.rs
index 3c4be633af6ff..3b6330d2670ac 100644
--- a/aptos-move/aptos-vm/src/transaction_metadata.rs
+++ b/aptos-move/aptos-vm/src/transaction_metadata.rs
@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use aptos_crypto::{ed25519::Ed25519PrivateKey, HashValue, PrivateKey};
-use aptos_gas::{FeePerGasUnit, Gas, NumBytes};
+use aptos_gas_algebra::{FeePerGasUnit, Gas, NumBytes};
 use aptos_types::{
     account_address::AccountAddress,
     chain_id::ChainId,
diff --git a/aptos-move/e2e-move-tests/Cargo.toml b/aptos-move/e2e-move-tests/Cargo.toml
index 1dd8ba2605f1c..16ed248070fb6 100644
--- a/aptos-move/e2e-move-tests/Cargo.toml
+++ b/aptos-move/e2e-move-tests/Cargo.toml
@@ -20,6 +20,7 @@ aptos-cached-packages = { workspace = true }
 aptos-crypto = { workspace = true }
 aptos-framework = { workspace = true }
 aptos-gas = { workspace = true, features = ["testing"] }
+aptos-gas-algebra = { workspace = true }
 aptos-gas-profiling = { workspace = true }
 aptos-keygen = { workspace = true }
 aptos-language-e2e-tests = { workspace = true }
diff --git a/aptos-move/e2e-move-tests/src/tests/per_category_gas_limits.rs b/aptos-move/e2e-move-tests/src/tests/per_category_gas_limits.rs
index fb9541197eaad..24cd88dd13e61 100644
--- a/aptos-move/e2e-move-tests/src/tests/per_category_gas_limits.rs
+++ b/aptos-move/e2e-move-tests/src/tests/per_category_gas_limits.rs
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{assert_success, assert_vm_status, tests::common, MoveHarness};
-use aptos_gas::{Fee, Gas};
+use aptos_gas_algebra::{Fee, Gas};
 use aptos_types::{account_address::AccountAddress, vm_status::StatusCode};
 use move_core_types::gas_algebra::InternalGas;
 use serde::{Deserialize, Serialize};
diff --git a/aptos-move/e2e-tests/Cargo.toml b/aptos-move/e2e-tests/Cargo.toml
index 3eb674ad24c77..3cfa40a21b35e 100644
--- a/aptos-move/e2e-tests/Cargo.toml
+++ b/aptos-move/e2e-tests/Cargo.toml
@@ -19,7 +19,9 @@ aptos-block-executor = { workspace = true }
 aptos-cached-packages ={ workspace = true }
 aptos-crypto = { workspace = true, features = ["fuzzing"] }
 aptos-framework = { workspace = true }
+aptos-gas-schedule = { workspace = true }
 aptos-gas = { workspace = true }
+aptos-gas-algebra = { workspace = true }
 aptos-gas-profiling = { workspace = true }
 aptos-keygen = { workspace = true }
 aptos-memory-usage-tracker = { workspace = true }
diff --git a/aptos-move/e2e-tests/src/account_universe/bad_transaction.rs b/aptos-move/e2e-tests/src/account_universe/bad_transaction.rs
index 4990ab5be1426..61dff46e40a48 100644
--- a/aptos-move/e2e-tests/src/account_universe/bad_transaction.rs
+++ b/aptos-move/e2e-tests/src/account_universe/bad_transaction.rs
@@ -11,10 +11,9 @@ use aptos_crypto::{
     ed25519::{Ed25519PrivateKey, Ed25519PublicKey},
     test_utils::KeyPair,
 };
-use aptos_gas::{
-    AptosGasParameters, FeePerGasUnit, Gas, GasExpression, InitialGasSchedule,
-    LATEST_GAS_FEATURE_VERSION,
-};
+use aptos_gas::{AptosGasParameters, InitialGasSchedule};
+use aptos_gas_algebra::{FeePerGasUnit, Gas, GasExpression};
+use aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION;
 use aptos_proptest_helpers::Index;
 use aptos_types::{
     transaction::{Script, SignedTransaction, TransactionStatus},
diff --git a/aptos-move/e2e-tests/src/executor.rs b/aptos-move/e2e-tests/src/executor.rs
index 3fb51e7cc852b..64d213aa577e9 100644
--- a/aptos-move/e2e-tests/src/executor.rs
+++ b/aptos-move/e2e-tests/src/executor.rs
@@ -19,9 +19,10 @@ use aptos_crypto::HashValue;
 use aptos_framework::ReleaseBundle;
 use aptos_gas::{
     AbstractValueSizeGasParameters, ChangeSetConfigs, NativeGasParameters, StandardGasAlgebra,
-    StandardGasMeter, LATEST_GAS_FEATURE_VERSION,
+    StandardGasMeter,
 };
 use aptos_gas_profiling::{GasProfiler, TransactionGasLog};
+use aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION;
 use aptos_keygen::KeyGen;
 use aptos_memory_usage_tracker::MemoryTrackedGasMeter;
 use aptos_state_view::TStateView;
diff --git a/aptos-move/framework/Cargo.toml b/aptos-move/framework/Cargo.toml
index 488111082357b..6e479a2c91eff 100644
--- a/aptos-move/framework/Cargo.toml
+++ b/aptos-move/framework/Cargo.toml
@@ -16,7 +16,7 @@ rust-version = { workspace = true }
 anyhow = { workspace = true }
 aptos-aggregator = { workspace = true }
 aptos-crypto = { workspace = true, features = ["fuzzing"] }
-aptos-gas-algebra-ext = { workspace = true }
+aptos-gas-algebra = { workspace = true }
 aptos-move-stdlib = { workspace = true }
 aptos-sdk-builder = { workspace = true }
 aptos-state-view = { workspace = true }
diff --git a/aptos-move/framework/src/natives/event.rs b/aptos-move/framework/src/natives/event.rs
index ae0b529a428a7..f47ff9ff18ac6 100644
--- a/aptos-move/framework/src/natives/event.rs
+++ b/aptos-move/framework/src/natives/event.rs
@@ -7,7 +7,7 @@ use crate::{
     },
     safely_pop_arg,
 };
-use aptos_gas_algebra_ext::{AbstractValueSize, InternalGasPerAbstractValueUnit};
+use aptos_gas_algebra::{AbstractValueSize, InternalGasPerAbstractValueUnit};
 use aptos_types::on_chain_config::{Features, TimedFeatures};
 use move_core_types::gas_algebra::InternalGas;
 use move_vm_runtime::native_functions::NativeFunction;
diff --git a/aptos-move/framework/src/natives/helpers.rs b/aptos-move/framework/src/natives/helpers.rs
index cdbd0ba843691..db7c896c62398 100644
--- a/aptos-move/framework/src/natives/helpers.rs
+++ b/aptos-move/framework/src/natives/helpers.rs
@@ -162,7 +162,7 @@ macro_rules! safely_pop_type_arg {
 #[allow(unused)]
 pub struct SafeNativeContext<'a, 'b, 'c, 'd> {
     timed_features: &'c TimedFeatures,
-    features: Arc<Features>,
+    features: &'c Features,
     inner: &'c mut NativeContext<'a, 'b, 'd>,
 
     gas_budget: InternalGas,
@@ -199,6 +199,13 @@ impl<'a, 'b, 'c, 'd> SafeNativeContext<'a, 'b, 'c, 'd> {
         }
     }
 
+    //pub fn charge_abstract(
+    //    &mut self,
+    //    abstract_amount: impl GasExpression<Unit = InternalGasUnit>,
+    //) -> SafeNativeResult<()> {
+    //    unimplemented!()
+    //}
+
     pub fn get_feature_flags(&self) -> &Features {
         self.features.deref()
     }
@@ -248,7 +255,7 @@ where
 
         let mut context = SafeNativeContext {
             timed_features: &timed_features,
-            features: features.clone(),
+            features: &features,
             inner: context,
 
             gas_budget,
diff --git a/aptos-move/framework/src/natives/mod.rs b/aptos-move/framework/src/natives/mod.rs
index 177b1c0416870..f4b96f9379791 100644
--- a/aptos-move/framework/src/natives/mod.rs
+++ b/aptos-move/framework/src/natives/mod.rs
@@ -21,7 +21,7 @@ pub mod util;
 
 use crate::natives::cryptography::multi_ed25519;
 use aggregator_natives::{aggregator, aggregator_factory};
-use aptos_gas_algebra_ext::AbstractValueSize;
+use aptos_gas_algebra::AbstractValueSize;
 use aptos_types::on_chain_config::{Features, TimedFeatures};
 use cryptography::ed25519;
 use move_core_types::{account_address::AccountAddress, identifier::Identifier};
diff --git a/aptos-move/gas-algebra-ext/src/lib.rs b/aptos-move/gas-algebra-ext/src/lib.rs
deleted file mode 100644
index a5c3f0ea03873..0000000000000
--- a/aptos-move/gas-algebra-ext/src/lib.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
-use move_core_types::gas_algebra::{Arg, GasQuantity, InternalGasUnit, UnitDiv};
-
-/// Unit of abstract value size -- a conceptual measurement of the memory space a Move value occupies.
-pub enum AbstractValueUnit {}
-
-pub type AbstractValueSize = GasQuantity<AbstractValueUnit>;
-
-pub type InternalGasPerAbstractValueUnit = GasQuantity<UnitDiv<InternalGasUnit, AbstractValueUnit>>;
-
-pub type AbstractValueSizePerArg = GasQuantity<UnitDiv<AbstractValueUnit, Arg>>;
diff --git a/aptos-move/move-examples/Cargo.toml b/aptos-move/move-examples/Cargo.toml
index 3e781d3accb6b..f32df71924596 100644
--- a/aptos-move/move-examples/Cargo.toml
+++ b/aptos-move/move-examples/Cargo.toml
@@ -13,6 +13,7 @@ repository = { workspace = true }
 rust-version = { workspace = true }
 
 [dependencies]
+aptos-gas-schedule = { workspace = true }
 aptos-gas = { workspace = true }
 aptos-types = { workspace = true }
 aptos-vm ={ workspace = true, features = ["testing"] }
diff --git a/aptos-move/move-examples/tests/move_unit_tests.rs b/aptos-move/move-examples/tests/move_unit_tests.rs
index fa2ea5829d9fd..86edc673c87fb 100644
--- a/aptos-move/move-examples/tests/move_unit_tests.rs
+++ b/aptos-move/move-examples/tests/move_unit_tests.rs
@@ -1,7 +1,8 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use aptos_gas::{AbstractValueSizeGasParameters, NativeGasParameters, LATEST_GAS_FEATURE_VERSION};
+use aptos_gas::{AbstractValueSizeGasParameters, NativeGasParameters};
+use aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION;
 use aptos_types::{
     account_address::{create_resource_address, AccountAddress},
     on_chain_config::{Features, TimedFeatures},
diff --git a/aptos-move/vm-genesis/Cargo.toml b/aptos-move/vm-genesis/Cargo.toml
index 442b2fbd27b4c..8f06ecb94e4bf 100644
--- a/aptos-move/vm-genesis/Cargo.toml
+++ b/aptos-move/vm-genesis/Cargo.toml
@@ -17,6 +17,7 @@ anyhow = { workspace = true }
 aptos-cached-packages =  { workspace = true }
 aptos-crypto = { workspace = true }
 aptos-framework =  { workspace = true }
+aptos-gas-schedule = { workspace = true }
 aptos-gas = { workspace = true }
 aptos-state-view = { workspace = true }
 aptos-types = { workspace = true }
diff --git a/aptos-move/vm-genesis/src/lib.rs b/aptos-move/vm-genesis/src/lib.rs
index f7ccab6a3a499..71d59b0af8157 100644
--- a/aptos-move/vm-genesis/src/lib.rs
+++ b/aptos-move/vm-genesis/src/lib.rs
@@ -15,8 +15,9 @@ use aptos_crypto::{
 use aptos_framework::{ReleaseBundle, ReleasePackage};
 use aptos_gas::{
     AbstractValueSizeGasParameters, AptosGasParameters, ChangeSetConfigs, InitialGasSchedule,
-    NativeGasParameters, ToOnChainGasSchedule, LATEST_GAS_FEATURE_VERSION,
+    NativeGasParameters, ToOnChainGasSchedule,
 };
+use aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION;
 use aptos_types::{
     account_config::{self, aptos_test_root_address, events::NewEpochEvent, CORE_CODE_ADDRESS},
     chain_id::ChainId,
@@ -81,7 +82,7 @@ pub static GENESIS_KEYPAIR: Lazy<(Ed25519PrivateKey, Ed25519PublicKey)> = Lazy::
 // Cannot be impl Default in GasScheduleV2, due to circular dependencies.
 pub fn default_gas_schedule() -> GasScheduleV2 {
     GasScheduleV2 {
-        feature_version: aptos_gas::LATEST_GAS_FEATURE_VERSION,
+        feature_version: LATEST_GAS_FEATURE_VERSION,
         entries: AptosGasParameters::initial().to_on_chain_gas_schedule(LATEST_GAS_FEATURE_VERSION),
     }
 }
diff --git a/crates/aptos/Cargo.toml b/crates/aptos/Cargo.toml
index eb20722e55640..ccdebdce15cd0 100644
--- a/crates/aptos/Cargo.toml
+++ b/crates/aptos/Cargo.toml
@@ -26,6 +26,7 @@ aptos-db-tool = { workspace = true }
 aptos-debugger = { workspace = true }
 aptos-faucet-core = { workspace = true }
 aptos-framework = { workspace = true }
+aptos-gas-schedule = { workspace = true }
 aptos-gas = { workspace = true }
 aptos-gas-profiling = { workspace = true }
 aptos-genesis = { workspace = true }
diff --git a/crates/aptos/src/move_tool/aptos_debug_natives.rs b/crates/aptos/src/move_tool/aptos_debug_natives.rs
index 7abcb46f714ce..1e018938683b7 100644
--- a/crates/aptos/src/move_tool/aptos_debug_natives.rs
+++ b/crates/aptos/src/move_tool/aptos_debug_natives.rs
@@ -1,7 +1,8 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use aptos_gas::{AbstractValueSizeGasParameters, NativeGasParameters, LATEST_GAS_FEATURE_VERSION};
+use aptos_gas::{AbstractValueSizeGasParameters, NativeGasParameters};
+use aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION;
 use aptos_types::on_chain_config::{Features, TimedFeatures};
 use aptos_vm::natives;
 use move_vm_runtime::native_functions::NativeFunctionTable;
diff --git a/testsuite/smoke-test/Cargo.toml b/testsuite/smoke-test/Cargo.toml
index e9748bbdf8b44..1bc3258edc5d6 100644
--- a/testsuite/smoke-test/Cargo.toml
+++ b/testsuite/smoke-test/Cargo.toml
@@ -25,6 +25,7 @@ aptos-faucet-core = { workspace = true }
 aptos-forge = { workspace = true }
 aptos-framework = { workspace = true }
 aptos-gas = { workspace = true, features = ["testing"] }
+aptos-gas-algebra = { workspace = true }
 aptos-global-constants = { workspace = true }
 aptos-indexer = { workspace = true }
 aptos-keygen = { workspace = true }
diff --git a/testsuite/smoke-test/src/upgrade.rs b/testsuite/smoke-test/src/upgrade.rs
index 6556b8031d0a0..17543544da4f4 100644
--- a/testsuite/smoke-test/src/upgrade.rs
+++ b/testsuite/smoke-test/src/upgrade.rs
@@ -7,7 +7,8 @@ use crate::{
 };
 use aptos_crypto::ValidCryptoMaterialStringExt;
 use aptos_forge::Swarm;
-use aptos_gas::{AptosGasParameters, GasQuantity, InitialGasSchedule, ToOnChainGasSchedule};
+use aptos_gas::{AptosGasParameters, InitialGasSchedule, ToOnChainGasSchedule};
+use aptos_gas_algebra::GasQuantity;
 use aptos_release_builder::{
     components::{
         feature_flags::{FeatureFlag, Features},
diff --git a/third_party/move/move-core/types/src/gas_algebra.rs b/third_party/move/move-core/types/src/gas_algebra.rs
index 60bbaa8b0c65f..1c2a0b4c1a273 100644
--- a/third_party/move/move-core/types/src/gas_algebra.rs
+++ b/third_party/move/move-core/types/src/gas_algebra.rs
@@ -379,58 +379,45 @@ impl ToUnitFractional<GibiByte> for Byte {
  **************************************************************************************************/
 /// Trait that defines a conversion from one unit to another, with an integral conversion rate
 /// determined from the parameters dynamically.
-pub trait ToUnitWithParams<U> {
-    type Params;
-
-    fn multiplier(params: &Self::Params) -> u64;
+pub trait ToUnitWithParams<P, U> {
+    fn multiplier(params: &P) -> u64;
 }
 
 /// Trait that defines a conversion from one unit to another, with a fractional conversion rate
 /// determined from the parameters dynamically.
-pub trait ToUnitFractionalWithParams<U> {
-    type Params;
-
-    fn ratio(params: &Self::Params) -> (u64, u64);
+pub trait ToUnitFractionalWithParams<P, U> {
+    fn ratio(params: &P) -> (u64, u64);
 }
 
 impl<U> GasQuantity<U> {
     /// Convert the quantity to another unit.
     /// An integral multiplier must have been defined via the `ToUnitWithParams` trait.
-    pub fn to_unit_with_params<T>(
-        self,
-        params: &<U as ToUnitWithParams<T>>::Params,
-    ) -> GasQuantity<T>
+    pub fn to_unit_with_params<P, T>(self, params: &P) -> GasQuantity<T>
     where
-        U: ToUnitWithParams<T>,
+        U: ToUnitWithParams<P, T>,
     {
-        let multiplier = <U as ToUnitWithParams<T>>::multiplier(params);
+        let multiplier = <U as ToUnitWithParams<P, T>>::multiplier(params);
         assert_ne!(multiplier, 0);
         GasQuantity::new(self.val.saturating_mul(multiplier))
     }
 
     /// Convert the quantity to another unit, with the resulting scalar value being rounded down.
     /// A ratio must have been defined via the `ToUnitFractionalWithParams` trait.
-    pub fn to_unit_round_down_with_params<T>(
-        self,
-        params: &<U as ToUnitFractionalWithParams<T>>::Params,
-    ) -> GasQuantity<T>
+    pub fn to_unit_round_down_with_params<P, T>(self, params: &P) -> GasQuantity<T>
     where
-        U: ToUnitFractionalWithParams<T>,
+        U: ToUnitFractionalWithParams<P, T>,
     {
-        let (n, d) = <U as ToUnitFractionalWithParams<T>>::ratio(params);
+        let (n, d) = <U as ToUnitFractionalWithParams<P, T>>::ratio(params);
         GasQuantity::new(apply_ratio_round_down(self.val, n, d))
     }
 
     /// Convert the quantity to another unit, with the resulting scalar value being rounded up.
     /// A ratio must have been defined via the `ToUnitFractionalWithParams` trait.
-    pub fn to_unit_round_up_with_params<T>(
-        self,
-        params: &<U as ToUnitFractionalWithParams<T>>::Params,
-    ) -> GasQuantity<T>
+    pub fn to_unit_round_up_with_params<P, T>(self, params: &P) -> GasQuantity<T>
     where
-        U: ToUnitFractionalWithParams<T>,
+        U: ToUnitFractionalWithParams<P, T>,
     {
-        let (n, d) = <U as ToUnitFractionalWithParams<T>>::ratio(params);
+        let (n, d) = <U as ToUnitFractionalWithParams<P, T>>::ratio(params);
         GasQuantity::new(apply_ratio_round_up(self.val, n, d))
     }
 }

From 3e621eb4b7b39e38e85603ba5ff4fa2450708f04 Mon Sep 17 00:00:00 2001
From: Victor Gao <vgao1996@gmail.com>
Date: Mon, 10 Jul 2023 07:23:59 +0000
Subject: [PATCH 3/4] [gas] abstract gas algebra part 3 -- natives

---
 Cargo.lock                                    |  133 ++-
 Cargo.toml                                    |   10 +-
 api/Cargo.toml                                |    4 +-
 api/src/context.rs                            |    4 +-
 api/src/transactions.rs                       |    6 +-
 aptos-move/aptos-aggregator/Cargo.toml        |    2 +-
 .../src/aggregator_extension.rs               |    2 +-
 aptos-move/aptos-debugger/Cargo.toml          |    6 +-
 aptos-move/aptos-debugger/src/lib.rs          |   11 +-
 .../aptos-gas-algebra/src/abstract_algebra.rs |  166 ++-
 aptos-move/aptos-gas-algebra/src/algebra.rs   |    4 +-
 aptos-move/aptos-gas-algebra/src/lib.rs       |    8 +
 .../{aptos-gas => aptos-gas-meter}/Cargo.toml |    9 +-
 aptos-move/aptos-gas-meter/src/algebra.rs     |  187 +++
 aptos-move/aptos-gas-meter/src/lib.rs         |   13 +
 aptos-move/aptos-gas-meter/src/meter.rs       |  527 +++++++++
 aptos-move/aptos-gas-meter/src/traits.rs      |  221 ++++
 aptos-move/aptos-gas-profiling/Cargo.toml     |    2 +-
 .../aptos-gas-profiling/src/profiler.rs       |    2 +-
 .../aptos-gas-schedule-updator/Cargo.toml     |   28 +
 .../src/lib.rs}                               |   30 +-
 .../src/main.rs}                              |    2 +-
 .../tests/gen_tests.rs                        |    2 +-
 aptos-move/aptos-gas-schedule/Cargo.toml      |    5 +-
 aptos-move/aptos-gas-schedule/run.py          |  202 ----
 .../aptos-gas-schedule/src/gas_params/mod.rs  |   73 --
 .../src/gas_schedule/aptos_framework.rs       |  202 ++++
 .../src/{gas_params => gas_schedule}/instr.rs |    7 +-
 .../{gas_params => gas_schedule}/macros.rs    |   42 +-
 .../src/{gas_params => gas_schedule}/misc.rs  |   12 +-
 .../src/gas_schedule/mod.rs                   |  199 ++++
 .../src/gas_schedule/move_stdlib.rs           |   35 +
 .../src/gas_schedule/table.rs                 |   38 +
 .../transaction.rs                            |   13 +-
 aptos-move/aptos-gas-schedule/src/lib.rs      |   29 +-
 aptos-move/aptos-gas-schedule/src/ver.rs      |   66 +-
 aptos-move/aptos-gas/src/aptos_framework.rs   |  193 ----
 aptos-move/aptos-gas/src/gas_meter.rs         | 1019 -----------------
 aptos-move/aptos-gas/src/lib.rs               |   33 -
 aptos-move/aptos-gas/src/move_stdlib.rs       |   34 -
 aptos-move/aptos-gas/src/natives.rs           |  110 --
 aptos-move/aptos-gas/src/table.rs             |   31 -
 .../aptos-memory-usage-tracker/Cargo.toml     |    2 +-
 .../aptos-memory-usage-tracker/src/lib.rs     |   42 +-
 aptos-move/aptos-native-interface/Cargo.toml  |   22 +
 .../aptos-native-interface/src/builder.rs     |  159 +++
 .../aptos-native-interface/src/context.rs     |  112 ++
 .../aptos-native-interface/src/errors.rs      |   42 +
 .../aptos-native-interface/src/helpers.rs     |   92 ++
 aptos-move/aptos-native-interface/src/lib.rs  |   26 +
 .../aptos-native-interface/src/native.rs      |   17 +
 .../aptos-native-interface/src/reexports.rs   |    4 +
 aptos-move/aptos-release-builder/Cargo.toml   |    2 +-
 .../src/components/mod.rs                     |    7 +-
 .../aptos-transaction-benchmarks/Cargo.toml   |    2 +-
 .../Cargo.toml                                |    2 +-
 .../src/aptos_test_harness.rs                 |    2 +-
 aptos-move/aptos-vm-profiling/Cargo.toml      |    4 +-
 .../aptos-vm-profiling/src/bins/run_move.rs   |   29 +-
 aptos-move/aptos-vm-types/Cargo.toml          |    3 +
 aptos-move/aptos-vm-types/src/lib.rs          |    1 +
 .../src}/storage.rs                           |   56 +-
 aptos-move/aptos-vm/Cargo.toml                |    5 +-
 aptos-move/aptos-vm/src/aptos_vm.rs           |   22 +-
 aptos-move/aptos-vm/src/aptos_vm_impl.rs      |   45 +-
 aptos-move/aptos-vm/src/data_cache.rs         |    2 +-
 .../aptos-vm/src/move_vm_ext/resolver.rs      |    2 +-
 .../src/move_vm_ext/respawned_session.rs      |    3 +-
 .../aptos-vm/src/move_vm_ext/session.rs       |    5 +-
 aptos-move/aptos-vm/src/move_vm_ext/vm.rs     |   13 +-
 aptos-move/aptos-vm/src/natives.rs            |   41 +-
 aptos-move/e2e-move-tests/Cargo.toml          |    2 +-
 aptos-move/e2e-move-tests/src/harness.rs      |    8 +-
 .../src/tests/per_category_gas_limits.rs      |   18 +-
 aptos-move/e2e-tests/Cargo.toml               |    7 +-
 .../src/account_universe/bad_transaction.rs   |    7 +-
 aptos-move/e2e-tests/src/data_store.rs        |    2 +-
 aptos-move/e2e-tests/src/executor.rs          |   14 +-
 aptos-move/e2e-testsuite/Cargo.toml           |    4 +-
 .../src/tests/failed_transaction_tests.rs     |    9 +-
 .../e2e-testsuite/src/tests/verify_txn.rs     |   16 +-
 aptos-move/framework/Cargo.toml               |    7 +-
 aptos-move/framework/move-stdlib/Cargo.toml   |    3 +
 .../framework/move-stdlib/src/natives/bcs.rs  |   80 +-
 .../framework/move-stdlib/src/natives/hash.rs |  102 +-
 .../move-stdlib/src/natives/helpers.rs        |   14 -
 .../framework/move-stdlib/src/natives/mod.rs  |  102 +-
 .../move-stdlib/src/natives/signer.rs         |   56 +-
 .../move-stdlib/src/natives/string.rs         |  179 +--
 .../move-stdlib/src/natives/unit_test.rs      |   59 +-
 .../move-stdlib/src/natives/vector.rs         |  321 ------
 aptos-move/framework/src/natives/account.rs   |   51 +-
 .../natives/aggregator_natives/aggregator.rs  |  102 +-
 .../aggregator_natives/aggregator_factory.rs  |   49 +-
 .../src/natives/aggregator_natives/context.rs |    2 +-
 .../src/natives/aggregator_natives/helpers.rs |    2 +-
 aptos-move/framework/src/natives/code.rs      |   74 +-
 .../framework/src/natives/create_signer.rs    |   32 +-
 .../cryptography/algebra/arithmetics/add.rs   |   36 +-
 .../cryptography/algebra/arithmetics/div.rs   |   26 +-
 .../algebra/arithmetics/double.rs             |   22 +-
 .../cryptography/algebra/arithmetics/inv.rs   |   22 +-
 .../cryptography/algebra/arithmetics/mod.rs   |   10 +-
 .../cryptography/algebra/arithmetics/mul.rs   |   24 +-
 .../cryptography/algebra/arithmetics/neg.rs   |   28 +-
 .../algebra/arithmetics/scalar_mul.rs         |   58 +-
 .../cryptography/algebra/arithmetics/sqr.rs   |   20 +-
 .../cryptography/algebra/arithmetics/sub.rs   |   36 +-
 .../natives/cryptography/algebra/casting.rs   |   20 +-
 .../natives/cryptography/algebra/constants.rs |   37 +-
 .../src/natives/cryptography/algebra/eq.rs    |   27 +-
 .../src/natives/cryptography/algebra/gas.rs   |   76 --
 .../cryptography/algebra/hash_to_structure.rs |   86 +-
 .../src/natives/cryptography/algebra/mod.rs   |  265 +----
 .../src/natives/cryptography/algebra/new.rs   |   21 +-
 .../natives/cryptography/algebra/pairing.rs   |   36 +-
 .../src/natives/cryptography/algebra/rand.rs  |   26 +-
 .../cryptography/algebra/serialization.rs     |   55 +-
 .../src/natives/cryptography/bls12381.rs      |  505 ++++----
 .../src/natives/cryptography/ed25519.rs       |   93 +-
 .../src/natives/cryptography/multi_ed25519.rs |  125 +-
 .../src/natives/cryptography/ristretto255.rs  |  248 +---
 .../cryptography/ristretto255_point.rs        |   94 +-
 .../cryptography/ristretto255_scalar.rs       |   52 +-
 .../src/natives/cryptography/secp256k1.rs     |   34 +-
 aptos-move/framework/src/natives/debug.rs     |   57 +-
 aptos-move/framework/src/natives/event.rs     |   59 +-
 aptos-move/framework/src/natives/hash.rs      |  132 +--
 aptos-move/framework/src/natives/helpers.rs   |  276 -----
 aptos-move/framework/src/natives/mod.rs       |  416 +------
 aptos-move/framework/src/natives/object.rs    |   40 +-
 .../framework/src/natives/state_storage.rs    |   40 +-
 .../framework/src/natives/string_utils.rs     |   69 +-
 .../src/natives/transaction_context.rs        |   82 +-
 aptos-move/framework/src/natives/type_info.rs |   91 +-
 aptos-move/framework/src/natives/util.rs      |   49 +-
 aptos-move/framework/table-natives/Cargo.toml |   28 +
 aptos-move/framework/table-natives/src/lib.rs |  568 +++++++++
 aptos-move/framework/tests/move_unit_test.rs  |    9 +-
 aptos-move/move-examples/Cargo.toml           |    1 -
 .../move-examples/tests/move_unit_tests.rs    |   11 +-
 aptos-move/vm-genesis/Cargo.toml              |    2 +-
 aptos-move/vm-genesis/src/lib.rs              |   14 +-
 .../writeset-transaction-generator/Cargo.toml |    3 +-
 .../src/writeset_builder.rs                   |    8 +-
 crates/aptos/Cargo.toml                       |    3 +-
 .../src/move_tool/aptos_debug_natives.rs      |   14 +-
 crates/aptos/src/move_tool/mod.rs             |    4 +-
 testsuite/smoke-test/Cargo.toml               |    2 +-
 testsuite/smoke-test/src/rosetta.rs           |    4 +-
 testsuite/smoke-test/src/upgrade.rs           |    9 +-
 .../move/move-core/types/src/gas_algebra.rs   |    9 +
 types/Cargo.toml                              |    1 -
 types/src/state_store/table.rs                |    6 -
 vm-validator/Cargo.toml                       |    4 +-
 .../src/unit_tests/vm_validator_test.rs       |   11 +-
 156 files changed, 4289 insertions(+), 5623 deletions(-)
 rename aptos-move/{aptos-gas => aptos-gas-meter}/Cargo.toml (84%)
 create mode 100644 aptos-move/aptos-gas-meter/src/algebra.rs
 create mode 100644 aptos-move/aptos-gas-meter/src/lib.rs
 create mode 100644 aptos-move/aptos-gas-meter/src/meter.rs
 create mode 100644 aptos-move/aptos-gas-meter/src/traits.rs
 create mode 100644 aptos-move/aptos-gas-schedule-updator/Cargo.toml
 rename aptos-move/{aptos-gas/src/gen.rs => aptos-gas-schedule-updator/src/lib.rs} (83%)
 rename aptos-move/{aptos-gas/src/bin/gen_proposal.rs => aptos-gas-schedule-updator/src/main.rs} (75%)
 rename aptos-move/{aptos-gas => aptos-gas-schedule-updator}/tests/gen_tests.rs (86%)
 delete mode 100644 aptos-move/aptos-gas-schedule/run.py
 delete mode 100644 aptos-move/aptos-gas-schedule/src/gas_params/mod.rs
 create mode 100644 aptos-move/aptos-gas-schedule/src/gas_schedule/aptos_framework.rs
 rename aptos-move/aptos-gas-schedule/src/{gas_params => gas_schedule}/instr.rs (97%)
 rename aptos-move/aptos-gas-schedule/src/{gas_params => gas_schedule}/macros.rs (72%)
 rename aptos-move/aptos-gas-schedule/src/{gas_params => gas_schedule}/misc.rs (98%)
 create mode 100644 aptos-move/aptos-gas-schedule/src/gas_schedule/mod.rs
 create mode 100644 aptos-move/aptos-gas-schedule/src/gas_schedule/move_stdlib.rs
 create mode 100644 aptos-move/aptos-gas-schedule/src/gas_schedule/table.rs
 rename aptos-move/aptos-gas-schedule/src/{gas_params => gas_schedule}/transaction.rs (96%)
 delete mode 100644 aptos-move/aptos-gas/src/aptos_framework.rs
 delete mode 100644 aptos-move/aptos-gas/src/gas_meter.rs
 delete mode 100644 aptos-move/aptos-gas/src/lib.rs
 delete mode 100644 aptos-move/aptos-gas/src/move_stdlib.rs
 delete mode 100644 aptos-move/aptos-gas/src/natives.rs
 delete mode 100644 aptos-move/aptos-gas/src/table.rs
 create mode 100644 aptos-move/aptos-native-interface/Cargo.toml
 create mode 100644 aptos-move/aptos-native-interface/src/builder.rs
 create mode 100644 aptos-move/aptos-native-interface/src/context.rs
 create mode 100644 aptos-move/aptos-native-interface/src/errors.rs
 create mode 100644 aptos-move/aptos-native-interface/src/helpers.rs
 create mode 100644 aptos-move/aptos-native-interface/src/lib.rs
 create mode 100644 aptos-move/aptos-native-interface/src/native.rs
 create mode 100644 aptos-move/aptos-native-interface/src/reexports.rs
 rename aptos-move/{aptos-gas-schedule/src/gas_params => aptos-vm-types/src}/storage.rs (87%)
 delete mode 100644 aptos-move/framework/move-stdlib/src/natives/helpers.rs
 delete mode 100644 aptos-move/framework/move-stdlib/src/natives/vector.rs
 delete mode 100644 aptos-move/framework/src/natives/cryptography/algebra/gas.rs
 create mode 100644 aptos-move/framework/table-natives/Cargo.toml
 create mode 100644 aptos-move/framework/table-natives/src/lib.rs

diff --git a/Cargo.lock b/Cargo.lock
index 81fc6f5bede6d..a674973871a55 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -206,7 +206,6 @@ dependencies = [
  "aptos-debugger",
  "aptos-faucet-core",
  "aptos-framework",
- "aptos-gas",
  "aptos-gas-profiling",
  "aptos-gas-schedule",
  "aptos-genesis",
@@ -290,13 +289,13 @@ dependencies = [
  "aptos-crypto",
  "aptos-language-e2e-tests",
  "aptos-state-view",
+ "aptos-table-natives",
  "aptos-types",
  "bcs 0.1.4",
  "better_any",
  "claims",
  "move-binary-format",
  "move-core-types",
- "move-table-extension",
  "once_cell",
  "smallvec",
 ]
@@ -313,7 +312,8 @@ dependencies = [
  "aptos-config",
  "aptos-crypto",
  "aptos-framework",
- "aptos-gas",
+ "aptos-gas-meter",
+ "aptos-gas-schedule",
  "aptos-logger",
  "aptos-mempool",
  "aptos-metrics-core",
@@ -1007,7 +1007,7 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "aptos-crypto",
- "aptos-gas",
+ "aptos-gas-meter",
  "aptos-gas-profiling",
  "aptos-gas-schedule",
  "aptos-logger",
@@ -1015,6 +1015,7 @@ dependencies = [
  "aptos-resource-viewer",
  "aptos-rest-client",
  "aptos-state-view",
+ "aptos-table-natives",
  "aptos-types",
  "aptos-validator-interface",
  "aptos-vm",
@@ -1026,7 +1027,6 @@ dependencies = [
  "move-compiler",
  "move-core-types",
  "move-resource-viewer",
- "move-table-extension",
  "move-vm-runtime",
  "move-vm-test-utils",
  "tokio",
@@ -1414,12 +1414,15 @@ dependencies = [
  "anyhow",
  "aptos-aggregator",
  "aptos-crypto",
- "aptos-gas",
  "aptos-gas-algebra",
+ "aptos-gas-meter",
+ "aptos-gas-schedule",
  "aptos-language-e2e-tests",
  "aptos-move-stdlib",
+ "aptos-native-interface",
  "aptos-sdk-builder",
  "aptos-state-view",
+ "aptos-table-natives",
  "aptos-types",
  "aptos-vm",
  "ark-bls12-381",
@@ -1436,6 +1439,7 @@ dependencies = [
  "clap 4.3.5",
  "codespan-reporting",
  "curve25519-dalek",
+ "either",
  "flate2",
  "hex",
  "include_dir 0.7.2",
@@ -1453,7 +1457,6 @@ dependencies = [
  "move-prover",
  "move-prover-boogie-backend",
  "move-stackless-bytecode",
- "move-table-extension",
  "move-unit-test",
  "move-vm-runtime",
  "move-vm-types",
@@ -1528,7 +1531,15 @@ dependencies = [
 ]
 
 [[package]]
-name = "aptos-gas"
+name = "aptos-gas-algebra"
+version = "0.0.1"
+dependencies = [
+ "either",
+ "move-core-types",
+]
+
+[[package]]
+name = "aptos-gas-meter"
 version = "0.1.0"
 dependencies = [
  "anyhow",
@@ -1547,28 +1558,19 @@ dependencies = [
  "move-binary-format",
  "move-core-types",
  "move-model",
- "move-table-extension",
  "move-vm-types",
  "paste",
  "tempfile",
 ]
 
-[[package]]
-name = "aptos-gas-algebra"
-version = "0.0.1"
-dependencies = [
- "either",
- "move-core-types",
-]
-
 [[package]]
 name = "aptos-gas-profiling"
 version = "0.1.0"
 dependencies = [
  "anyhow",
  "aptos-framework",
- "aptos-gas",
  "aptos-gas-algebra",
+ "aptos-gas-meter",
  "aptos-package-builder",
  "aptos-types",
  "inferno",
@@ -1586,13 +1588,28 @@ dependencies = [
  "aptos-gas-algebra",
  "aptos-global-constants",
  "aptos-types",
- "aptos-vm-types",
  "either",
  "move-core-types",
  "move-vm-types",
  "paste",
 ]
 
+[[package]]
+name = "aptos-gas-schedule-updator"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "aptos-framework",
+ "aptos-gas-schedule",
+ "aptos-package-builder",
+ "aptos-types",
+ "bcs 0.1.4",
+ "clap 4.3.5",
+ "move-core-types",
+ "move-model",
+ "tempfile",
+]
+
 [[package]]
 name = "aptos-genesis"
 version = "0.1.0"
@@ -2046,18 +2063,20 @@ dependencies = [
  "aptos-cached-packages",
  "aptos-crypto",
  "aptos-framework",
- "aptos-gas",
  "aptos-gas-algebra",
+ "aptos-gas-meter",
  "aptos-gas-profiling",
  "aptos-gas-schedule",
  "aptos-keygen",
  "aptos-memory-usage-tracker",
  "aptos-proptest-helpers",
  "aptos-state-view",
+ "aptos-table-natives",
  "aptos-types",
  "aptos-vm",
  "aptos-vm-genesis",
  "aptos-vm-logging",
+ "aptos-vm-types",
  "bcs 0.1.4",
  "goldenfile",
  "hex",
@@ -2065,7 +2084,6 @@ dependencies = [
  "move-command-line-common",
  "move-core-types",
  "move-ir-compiler",
- "move-table-extension",
  "move-vm-types",
  "num_cpus",
  "once_cell",
@@ -2127,8 +2145,8 @@ dependencies = [
 name = "aptos-memory-usage-tracker"
 version = "0.1.0"
 dependencies = [
- "aptos-gas",
  "aptos-gas-algebra",
+ "aptos-gas-meter",
  "aptos-types",
  "move-binary-format",
  "move-core-types",
@@ -2217,7 +2235,6 @@ dependencies = [
 name = "aptos-move-examples"
 version = "0.1.0"
 dependencies = [
- "aptos-gas",
  "aptos-gas-schedule",
  "aptos-types",
  "aptos-vm",
@@ -2235,7 +2252,10 @@ name = "aptos-move-stdlib"
 version = "0.1.1"
 dependencies = [
  "anyhow",
+ "aptos-gas-schedule",
+ "aptos-native-interface",
  "dir-diff",
+ "either",
  "file_diff",
  "hex",
  "log",
@@ -2283,6 +2303,20 @@ dependencies = [
  "rayon",
 ]
 
+[[package]]
+name = "aptos-native-interface"
+version = "0.1.0"
+dependencies = [
+ "aptos-gas-algebra",
+ "aptos-gas-schedule",
+ "aptos-types",
+ "move-binary-format",
+ "move-core-types",
+ "move-vm-runtime",
+ "move-vm-types",
+ "smallvec",
+]
+
 [[package]]
 name = "aptos-netcore"
 version = "0.1.0"
@@ -2719,7 +2753,7 @@ dependencies = [
  "aptos-build-info",
  "aptos-crypto",
  "aptos-framework",
- "aptos-gas",
+ "aptos-gas-schedule-updator",
  "aptos-genesis",
  "aptos-rest-client",
  "aptos-temppath",
@@ -3187,6 +3221,24 @@ dependencies = [
  "thiserror",
 ]
 
+[[package]]
+name = "aptos-table-natives"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "aptos-gas-schedule",
+ "aptos-native-interface",
+ "aptos-types",
+ "better_any",
+ "move-binary-format",
+ "move-core-types",
+ "move-vm-runtime",
+ "move-vm-test-utils",
+ "move-vm-types",
+ "sha3 0.9.1",
+ "smallvec",
+]
+
 [[package]]
 name = "aptos-telemetry"
 version = "0.1.0"
@@ -3330,7 +3382,7 @@ dependencies = [
  "aptos-block-partitioner",
  "aptos-crypto",
  "aptos-executor-service",
- "aptos-gas",
+ "aptos-gas-meter",
  "aptos-language-e2e-tests",
  "aptos-logger",
  "aptos-metrics-core",
@@ -3431,7 +3483,7 @@ dependencies = [
  "aptos-cached-packages",
  "aptos-crypto",
  "aptos-framework",
- "aptos-gas",
+ "aptos-gas-schedule",
  "aptos-language-e2e-tests",
  "aptos-state-view",
  "aptos-storage-interface",
@@ -3470,7 +3522,6 @@ dependencies = [
  "hex",
  "itertools",
  "move-core-types",
- "move-table-extension",
  "num-derive",
  "num-traits 0.2.15",
  "once_cell",
@@ -3540,8 +3591,8 @@ dependencies = [
  "aptos-crypto",
  "aptos-crypto-derive",
  "aptos-framework",
- "aptos-gas",
  "aptos-gas-algebra",
+ "aptos-gas-meter",
  "aptos-gas-schedule",
  "aptos-infallible",
  "aptos-language-e2e-tests",
@@ -3550,7 +3601,9 @@ dependencies = [
  "aptos-metrics-core",
  "aptos-move-stdlib",
  "aptos-mvhashmap",
+ "aptos-native-interface",
  "aptos-state-view",
+ "aptos-table-natives",
  "aptos-types",
  "aptos-utils",
  "aptos-vm-logging",
@@ -3563,7 +3616,6 @@ dependencies = [
  "move-bytecode-utils",
  "move-bytecode-verifier",
  "move-core-types",
- "move-table-extension",
  "move-unit-test",
  "move-vm-runtime",
  "move-vm-test-utils",
@@ -3604,12 +3656,12 @@ dependencies = [
  "aptos-cached-packages",
  "aptos-crypto",
  "aptos-framework",
- "aptos-gas",
  "aptos-gas-schedule",
  "aptos-proptest-helpers",
  "aptos-state-view",
  "aptos-types",
  "aptos-vm",
+ "aptos-vm-types",
  "bcs 0.1.4",
  "move-core-types",
  "move-vm-types",
@@ -3641,8 +3693,11 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "aptos-cached-packages",
+ "aptos-gas-schedule",
  "aptos-language-e2e-tests",
  "aptos-move-stdlib",
+ "aptos-native-interface",
+ "aptos-table-natives",
  "aptos-types",
  "aptos-vm",
  "aptos-vm-genesis",
@@ -3652,7 +3707,6 @@ dependencies = [
  "move-binary-format",
  "move-core-types",
  "move-ir-compiler",
- "move-table-extension",
  "move-vm-runtime",
  "move-vm-test-utils",
  "move-vm-types",
@@ -3666,10 +3720,13 @@ version = "0.0.1"
 dependencies = [
  "anyhow",
  "aptos-aggregator",
+ "aptos-gas-algebra",
+ "aptos-gas-schedule",
  "aptos-language-e2e-tests",
  "aptos-state-view",
  "aptos-types",
  "claims",
+ "either",
  "move-binary-format",
  "move-core-types",
 ]
@@ -3683,7 +3740,8 @@ dependencies = [
  "aptos-crypto",
  "aptos-db",
  "aptos-executor-test-helpers",
- "aptos-gas",
+ "aptos-gas-meter",
+ "aptos-gas-schedule",
  "aptos-scratchpad",
  "aptos-state-view",
  "aptos-storage-interface",
@@ -3720,10 +3778,11 @@ dependencies = [
  "aptos-crypto",
  "aptos-crypto-derive",
  "aptos-framework",
- "aptos-gas",
+ "aptos-gas-schedule",
  "aptos-state-view",
  "aptos-types",
  "aptos-vm",
+ "aptos-vm-types",
  "bcs 0.1.4",
  "handlebars",
  "move-command-line-common",
@@ -5772,9 +5831,9 @@ dependencies = [
  "aptos-cached-packages",
  "aptos-crypto",
  "aptos-framework",
- "aptos-gas",
  "aptos-gas-algebra",
  "aptos-gas-profiling",
+ "aptos-gas-schedule",
  "aptos-keygen",
  "aptos-language-e2e-tests",
  "aptos-logger",
@@ -7575,7 +7634,8 @@ dependencies = [
  "aptos-cached-packages",
  "aptos-crypto",
  "aptos-framework",
- "aptos-gas",
+ "aptos-gas-meter",
+ "aptos-gas-schedule",
  "aptos-keygen",
  "aptos-language-e2e-tests",
  "aptos-logger",
@@ -7585,6 +7645,7 @@ dependencies = [
  "aptos-vm",
  "aptos-vm-genesis",
  "aptos-vm-logging",
+ "aptos-vm-types",
  "aptos-writeset-generator",
  "bcs 0.1.4",
  "fail 0.5.0",
@@ -11658,8 +11719,8 @@ dependencies = [
  "aptos-faucet-core",
  "aptos-forge",
  "aptos-framework",
- "aptos-gas",
  "aptos-gas-algebra",
+ "aptos-gas-schedule",
  "aptos-genesis",
  "aptos-global-constants",
  "aptos-indexer",
diff --git a/Cargo.toml b/Cargo.toml
index 7ba6bbfe0c660..092f1f75be5c1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,11 +8,13 @@ members = [
     "api/types",
     "aptos-move/aptos-aggregator",
     "aptos-move/aptos-debugger",
-    "aptos-move/aptos-gas",
     "aptos-move/aptos-gas-algebra",
+    "aptos-move/aptos-gas-meter",
     "aptos-move/aptos-gas-profiling",
     "aptos-move/aptos-gas-schedule",
+    "aptos-move/aptos-gas-schedule-updator",
     "aptos-move/aptos-memory-usage-tracker",
+    "aptos-move/aptos-native-interface",
     "aptos-move/aptos-release-builder",
     "aptos-move/aptos-resource-viewer",
     "aptos-move/aptos-sdk-builder",
@@ -30,6 +32,7 @@ members = [
     "aptos-move/e2e-testsuite",
     "aptos-move/framework",
     "aptos-move/framework/cached-packages",
+    "aptos-move/framework/table-natives",
     "aptos-move/move-examples",
     "aptos-move/mvhashmap",
     "aptos-move/package-builder",
@@ -297,10 +300,11 @@ aptos-forge = { path = "testsuite/forge" }
 aptos-framework = { path = "aptos-move/framework" }
 aptos-fuzzer = { path = "testsuite/aptos-fuzzer" }
 fuzzer = { path = "testsuite/fuzzer" }
-aptos-gas = { path = "aptos-move/aptos-gas" }
+aptos-gas-meter = { path = "aptos-move/aptos-gas-meter" }
 aptos-gas-algebra = { path = "aptos-move/aptos-gas-algebra" }
 aptos-gas-profiling = { path = "aptos-move/aptos-gas-profiling" }
 aptos-gas-schedule = { path = "aptos-move/aptos-gas-schedule" }
+aptos-gas-schedule-updator = { path = "aptos-move/aptos-gas-schedule-updator" }
 aptos-genesis = { path = "crates/aptos-genesis" }
 aptos-github-client = { path = "crates/aptos-github-client" }
 aptos-global-constants = { path = "config/global-constants" }
@@ -330,6 +334,7 @@ aptos-metrics-core = { path = "crates/aptos-metrics-core" }
 aptos-move-examples = { path = "aptos-move/move-examples" }
 aptos-moving-average = { path = "crates/moving-average" }
 aptos-mvhashmap = { path = "aptos-move/mvhashmap" }
+aptos-native-interface = { path = "aptos-move/aptos-native-interface" }
 aptos-netcore = { path = "network/netcore" }
 aptos-network = { path = "network" }
 aptos-network-builder = { path = "network/builder" }
@@ -633,6 +638,7 @@ move-prover = { path = "third_party/move/move-prover" }
 move-prover-boogie-backend = { path = "third_party/move/move-prover/boogie-backend" }
 move-stackless-bytecode = { path = "third_party/move/move-prover/bytecode" }
 aptos-move-stdlib = { path = "aptos-move/framework/move-stdlib" }
+aptos-table-natives = { path = "aptos-move/framework/table-natives" }
 move-prover-test-utils = { path = "third_party/move/move-prover/test-utils" }
 move-resource-viewer = { path = "third_party/move/tools/move-resource-viewer" }
 move-symbol-pool = { path = "third_party/move/move-symbol-pool" }
diff --git a/api/Cargo.toml b/api/Cargo.toml
index b0ad8e9bfb8b0..7d8e03995c6c4 100644
--- a/api/Cargo.toml
+++ b/api/Cargo.toml
@@ -18,7 +18,7 @@ aptos-api-types = { workspace = true }
 aptos-build-info = { workspace = true }
 aptos-config = { workspace = true }
 aptos-crypto = { workspace = true }
-aptos-gas = { workspace = true }
+aptos-gas-schedule = { workspace = true }
 aptos-logger = { workspace = true }
 aptos-mempool = { workspace = true }
 aptos-metrics-core = { workspace = true }
@@ -52,7 +52,7 @@ url = { workspace = true }
 aptos-api-test-context = { workspace = true }
 aptos-cached-packages = { workspace = true }
 aptos-framework = { workspace = true }
-aptos-gas = { workspace = true, features = ["testing"] }
+aptos-gas-meter = { workspace = true, features = ["testing"] }
 aptos-proptest-helpers = { workspace = true }
 aptos-sdk = { workspace = true }
 move-package = { workspace = true }
diff --git a/api/src/context.rs b/api/src/context.rs
index d4347a19345b4..ad0954bb2577c 100644
--- a/api/src/context.rs
+++ b/api/src/context.rs
@@ -17,7 +17,7 @@ use aptos_api_types::{
 };
 use aptos_config::config::{NodeConfig, RoleType};
 use aptos_crypto::HashValue;
-use aptos_gas::{AptosGasParameters, FromOnChainGasSchedule};
+use aptos_gas_schedule::{AptosGasParameters, FromOnChainGasSchedule};
 use aptos_logger::error;
 use aptos_mempool::{MempoolClientRequest, MempoolClientSender, SubmissionStatus};
 use aptos_state_view::TStateView;
@@ -1092,7 +1092,7 @@ impl Context {
 
     fn min_gas_unit_price<E: InternalError>(&self, ledger_info: &LedgerInfo) -> Result<u64, E> {
         let (_, gas_schedule) = self.get_gas_schedule(ledger_info)?;
-        Ok(gas_schedule.txn.min_price_per_gas_unit.into())
+        Ok(gas_schedule.vm.txn.min_price_per_gas_unit.into())
     }
 
     pub fn get_gas_schedule<E: InternalError>(
diff --git a/api/src/transactions.rs b/api/src/transactions.rs
index ac94edbcb66f9..8d2f6bde1cd2d 100644
--- a/api/src/transactions.rs
+++ b/api/src/transactions.rs
@@ -452,9 +452,9 @@ impl TransactionsApi {
         let estimated_max_gas_amount = if estimate_max_gas_amount.0.unwrap_or_default() {
             // Retrieve max possible gas units
             let (_, gas_params) = self.context.get_gas_schedule(&ledger_info)?;
-            let min_number_of_gas_units = u64::from(gas_params.txn.min_transaction_gas_units)
-                / u64::from(gas_params.txn.gas_unit_scaling_factor);
-            let max_number_of_gas_units = u64::from(gas_params.txn.maximum_number_of_gas_units);
+            let min_number_of_gas_units = u64::from(gas_params.vm.txn.min_transaction_gas_units)
+                / u64::from(gas_params.vm.txn.gas_unit_scaling_factor);
+            let max_number_of_gas_units = u64::from(gas_params.vm.txn.maximum_number_of_gas_units);
 
             // Retrieve account balance to determine max gas available
             let account_state = self
diff --git a/aptos-move/aptos-aggregator/Cargo.toml b/aptos-move/aptos-aggregator/Cargo.toml
index 08c67c7be1b8a..3ecb185cea6f7 100644
--- a/aptos-move/aptos-aggregator/Cargo.toml
+++ b/aptos-move/aptos-aggregator/Cargo.toml
@@ -16,12 +16,12 @@ rust-version = { workspace = true }
 anyhow = { workspace = true }
 aptos-crypto = { workspace = true }
 aptos-state-view = { workspace = true }
+aptos-table-natives = { workspace = true }
 aptos-types = { workspace = true }
 bcs = { workspace = true }
 better_any = { workspace = true }
 move-binary-format = { workspace = true }
 move-core-types = { workspace = true }
-move-table-extension = { workspace = true }
 once_cell = { workspace = true }
 smallvec = { workspace = true }
 
diff --git a/aptos-move/aptos-aggregator/src/aggregator_extension.rs b/aptos-move/aptos-aggregator/src/aggregator_extension.rs
index 5f9ec715b2309..8a654085b6005 100644
--- a/aptos-move/aptos-aggregator/src/aggregator_extension.rs
+++ b/aptos-move/aptos-aggregator/src/aggregator_extension.rs
@@ -2,10 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::delta_change_set::{addition, deserialize, subtraction};
+use aptos_table_natives::{TableHandle, TableResolver};
 use aptos_types::vm_status::StatusCode;
 use move_binary_format::errors::{PartialVMError, PartialVMResult};
 use move_core_types::account_address::AccountAddress;
-use move_table_extension::{TableHandle, TableResolver};
 use std::collections::{BTreeMap, BTreeSet};
 
 /// Describes the state of each aggregator instance.
diff --git a/aptos-move/aptos-debugger/Cargo.toml b/aptos-move/aptos-debugger/Cargo.toml
index e41975f907771..6af4d089526a2 100644
--- a/aptos-move/aptos-debugger/Cargo.toml
+++ b/aptos-move/aptos-debugger/Cargo.toml
@@ -12,14 +12,15 @@ edition = "2021"
 [dependencies]
 anyhow = { workspace = true }
 aptos-crypto = { workspace = true }
-aptos-gas-schedule = { workspace = true }
-aptos-gas = { workspace = true }
+aptos-gas-meter = { workspace = true }
 aptos-gas-profiling = { workspace = true }
+aptos-gas-schedule = { workspace = true }
 aptos-logger = { workspace = true }
 aptos-memory-usage-tracker = { workspace = true }
 aptos-resource-viewer = { workspace = true }
 aptos-rest-client = { workspace = true }
 aptos-state-view = { workspace = true }
+aptos-table-natives = { workspace = true }
 aptos-types = { workspace = true }
 aptos-validator-interface = { workspace = true }
 aptos-vm = { workspace = true }
@@ -31,7 +32,6 @@ move-cli = { workspace = true }
 move-compiler = { workspace = true }
 move-core-types = { workspace = true }
 move-resource-viewer = { workspace = true }
-move-table-extension = { workspace = true }
 move-vm-runtime = { workspace = true }
 move-vm-test-utils = { workspace = true }
 tokio = { workspace = true }
diff --git a/aptos-move/aptos-debugger/src/lib.rs b/aptos-move/aptos-debugger/src/lib.rs
index f00512646a62b..462f334499356 100644
--- a/aptos-move/aptos-debugger/src/lib.rs
+++ b/aptos-move/aptos-debugger/src/lib.rs
@@ -2,12 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use anyhow::{format_err, Result};
-use aptos_gas::{
-    AbstractValueSizeGasParameters, ChangeSetConfigs, NativeGasParameters, StandardGasAlgebra,
-    StandardGasMeter,
-};
+use aptos_gas_meter::{StandardGasAlgebra, StandardGasMeter};
 use aptos_gas_profiling::{GasProfiler, TransactionGasLog};
-use aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION;
+use aptos_gas_schedule::{MiscGasParameters, NativeGasParameters, LATEST_GAS_FEATURE_VERSION};
 use aptos_memory_usage_tracker::MemoryTrackedGasMeter;
 use aptos_resource_viewer::{AnnotatedAccountStateBlob, AptosValueAnnotator};
 use aptos_rest_client::Client;
@@ -31,7 +28,7 @@ use aptos_vm::{
     AptosVM, VMExecutor,
 };
 use aptos_vm_logging::log_schema::AdapterLogSchema;
-use aptos_vm_types::{change_set::VMChangeSet, output::VMOutput};
+use aptos_vm_types::{change_set::VMChangeSet, output::VMOutput, storage::ChangeSetConfigs};
 use move_binary_format::errors::VMResult;
 use std::{path::Path, sync::Arc};
 
@@ -231,7 +228,7 @@ impl AptosDebugger {
         let features = Features::fetch_config(&state_view_storage).unwrap_or_default();
         let move_vm = MoveVmExt::new(
             NativeGasParameters::zeros(),
-            AbstractValueSizeGasParameters::zeros(),
+            MiscGasParameters::zeros(),
             LATEST_GAS_FEATURE_VERSION,
             ChainId::test().id(),
             features,
diff --git a/aptos-move/aptos-gas-algebra/src/abstract_algebra.rs b/aptos-move/aptos-gas-algebra/src/abstract_algebra.rs
index 6f95bfec2ea0f..046ff55699315 100644
--- a/aptos-move/aptos-gas-algebra/src/abstract_algebra.rs
+++ b/aptos-move/aptos-gas-algebra/src/abstract_algebra.rs
@@ -2,24 +2,42 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use either::Either;
-use move_core_types::gas_algebra::GasQuantity;
-use std::ops::{Add, Mul};
+use move_core_types::gas_algebra::{GasQuantity, UnitDiv};
+use std::{
+    marker::PhantomData,
+    ops::{Add, Mul},
+};
 
 /***************************************************************************************************
  * Gas Expression & Visitor
  *
  **************************************************************************************************/
-/// Trait representing an abstract view over an expression that is used to represent some
-/// gas amount.
+/// Trait representing an abstract expression that can be used to calculate some gas amount.
 ///
 /// It carries a type parameter `E`, indicating an environment in which the expression can be
 /// evaluated/materialized.
 pub trait GasExpression<E> {
     type Unit;
 
-    fn materialize(&self, feature_version: u64, env: &E) -> GasQuantity<Self::Unit>;
+    /// Evaluates the expression within the given environment to a concrete number.
+    fn evaluate(&self, feature_version: u64, env: &E) -> GasQuantity<Self::Unit>;
 
+    /// Traverse the expression in post-order using the given visitor.
+    /// See [`GasExpressionVisitor`] for details.
     fn visit(&self, visitor: &mut impl GasExpressionVisitor);
+
+    /// Performs a division on the unit of the expression.
+    ///
+    /// This is sometimes required if you want to multiply an amount by a certain count.
+    fn per<U>(self) -> GasPerUnit<Self, U>
+    where
+        Self: Sized,
+    {
+        GasPerUnit {
+            inner: self,
+            phantom: PhantomData,
+        }
+    }
 }
 
 /// An interface for performing post-order traversal of the tree structure of a gas expression.
@@ -46,55 +64,82 @@ pub trait GasExpressionVisitor {
     fn gas_param<P>(&mut self);
 
     fn quantity<U>(&mut self, quantity: GasQuantity<U>);
+
+    fn per<U>(&mut self);
 }
 
 /***************************************************************************************************
  * Built-in Gas Expressions
  *
  **************************************************************************************************/
+/// Representing the addition of two gas expressions.
 #[derive(Debug, Clone)]
 pub struct GasAdd<L, R> {
     pub left: L,
     pub right: R,
 }
 
+/// Representing the multiplication of two gas expressions.
 #[derive(Debug, Clone)]
 pub struct GasMul<L, R> {
     pub left: L,
     pub right: R,
 }
 
+/// Representing a gas expression divided by a particular unit.
+/// This is sometimes required for further multiplications.
+#[derive(Debug, Clone)]
+pub struct GasPerUnit<T, U> {
+    pub inner: T,
+    phantom: PhantomData<U>,
+}
+
 /***************************************************************************************************
  * Gas Expression Impl
  *
  **************************************************************************************************/
+// Notation:
+//   E | T: U means T is a valid gas expression with unit U under environment E.
+
+// E | T: U
+// ---------
+// E | &T: U
 impl<E, T> GasExpression<E> for &T
 where
     T: GasExpression<E>,
 {
     type Unit = T::Unit;
 
-    fn materialize(&self, feature_version: u64, env: &E) -> GasQuantity<Self::Unit> {
-        (*self).materialize(feature_version, env)
+    #[inline]
+    fn evaluate(&self, feature_version: u64, env: &E) -> GasQuantity<Self::Unit> {
+        (*self).evaluate(feature_version, env)
     }
 
+    #[inline]
     fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
         (*self).visit(visitor)
     }
 }
 
+// ---------------------
+// E | GasQuantity<U>: U
 impl<E, U> GasExpression<E> for GasQuantity<U> {
     type Unit = U;
 
-    fn materialize(&self, _feature_version: u64, _env: &E) -> GasQuantity<Self::Unit> {
+    #[inline]
+    fn evaluate(&self, _feature_version: u64, _env: &E) -> GasQuantity<Self::Unit> {
         *self
     }
 
+    #[inline]
     fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
         visitor.quantity(*self)
     }
 }
 
+// E | L: U,  E | R: U
+// -------------------
+//    E | L + R: U
 impl<E, L, R, U> GasExpression<E> for GasAdd<L, R>
 where
     L: GasExpression<E, Unit = U>,
@@ -103,8 +148,8 @@ where
     type Unit = U;
 
     #[inline]
-    fn materialize(&self, feature_version: u64, env: &E) -> GasQuantity<Self::Unit> {
-        self.left.materialize(feature_version, env) + self.right.materialize(feature_version, env)
+    fn evaluate(&self, feature_version: u64, env: &E) -> GasQuantity<Self::Unit> {
+        self.left.evaluate(feature_version, env) + self.right.evaluate(feature_version, env)
     }
 
     #[inline]
@@ -115,6 +160,9 @@ where
     }
 }
 
+// E | L: UL,  E | R: UR,  O = UL * UR
+// -----------------------------------
+//           E | L * R: O
 impl<E, L, R, UL, UR, O> GasExpression<E> for GasMul<L, R>
 where
     L: GasExpression<E, Unit = UL>,
@@ -124,8 +172,8 @@ where
     type Unit = O;
 
     #[inline]
-    fn materialize(&self, feature_version: u64, env: &E) -> GasQuantity<Self::Unit> {
-        self.left.materialize(feature_version, env) * self.right.materialize(feature_version, env)
+    fn evaluate(&self, feature_version: u64, env: &E) -> GasQuantity<Self::Unit> {
+        self.left.evaluate(feature_version, env) * self.right.evaluate(feature_version, env)
     }
 
     #[inline]
@@ -136,6 +184,9 @@ where
     }
 }
 
+// E | L: U,  E | R: U
+// -------------------
+// E | Either<L, R>: U
 impl<E, L, R, U> GasExpression<E> for Either<L, R>
 where
     L: GasExpression<E, Unit = U>,
@@ -144,10 +195,10 @@ where
     type Unit = U;
 
     #[inline]
-    fn materialize(&self, feature_version: u64, env: &E) -> GasQuantity<Self::Unit> {
+    fn evaluate(&self, feature_version: u64, env: &E) -> GasQuantity<Self::Unit> {
         match self {
-            Either::Left(left) => left.materialize(feature_version, env),
-            Either::Right(right) => right.materialize(feature_version, env),
+            Either::Left(left) => left.evaluate(feature_version, env),
+            Either::Right(right) => right.evaluate(feature_version, env),
         }
     }
 
@@ -160,52 +211,63 @@ where
     }
 }
 
-/***************************************************************************************************
- * Arithmetic Operations
- *
- **************************************************************************************************/
-impl<L, R, T> Add<T> for GasAdd<L, R> {
-    type Output = GasAdd<Self, T>;
+//       E | T: U1
+// ----------------------
+// E | T.per<U2>(): U1/U2
+impl<E, T, U1, U2> GasExpression<E> for GasPerUnit<T, U2>
+where
+    T: GasExpression<E, Unit = U1>,
+{
+    type Unit = UnitDiv<U1, U2>;
 
-    fn add(self, rhs: T) -> Self::Output {
-        GasAdd {
-            left: self,
-            right: rhs,
-        }
+    #[inline]
+    fn evaluate(&self, feature_version: u64, env: &E) -> GasQuantity<Self::Unit> {
+        self.inner.evaluate(feature_version, env).per()
     }
-}
-
-impl<L, R, T> Mul<T> for GasAdd<L, R> {
-    type Output = GasMul<Self, T>;
 
-    fn mul(self, rhs: T) -> Self::Output {
-        GasMul {
-            left: self,
-            right: rhs,
-        }
+    #[inline]
+    fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
+        self.inner.visit(visitor);
+        visitor.per::<U2>();
     }
 }
 
-impl<L, R, T> Add<T> for GasMul<L, R> {
-    type Output = GasAdd<Self, T>;
-
-    fn add(self, rhs: T) -> Self::Output {
-        GasAdd {
-            left: self,
-            right: rhs,
+/***************************************************************************************************
+ * Arithmetic Operations
+ *
+ **************************************************************************************************/
+macro_rules! impl_add_and_mul {
+    (<$($tp: ident),*>, $left_ty: ty, $right_ty: ty) => {
+        impl<$($tp),*> Add<$right_ty> for $left_ty {
+            type Output = GasAdd<Self, $right_ty>;
+
+            #[inline]
+            fn add(self, rhs: $right_ty) -> Self::Output {
+                GasAdd {
+                    left: self,
+                    right: rhs,
+                }
+            }
         }
-    }
-}
 
-impl<L, R, T> Mul<T> for GasMul<L, R> {
-    type Output = GasMul<Self, T>;
+        impl<$($tp),*> Mul<$right_ty> for $left_ty {
+            type Output = GasMul<Self, $right_ty>;
 
-    fn mul(self, rhs: T) -> Self::Output {
-        GasMul {
-            left: self,
-            right: rhs,
+            #[inline]
+            fn mul(self, rhs: $right_ty) -> Self::Output {
+                GasMul {
+                    left: self,
+                    right: rhs,
+                }
+            }
         }
-    }
+    };
 }
 
-// TODO: Add/Mul GasQuantity T
+impl_add_and_mul!(<L, R, T>, GasAdd<L, R>, T);
+impl_add_and_mul!(<L, R, T>, GasMul<L, R>, T);
+impl_add_and_mul!(<T, U, X>, GasPerUnit<T, U>, X);
+
+impl_add_and_mul!(<U, L, R>, GasQuantity<U>, GasAdd<L, R>);
+impl_add_and_mul!(<U, L, R>, GasQuantity<U>, GasMul<L, R>);
+impl_add_and_mul!(<X, T, U>, GasQuantity<X>, GasPerUnit<T, U>);
diff --git a/aptos-move/aptos-gas-algebra/src/algebra.rs b/aptos-move/aptos-gas-algebra/src/algebra.rs
index e9c1d570ee822..d69eba7ac968b 100644
--- a/aptos-move/aptos-gas-algebra/src/algebra.rs
+++ b/aptos-move/aptos-gas-algebra/src/algebra.rs
@@ -19,10 +19,10 @@ pub type AbstractValueSizePerArg = GasQuantity<UnitDiv<AbstractValueUnit, Arg>>;
 /// Unit of (external) gas.
 pub enum GasUnit {}
 
-/// Unit of Aptos's native coin.
+/// Unit of the Aptos network's native coin.
 pub enum APT {}
 
-/// Unit of gas currency. 1 Octa = 10^-8 Aptos coins.
+/// Alternative unit of the Aptos network's native coin. 1 Octa = 10^-8 Aptos coins.
 pub enum Octa {}
 
 pub type Gas = GasQuantity<GasUnit>;
diff --git a/aptos-move/aptos-gas-algebra/src/lib.rs b/aptos-move/aptos-gas-algebra/src/lib.rs
index f11215af71768..7a3d5ac7aa528 100644
--- a/aptos-move/aptos-gas-algebra/src/lib.rs
+++ b/aptos-move/aptos-gas-algebra/src/lib.rs
@@ -1,6 +1,14 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
+//! This crate extends Move's gas algebra by introducing Aptos-specific counting units.
+//!
+//! It provides an abstract algebra that goes beyond concrete quantities and allows
+//! the representation of gas expressions.
+//!
+//! These expressions can be evaluated or interpreted symbolically, opening up possibilities
+//! for building advanced analysis tools.
+
 mod abstract_algebra;
 mod algebra;
 
diff --git a/aptos-move/aptos-gas/Cargo.toml b/aptos-move/aptos-gas-meter/Cargo.toml
similarity index 84%
rename from aptos-move/aptos-gas/Cargo.toml
rename to aptos-move/aptos-gas-meter/Cargo.toml
index 36ac56dbadb0a..ae96ebb32af26 100644
--- a/aptos-move/aptos-gas/Cargo.toml
+++ b/aptos-move/aptos-gas-meter/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
-name = "aptos-gas"
-description = "Gas metering for the Aptos blockchain"
+name = "aptos-gas-meter"
+description = "Gas meter implementation for the Aptos blockchain"
 version = "0.1.0"
 
 # Workspace inherited keys
@@ -29,7 +29,6 @@ either = { workspace = true }
 move-binary-format = { workspace = true }
 move-core-types = { workspace = true }
 move-model = { workspace = true }
-move-table-extension = { workspace = true }
 move-vm-types = { workspace = true }
 paste = { workspace = true }
 
@@ -38,7 +37,3 @@ tempfile = { workspace = true }
 
 [features]
 testing = ["aptos-move-stdlib/testing", "aptos-global-constants/testing"]
-
-[[bin]]
-name = "aptos-gas-gen-update-proposal"
-path = "src/bin/gen_proposal.rs"
diff --git a/aptos-move/aptos-gas-meter/src/algebra.rs b/aptos-move/aptos-gas-meter/src/algebra.rs
new file mode 100644
index 0000000000000..66c36631ccfee
--- /dev/null
+++ b/aptos-move/aptos-gas-meter/src/algebra.rs
@@ -0,0 +1,187 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::traits::GasAlgebra;
+use aptos_gas_algebra::{Fee, FeePerGasUnit, Gas, GasExpression, Octa};
+use aptos_gas_schedule::VMGasParameters;
+use aptos_logger::error;
+use aptos_vm_types::storage::StorageGasParameters;
+use move_binary_format::errors::{PartialVMError, PartialVMResult};
+use move_core_types::{
+    gas_algebra::{InternalGas, InternalGasUnit},
+    vm_status::StatusCode,
+};
+use std::fmt::Debug;
+
+/// Base gas algebra implementation that tracks the gas usage using its internal counters.
+///
+/// Abstract gas amounts are always evaluated to concrete values at the spot.
+pub struct StandardGasAlgebra {
+    feature_version: u64,
+    vm_gas_params: VMGasParameters,
+    storage_gas_params: StorageGasParameters,
+
+    balance: InternalGas,
+
+    execution_gas_used: InternalGas,
+    io_gas_used: InternalGas,
+    // The gas consumed by the storage operations.
+    storage_fee_in_internal_units: InternalGas,
+    // The storage fee consumed by the storage operations.
+    storage_fee_used: Fee,
+}
+
+impl StandardGasAlgebra {
+    pub fn new(
+        gas_feature_version: u64,
+        vm_gas_params: VMGasParameters,
+        storage_gas_params: StorageGasParameters,
+        balance: impl Into<Gas>,
+    ) -> Self {
+        let balance = balance.into().to_unit_with_params(&vm_gas_params.txn);
+
+        Self {
+            feature_version: gas_feature_version,
+            vm_gas_params,
+            storage_gas_params,
+            balance,
+            execution_gas_used: 0.into(),
+            io_gas_used: 0.into(),
+            storage_fee_in_internal_units: 0.into(),
+            storage_fee_used: 0.into(),
+        }
+    }
+}
+
+impl StandardGasAlgebra {
+    fn charge(&mut self, amount: InternalGas) -> PartialVMResult<()> {
+        match self.balance.checked_sub(amount) {
+            Some(new_balance) => {
+                self.balance = new_balance;
+                Ok(())
+            },
+            None => {
+                self.balance = 0.into();
+                Err(PartialVMError::new(StatusCode::OUT_OF_GAS))
+            },
+        }
+    }
+}
+
+impl GasAlgebra for StandardGasAlgebra {
+    fn feature_version(&self) -> u64 {
+        self.feature_version
+    }
+
+    fn vm_gas_params(&self) -> &VMGasParameters {
+        &self.vm_gas_params
+    }
+
+    fn storage_gas_params(&self) -> &StorageGasParameters {
+        &self.storage_gas_params
+    }
+
+    fn balance_internal(&self) -> InternalGas {
+        self.balance
+    }
+
+    fn charge_execution(
+        &mut self,
+        abstract_amount: impl GasExpression<VMGasParameters, Unit = InternalGasUnit> + Debug,
+    ) -> PartialVMResult<()> {
+        let amount = abstract_amount.evaluate(self.feature_version, &self.vm_gas_params);
+
+        self.charge(amount)?;
+
+        self.execution_gas_used += amount;
+        if self.feature_version >= 7
+            && self.execution_gas_used > self.vm_gas_params.txn.max_execution_gas
+        {
+            Err(PartialVMError::new(StatusCode::EXECUTION_LIMIT_REACHED))
+        } else {
+            Ok(())
+        }
+    }
+
+    fn charge_io(
+        &mut self,
+        abstract_amount: impl GasExpression<VMGasParameters, Unit = InternalGasUnit>,
+    ) -> PartialVMResult<()> {
+        let amount = abstract_amount.evaluate(self.feature_version, &self.vm_gas_params);
+
+        self.charge(amount)?;
+
+        self.io_gas_used += amount;
+        if self.feature_version >= 7 && self.io_gas_used > self.vm_gas_params.txn.max_io_gas {
+            Err(PartialVMError::new(StatusCode::IO_LIMIT_REACHED))
+        } else {
+            Ok(())
+        }
+    }
+
+    fn charge_storage_fee(
+        &mut self,
+        abstract_amount: impl GasExpression<VMGasParameters, Unit = Octa>,
+        gas_unit_price: FeePerGasUnit,
+    ) -> PartialVMResult<()> {
+        let amount = abstract_amount.evaluate(self.feature_version, &self.vm_gas_params);
+
+        let txn_params = &self.vm_gas_params.txn;
+
+        // Because the storage fees are defined in terms of fixed APT costs, we need
+        // to convert them into gas units.
+        //
+        // u128 is used to protect against overflow and preserve as much precision as
+        // possible in the extreme cases.
+        fn div_ceil(n: u128, d: u128) -> u128 {
+            if n % d == 0 {
+                n / d
+            } else {
+                n / d + 1
+            }
+        }
+        let gas_consumed_internal = div_ceil(
+            (u64::from(amount) as u128) * (u64::from(txn_params.gas_unit_scaling_factor) as u128),
+            u64::from(gas_unit_price) as u128,
+        );
+        let gas_consumed_internal = InternalGas::new(
+            if gas_consumed_internal > u64::MAX as u128 {
+                error!(
+                    "Something's wrong in the gas schedule: gas_consumed_internal ({}) > u64::MAX",
+                    gas_consumed_internal
+                );
+                u64::MAX
+            } else {
+                gas_consumed_internal as u64
+            },
+        );
+
+        self.charge(gas_consumed_internal)?;
+
+        self.storage_fee_in_internal_units += gas_consumed_internal;
+        self.storage_fee_used += amount;
+        if self.feature_version >= 7
+            && self.storage_fee_used > self.vm_gas_params.txn.max_storage_fee
+        {
+            return Err(PartialVMError::new(StatusCode::STORAGE_LIMIT_REACHED));
+        }
+
+        Ok(())
+    }
+
+    fn execution_gas_used(&self) -> InternalGas {
+        self.execution_gas_used
+    }
+
+    fn io_gas_used(&self) -> InternalGas {
+        self.io_gas_used
+    }
+
+    fn storage_fee_used_in_gas_units(&self) -> InternalGas {
+        self.storage_fee_in_internal_units
+    }
+
+    fn storage_fee_used(&self) -> Fee {
+        self.storage_fee_used
+    }
+}
diff --git a/aptos-move/aptos-gas-meter/src/lib.rs b/aptos-move/aptos-gas-meter/src/lib.rs
new file mode 100644
index 0000000000000..3c8b890a56eaa
--- /dev/null
+++ b/aptos-move/aptos-gas-meter/src/lib.rs
@@ -0,0 +1,13 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+//! This crate serves as the implementation of the standard gas meter and algebra used in the Aptos VM.
+//! It also defines traits that enable composability of gas meters and algebra.
+
+mod algebra;
+mod meter;
+mod traits;
+
+pub use algebra::StandardGasAlgebra;
+pub use meter::StandardGasMeter;
+pub use traits::{AptosGasMeter, GasAlgebra};
diff --git a/aptos-move/aptos-gas-meter/src/meter.rs b/aptos-move/aptos-gas-meter/src/meter.rs
new file mode 100644
index 0000000000000..b72d2b1640651
--- /dev/null
+++ b/aptos-move/aptos-gas-meter/src/meter.rs
@@ -0,0 +1,527 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::traits::{AptosGasMeter, GasAlgebra};
+use aptos_gas_algebra::{Fee, FeePerGasUnit};
+use aptos_gas_schedule::gas_params::{instr::*, txn::*};
+use aptos_types::{
+    contract_event::ContractEvent, state_store::state_key::StateKey, write_set::WriteOp,
+};
+use move_binary_format::{
+    errors::{Location, PartialVMError, PartialVMResult, VMResult},
+    file_format::CodeOffset,
+};
+use move_core_types::{
+    account_address::AccountAddress,
+    gas_algebra::{InternalGas, NumArgs, NumBytes},
+    language_storage::ModuleId,
+    vm_status::StatusCode,
+};
+use move_vm_types::{
+    gas::{GasMeter as MoveGasMeter, SimpleInstruction},
+    views::{TypeView, ValueView},
+};
+
+/// The official gas meter used inside the Aptos VM.
+/// It maintains an internal gas counter, measured in internal gas units, and carries an environment
+/// consisting all the gas parameters, which it can lookup when performing gas calculations.
+pub struct StandardGasMeter<A> {
+    algebra: A,
+}
+
+impl<A> StandardGasMeter<A>
+where
+    A: GasAlgebra,
+{
+    pub fn new(algebra: A) -> Self {
+        Self { algebra }
+    }
+
+    pub fn feature_version(&self) -> u64 {
+        self.algebra.feature_version()
+    }
+}
+
+impl<A> MoveGasMeter for StandardGasMeter<A>
+where
+    A: GasAlgebra,
+{
+    #[inline]
+    fn balance_internal(&self) -> InternalGas {
+        self.algebra.balance_internal()
+    }
+
+    #[inline]
+    fn charge_br_false(&mut self, _target_offset: Option<CodeOffset>) -> PartialVMResult<()> {
+        self.algebra.charge_execution(BR_FALSE)
+    }
+
+    #[inline]
+    fn charge_br_true(&mut self, _target_offset: Option<CodeOffset>) -> PartialVMResult<()> {
+        self.algebra.charge_execution(BR_TRUE)
+    }
+
+    #[inline]
+    fn charge_branch(&mut self, _target_offset: CodeOffset) -> PartialVMResult<()> {
+        self.algebra.charge_execution(BRANCH)
+    }
+
+    #[inline]
+    fn charge_simple_instr(&mut self, instr: SimpleInstruction) -> PartialVMResult<()> {
+        macro_rules! dispatch {
+            ($($name: ident => $cost: expr),* $(,)?) => {
+                match instr {
+                    $(SimpleInstruction::$name => self.algebra.charge_execution($cost)),*
+                }
+            };
+        }
+
+        dispatch! {
+            Nop => NOP,
+
+            Abort => ABORT,
+            Ret => RET,
+
+            LdU8 => LD_U8,
+            LdU16 => LD_U16,
+            LdU32 => LD_U32,
+            LdU64 => LD_U64,
+            LdU128 => LD_U128,
+            LdU256 => LD_U256,
+            LdTrue => LD_TRUE,
+            LdFalse => LD_FALSE,
+
+            ImmBorrowLoc => IMM_BORROW_LOC,
+            MutBorrowLoc => MUT_BORROW_LOC,
+            ImmBorrowField => IMM_BORROW_FIELD,
+            MutBorrowField => MUT_BORROW_FIELD,
+            ImmBorrowFieldGeneric => IMM_BORROW_FIELD_GENERIC,
+            MutBorrowFieldGeneric => MUT_BORROW_FIELD_GENERIC,
+            FreezeRef => FREEZE_REF,
+
+            CastU8 => CAST_U8,
+            CastU16 => CAST_U16,
+            CastU32 => CAST_U32,
+            CastU64 => CAST_U64,
+            CastU128 => CAST_U128,
+            CastU256 => CAST_U256,
+
+            Add => ADD,
+            Sub => SUB,
+            Mul => MUL,
+            Mod => MOD_,
+            Div => DIV,
+
+            BitOr => BIT_OR,
+            BitAnd => BIT_AND,
+            Xor => XOR,
+            Shl => SHL,
+            Shr => SHR,
+
+            Or => OR,
+            And => AND,
+            Not => NOT,
+
+            Lt => LT,
+            Gt => GT,
+            Le => LE,
+            Ge => GE,
+        }
+    }
+
+    #[inline]
+    fn charge_native_function_before_execution(
+        &mut self,
+        _ty_args: impl ExactSizeIterator<Item = impl TypeView>,
+        _args: impl ExactSizeIterator<Item = impl ValueView>,
+    ) -> PartialVMResult<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn charge_native_function(
+        &mut self,
+        amount: InternalGas,
+        _ret_vals: Option<impl ExactSizeIterator<Item = impl ValueView>>,
+    ) -> PartialVMResult<()> {
+        // TODO(Gas): Is this correct???
+        self.algebra.charge_execution(amount)
+    }
+
+    #[inline]
+    fn charge_load_resource(
+        &mut self,
+        _addr: AccountAddress,
+        _ty: impl TypeView,
+        val: Option<impl ValueView>,
+        bytes_loaded: NumBytes,
+    ) -> PartialVMResult<()> {
+        // TODO(Gas): check if this is correct.
+        if self.feature_version() <= 8 && val.is_none() && bytes_loaded != 0.into() {
+            return Err(PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR).with_message("in legacy versions, number of bytes loaded must be zero when the resource does not exist ".to_string()));
+        }
+        let cost = self
+            .storage_gas_params()
+            .pricing
+            .calculate_read_gas(val.is_some(), bytes_loaded);
+        self.algebra.charge_io(cost)
+    }
+
+    #[inline]
+    fn charge_pop(&mut self, _popped_val: impl ValueView) -> PartialVMResult<()> {
+        self.algebra.charge_execution(POP)
+    }
+
+    #[inline]
+    fn charge_call(
+        &mut self,
+        _module_id: &ModuleId,
+        _func_name: &str,
+        args: impl ExactSizeIterator<Item = impl ValueView>,
+        num_locals: NumArgs,
+    ) -> PartialVMResult<()> {
+        let cost = CALL_BASE + CALL_PER_ARG * NumArgs::new(args.len() as u64);
+
+        match self.feature_version() {
+            0..=2 => self.algebra.charge_execution(cost),
+            3.. => self
+                .algebra
+                .charge_execution(cost + CALL_PER_LOCAL * num_locals),
+        }
+    }
+
+    #[inline]
+    fn charge_call_generic(
+        &mut self,
+        _module_id: &ModuleId,
+        _func_name: &str,
+        ty_args: impl ExactSizeIterator<Item = impl TypeView>,
+        args: impl ExactSizeIterator<Item = impl ValueView>,
+        num_locals: NumArgs,
+    ) -> PartialVMResult<()> {
+        let cost = CALL_GENERIC_BASE
+            + CALL_GENERIC_PER_TY_ARG * NumArgs::new(ty_args.len() as u64)
+            + CALL_GENERIC_PER_ARG * NumArgs::new(args.len() as u64);
+
+        match self.feature_version() {
+            0..=2 => self.algebra.charge_execution(cost),
+            3.. => self
+                .algebra
+                .charge_execution(cost + CALL_GENERIC_PER_LOCAL * num_locals),
+        }
+    }
+
+    #[inline]
+    fn charge_ld_const(&mut self, size: NumBytes) -> PartialVMResult<()> {
+        self.algebra
+            .charge_execution(LD_CONST_BASE + LD_CONST_PER_BYTE * size)
+    }
+
+    #[inline]
+    fn charge_ld_const_after_deserialization(
+        &mut self,
+        _val: impl ValueView,
+    ) -> PartialVMResult<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn charge_copy_loc(&mut self, val: impl ValueView) -> PartialVMResult<()> {
+        let (stack_size, heap_size) = self
+            .vm_gas_params()
+            .misc
+            .abs_val
+            .abstract_value_size_stack_and_heap(val, self.feature_version());
+
+        // Note(Gas): this makes a deep copy so we need to charge for the full value size
+        self.algebra
+            .charge_execution(COPY_LOC_BASE + COPY_LOC_PER_ABS_VAL_UNIT * (stack_size + heap_size))
+    }
+
+    #[inline]
+    fn charge_move_loc(&mut self, _val: impl ValueView) -> PartialVMResult<()> {
+        self.algebra.charge_execution(MOVE_LOC_BASE)
+    }
+
+    #[inline]
+    fn charge_store_loc(&mut self, _val: impl ValueView) -> PartialVMResult<()> {
+        self.algebra.charge_execution(ST_LOC_BASE)
+    }
+
+    #[inline]
+    fn charge_pack(
+        &mut self,
+        is_generic: bool,
+        args: impl ExactSizeIterator<Item = impl ValueView>,
+    ) -> PartialVMResult<()> {
+        let num_args = NumArgs::new(args.len() as u64);
+
+        match is_generic {
+            false => self
+                .algebra
+                .charge_execution(PACK_BASE + PACK_PER_FIELD * num_args),
+            true => self
+                .algebra
+                .charge_execution(PACK_GENERIC_BASE + PACK_GENERIC_PER_FIELD * num_args),
+        }
+    }
+
+    #[inline]
+    fn charge_unpack(
+        &mut self,
+        is_generic: bool,
+        args: impl ExactSizeIterator<Item = impl ValueView>,
+    ) -> PartialVMResult<()> {
+        let num_args = NumArgs::new(args.len() as u64);
+
+        match is_generic {
+            false => self
+                .algebra
+                .charge_execution(UNPACK_BASE + UNPACK_PER_FIELD * num_args),
+            true => self
+                .algebra
+                .charge_execution(UNPACK_GENERIC_BASE + UNPACK_GENERIC_PER_FIELD * num_args),
+        }
+    }
+
+    #[inline]
+    fn charge_read_ref(&mut self, val: impl ValueView) -> PartialVMResult<()> {
+        let (stack_size, heap_size) = self
+            .vm_gas_params()
+            .misc
+            .abs_val
+            .abstract_value_size_stack_and_heap(val, self.feature_version());
+
+        // Note(Gas): this makes a deep copy so we need to charge for the full value size
+        self.algebra
+            .charge_execution(READ_REF_BASE + READ_REF_PER_ABS_VAL_UNIT * (stack_size + heap_size))
+    }
+
+    #[inline]
+    fn charge_write_ref(
+        &mut self,
+        _new_val: impl ValueView,
+        _old_val: impl ValueView,
+    ) -> PartialVMResult<()> {
+        self.algebra.charge_execution(WRITE_REF_BASE)
+    }
+
+    #[inline]
+    fn charge_eq(&mut self, lhs: impl ValueView, rhs: impl ValueView) -> PartialVMResult<()> {
+        let abs_val_params = &self.vm_gas_params().misc.abs_val;
+
+        let cost = EQ_BASE
+            + EQ_PER_ABS_VAL_UNIT
+                * (abs_val_params.abstract_value_size_dereferenced(lhs, self.feature_version())
+                    + abs_val_params.abstract_value_size_dereferenced(rhs, self.feature_version()));
+
+        self.algebra.charge_execution(cost)
+    }
+
+    #[inline]
+    fn charge_neq(&mut self, lhs: impl ValueView, rhs: impl ValueView) -> PartialVMResult<()> {
+        let abs_val_params = &self.vm_gas_params().misc.abs_val;
+
+        let cost = NEQ_BASE
+            + NEQ_PER_ABS_VAL_UNIT
+                * (abs_val_params.abstract_value_size_dereferenced(lhs, self.feature_version())
+                    + abs_val_params.abstract_value_size_dereferenced(rhs, self.feature_version()));
+
+        self.algebra.charge_execution(cost)
+    }
+
+    #[inline]
+    fn charge_borrow_global(
+        &mut self,
+        is_mut: bool,
+        is_generic: bool,
+        _ty: impl TypeView,
+        _is_success: bool,
+    ) -> PartialVMResult<()> {
+        match (is_mut, is_generic) {
+            (false, false) => self.algebra.charge_execution(IMM_BORROW_GLOBAL_BASE),
+            (false, true) => self
+                .algebra
+                .charge_execution(IMM_BORROW_GLOBAL_GENERIC_BASE),
+            (true, false) => self.algebra.charge_execution(MUT_BORROW_GLOBAL_BASE),
+            (true, true) => self
+                .algebra
+                .charge_execution(MUT_BORROW_GLOBAL_GENERIC_BASE),
+        }
+    }
+
+    #[inline]
+    fn charge_exists(
+        &mut self,
+        is_generic: bool,
+        _ty: impl TypeView,
+        _exists: bool,
+    ) -> PartialVMResult<()> {
+        match is_generic {
+            false => self.algebra.charge_execution(EXISTS_BASE),
+            true => self.algebra.charge_execution(EXISTS_GENERIC_BASE),
+        }
+    }
+
+    #[inline]
+    fn charge_move_from(
+        &mut self,
+        is_generic: bool,
+        _ty: impl TypeView,
+        _val: Option<impl ValueView>,
+    ) -> PartialVMResult<()> {
+        match is_generic {
+            false => self.algebra.charge_execution(MOVE_FROM_BASE),
+            true => self.algebra.charge_execution(MOVE_FROM_GENERIC_BASE),
+        }
+    }
+
+    #[inline]
+    fn charge_move_to(
+        &mut self,
+        is_generic: bool,
+        _ty: impl TypeView,
+        _val: impl ValueView,
+        _is_success: bool,
+    ) -> PartialVMResult<()> {
+        match is_generic {
+            false => self.algebra.charge_execution(MOVE_TO_BASE),
+            true => self.algebra.charge_execution(MOVE_TO_GENERIC_BASE),
+        }
+    }
+
+    #[inline]
+    fn charge_vec_pack<'a>(
+        &mut self,
+        _ty: impl TypeView + 'a,
+        args: impl ExactSizeIterator<Item = impl ValueView>,
+    ) -> PartialVMResult<()> {
+        let num_args = NumArgs::new(args.len() as u64);
+
+        self.algebra
+            .charge_execution(VEC_PACK_BASE + VEC_PACK_PER_ELEM * num_args)
+    }
+
+    #[inline]
+    fn charge_vec_unpack(
+        &mut self,
+        _ty: impl TypeView,
+        expect_num_elements: NumArgs,
+        _elems: impl ExactSizeIterator<Item = impl ValueView>,
+    ) -> PartialVMResult<()> {
+        self.algebra
+            .charge_execution(VEC_UNPACK_BASE + VEC_UNPACK_PER_EXPECTED_ELEM * expect_num_elements)
+    }
+
+    #[inline]
+    fn charge_vec_len(&mut self, _ty: impl TypeView) -> PartialVMResult<()> {
+        self.algebra.charge_execution(VEC_LEN_BASE)
+    }
+
+    #[inline]
+    fn charge_vec_borrow(
+        &mut self,
+        is_mut: bool,
+        _ty: impl TypeView,
+        _is_success: bool,
+    ) -> PartialVMResult<()> {
+        match is_mut {
+            false => self.algebra.charge_execution(VEC_IMM_BORROW_BASE),
+            true => self.algebra.charge_execution(VEC_MUT_BORROW_BASE),
+        }
+    }
+
+    #[inline]
+    fn charge_vec_push_back(
+        &mut self,
+        _ty: impl TypeView,
+        _val: impl ValueView,
+    ) -> PartialVMResult<()> {
+        self.algebra.charge_execution(VEC_PUSH_BACK_BASE)
+    }
+
+    #[inline]
+    fn charge_vec_pop_back(
+        &mut self,
+        _ty: impl TypeView,
+        _val: Option<impl ValueView>,
+    ) -> PartialVMResult<()> {
+        self.algebra.charge_execution(VEC_POP_BACK_BASE)
+    }
+
+    #[inline]
+    fn charge_vec_swap(&mut self, _ty: impl TypeView) -> PartialVMResult<()> {
+        self.algebra.charge_execution(VEC_SWAP_BASE)
+    }
+
+    #[inline]
+    fn charge_drop_frame(
+        &mut self,
+        _locals: impl Iterator<Item = impl ValueView>,
+    ) -> PartialVMResult<()> {
+        Ok(())
+    }
+}
+
+impl<A> AptosGasMeter for StandardGasMeter<A>
+where
+    A: GasAlgebra,
+{
+    type Algebra = A;
+
+    #[inline]
+    fn algebra(&self) -> &Self::Algebra {
+        &self.algebra
+    }
+
+    #[inline]
+    fn algebra_mut(&mut self) -> &mut Self::Algebra {
+        &mut self.algebra
+    }
+
+    #[inline]
+    fn charge_storage_fee(
+        &mut self,
+        amount: Fee,
+        gas_unit_price: FeePerGasUnit,
+    ) -> PartialVMResult<()> {
+        self.algebra.charge_storage_fee(amount, gas_unit_price)
+    }
+
+    fn charge_io_gas_for_write(&mut self, key: &StateKey, op: &WriteOp) -> VMResult<()> {
+        let cost = self.storage_gas_params().pricing.io_gas_per_write(key, op);
+        self.algebra
+            .charge_io(cost)
+            .map_err(|e| e.finish(Location::Undefined))
+    }
+
+    fn storage_fee_per_write(&self, key: &StateKey, op: &WriteOp) -> Fee {
+        self.vm_gas_params().txn.storage_fee_per_write(key, op)
+    }
+
+    fn storage_fee_per_event(&self, event: &ContractEvent) -> Fee {
+        self.vm_gas_params().txn.storage_fee_per_event(event)
+    }
+
+    fn storage_discount_for_events(&self, total_cost: Fee) -> Fee {
+        self.vm_gas_params()
+            .txn
+            .storage_discount_for_events(total_cost)
+    }
+
+    fn storage_fee_for_transaction_storage(&self, txn_size: NumBytes) -> Fee {
+        self.vm_gas_params()
+            .txn
+            .storage_fee_for_transaction_storage(txn_size)
+    }
+
+    fn charge_intrinsic_gas_for_transaction(&mut self, txn_size: NumBytes) -> VMResult<()> {
+        let excess = txn_size
+            .checked_sub(self.vm_gas_params().txn.large_transaction_cutoff)
+            .unwrap_or_else(|| 0.into());
+
+        self.algebra
+            .charge_execution(MIN_TRANSACTION_GAS_UNITS + INTRINSIC_GAS_PER_BYTE * excess)
+            .map_err(|e| e.finish(Location::Undefined))
+    }
+}
diff --git a/aptos-move/aptos-gas-meter/src/traits.rs b/aptos-move/aptos-gas-meter/src/traits.rs
new file mode 100644
index 0000000000000..78f5a76769425
--- /dev/null
+++ b/aptos-move/aptos-gas-meter/src/traits.rs
@@ -0,0 +1,221 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+use aptos_gas_algebra::{Fee, FeePerGasUnit, Gas, GasExpression, GasScalingFactor, Octa};
+use aptos_gas_schedule::VMGasParameters;
+use aptos_types::{
+    contract_event::ContractEvent, state_store::state_key::StateKey, write_set::WriteOp,
+};
+use aptos_vm_types::storage::StorageGasParameters;
+use move_binary_format::errors::{Location, PartialVMResult, VMResult};
+use move_core_types::gas_algebra::{InternalGas, InternalGasUnit, NumBytes};
+use move_vm_types::gas::GasMeter as MoveGasMeter;
+use std::fmt::Debug;
+
+/// An abstraction of the part of the gas meter that manages the core algebra,
+/// defining how the gas charges should be handled.
+pub trait GasAlgebra {
+    /// Returns the gas feature version.
+    fn feature_version(&self) -> u64;
+
+    /// Returns the struct containing all (regular) gas parameters.
+    fn vm_gas_params(&self) -> &VMGasParameters;
+
+    /// Returns the struct containing the storage-specific gas parameters.
+    fn storage_gas_params(&self) -> &StorageGasParameters;
+
+    /// Returns the current balance, measured in internal gas units.
+    fn balance_internal(&self) -> InternalGas;
+
+    /// Charges gas under the execution category.
+    ///
+    /// The amount charged can be a quantity or an abstract expression containing
+    /// gas parameters.
+    fn charge_execution(
+        &mut self,
+        abstract_amount: impl GasExpression<VMGasParameters, Unit = InternalGasUnit> + Debug,
+    ) -> PartialVMResult<()>;
+
+    /// Charges gas charge under the IO category.
+    ///
+    /// The amount charged can be a quantity or an abstract expression containing
+    /// gas parameters.
+    fn charge_io(
+        &mut self,
+        abstract_amount: impl GasExpression<VMGasParameters, Unit = InternalGasUnit>,
+    ) -> PartialVMResult<()>;
+
+    /// Charges storage fee.
+    ///
+    /// The amount charged can be a quantity or an abstract expression containing
+    /// gas parameters.
+    fn charge_storage_fee(
+        &mut self,
+        abstract_amount: impl GasExpression<VMGasParameters, Unit = Octa>,
+        gas_unit_price: FeePerGasUnit,
+    ) -> PartialVMResult<()>;
+
+    /// Returns the amount of gas used under the execution category.
+    fn execution_gas_used(&self) -> InternalGas;
+
+    /// Returns the amount of gas used under the IO category.
+    fn io_gas_used(&self) -> InternalGas;
+
+    /// Returns the amount of storage fee used, measured in internal gas units.
+    fn storage_fee_used_in_gas_units(&self) -> InternalGas;
+
+    /// Returns the amount of storage fee used.
+    fn storage_fee_used(&self) -> Fee;
+}
+
+/// Trait representing a gas meter used inside the Aptos VM.
+///
+/// It extends Move VM's `GasMeter` trait with a few Aptos-specific callbacks, along with
+/// some primitives that would allow gas meters to be composable.
+pub trait AptosGasMeter: MoveGasMeter {
+    type Algebra: GasAlgebra;
+
+    /// Returns a reference to the underlying algebra object.
+    fn algebra(&self) -> &Self::Algebra;
+
+    /// Returns a mutable reference to the underlying algebra object.
+    fn algebra_mut(&mut self) -> &mut Self::Algebra;
+
+    /// Charges fee for utilizing short-term or long-term storage.
+    ///
+    /// Since the fee is measured in APT/Octa, it needs to be converted into gas units
+    /// according to the given unit price.
+    fn charge_storage_fee(
+        &mut self,
+        amount: Fee,
+        gas_unit_price: FeePerGasUnit,
+    ) -> PartialVMResult<()>;
+
+    /// Charges an intrinsic cost for executing the transaction.
+    ///
+    /// The cost stays constant for transactions below a certain size, but will grow proportionally
+    /// for bigger ones.
+    fn charge_intrinsic_gas_for_transaction(&mut self, txn_size: NumBytes) -> VMResult<()>;
+
+    /// Charges IO gas for an item in the write set.
+    ///
+    /// This is to be differentiated from the storage fee, which is meant to cover the long-term
+    /// storage costs.
+    fn charge_io_gas_for_write(&mut self, key: &StateKey, op: &WriteOp) -> VMResult<()>;
+
+    /// Calculates the storage fee for a write operation.
+    fn storage_fee_per_write(&self, key: &StateKey, op: &WriteOp) -> Fee;
+
+    /// Calculates the storage fee for an event.
+    fn storage_fee_per_event(&self, event: &ContractEvent) -> Fee;
+
+    /// Calculates the discount applied to the event storage fees, based on a free quota.
+    fn storage_discount_for_events(&self, total_cost: Fee) -> Fee;
+
+    /// Calculates the storage fee for the transaction.
+    fn storage_fee_for_transaction_storage(&self, txn_size: NumBytes) -> Fee;
+
+    /// Charges the storage fees for writes, events & txn storage in a lump sum, minimizing the
+    /// loss of precision.
+    ///
+    /// The contract requires that this function behaviors in a way that is consistent to
+    /// the ones defining the costs.
+    /// Due to this reason, you should normally not override the default implementation,
+    /// unless you are doing something special, such as injecting additional logging logic.
+    fn charge_storage_fee_for_all<'a>(
+        &mut self,
+        write_ops: impl IntoIterator<Item = (&'a StateKey, &'a WriteOp)>,
+        events: impl IntoIterator<Item = &'a ContractEvent>,
+        txn_size: NumBytes,
+        gas_unit_price: FeePerGasUnit,
+    ) -> VMResult<()> {
+        // The new storage fee are only active since version 7.
+        if self.feature_version() < 7 {
+            return Ok(());
+        }
+
+        // TODO(Gas): right now, some of our tests use a unit price of 0 and this is a hack
+        // to avoid causing them issues. We should revisit the problem and figure out a
+        // better way to handle this.
+        if gas_unit_price.is_zero() {
+            return Ok(());
+        }
+
+        // Calculate the storage fees.
+        let write_fee = write_ops.into_iter().fold(Fee::new(0), |acc, (key, op)| {
+            acc + self.storage_fee_per_write(key, op)
+        });
+        let event_fee = events.into_iter().fold(Fee::new(0), |acc, event| {
+            acc + self.storage_fee_per_event(event)
+        });
+        let event_discount = self.storage_discount_for_events(event_fee);
+        let event_net_fee = event_fee
+            .checked_sub(event_discount)
+            .expect("discount should always be less than or equal to total amount");
+        let txn_fee = self.storage_fee_for_transaction_storage(txn_size);
+        let fee = write_fee + event_net_fee + txn_fee;
+
+        self.charge_storage_fee(fee, gas_unit_price)
+            .map_err(|err| err.finish(Location::Undefined))?;
+
+        Ok(())
+    }
+
+    // Below are getters reexported from the gas algebra.
+    // Gas meter instances should not reimplement these themselves.
+
+    /// Returns the gas feature version.
+    fn feature_version(&self) -> u64 {
+        self.algebra().feature_version()
+    }
+
+    /// Returns the struct that contains all (non-storage) gas parameters.
+    fn vm_gas_params(&self) -> &VMGasParameters {
+        self.algebra().vm_gas_params()
+    }
+
+    // Returns a reference to the struct containing all storage gas parameters.
+    fn storage_gas_params(&self) -> &StorageGasParameters {
+        self.algebra().storage_gas_params()
+    }
+
+    /// Returns the remaining balance, measured in (external) gas units.
+    ///
+    /// The number should be rounded down when converting from internal to external gas units.
+    fn balance(&self) -> Gas {
+        self.algebra()
+            .balance_internal()
+            .to_unit_round_down_with_params(&self.vm_gas_params().txn)
+    }
+
+    /// Returns the scaling factor between internal and external gas units.
+    fn gas_unit_scaling_factor(&self) -> GasScalingFactor {
+        self.algebra().vm_gas_params().txn.scaling_factor()
+    }
+
+    /// Return the total gas used for execution.
+    fn execution_gas_used(&self) -> Gas {
+        self.algebra()
+            .execution_gas_used()
+            .to_unit_round_up_with_params(&self.vm_gas_params().txn)
+    }
+
+    /// Return the total gas used for io.
+    fn io_gas_used(&self) -> Gas {
+        self.algebra()
+            .io_gas_used()
+            .to_unit_round_up_with_params(&self.vm_gas_params().txn)
+    }
+
+    /// Return the total gas used for storage.
+    fn storage_fee_used_in_gas_units(&self) -> Gas {
+        self.algebra()
+            .storage_fee_used_in_gas_units()
+            .to_unit_round_up_with_params(&self.vm_gas_params().txn)
+    }
+
+    /// Return the total fee used for storage.
+    fn storage_fee_used(&self) -> Fee {
+        self.algebra().storage_fee_used()
+    }
+}
diff --git a/aptos-move/aptos-gas-profiling/Cargo.toml b/aptos-move/aptos-gas-profiling/Cargo.toml
index ecfd2f4053da0..d8230d9e2a590 100644
--- a/aptos-move/aptos-gas-profiling/Cargo.toml
+++ b/aptos-move/aptos-gas-profiling/Cargo.toml
@@ -18,8 +18,8 @@ regex = { workspace = true }
 smallvec = { workspace = true }
 
 aptos-framework = { workspace = true }
-aptos-gas = { workspace = true }
 aptos-gas-algebra = { workspace = true }
+aptos-gas-meter = { workspace = true }
 aptos-package-builder = { workspace = true }
 aptos-types = { workspace = true }
 
diff --git a/aptos-move/aptos-gas-profiling/src/profiler.rs b/aptos-move/aptos-gas-profiling/src/profiler.rs
index bd00adb12bba2..ecf2ba83030ca 100644
--- a/aptos-move/aptos-gas-profiling/src/profiler.rs
+++ b/aptos-move/aptos-gas-profiling/src/profiler.rs
@@ -5,8 +5,8 @@ use crate::log::{
     CallFrame, EventStorage, ExecutionAndIOCosts, ExecutionGasEvent, FrameName, StorageFees,
     TransactionGasLog, WriteOpType, WriteStorage, WriteTransient,
 };
-use aptos_gas::AptosGasMeter;
 use aptos_gas_algebra::{Fee, FeePerGasUnit, InternalGas, NumArgs, NumBytes};
+use aptos_gas_meter::AptosGasMeter;
 use aptos_types::{
     contract_event::ContractEvent, state_store::state_key::StateKey, write_set::WriteOp,
 };
diff --git a/aptos-move/aptos-gas-schedule-updator/Cargo.toml b/aptos-move/aptos-gas-schedule-updator/Cargo.toml
new file mode 100644
index 0000000000000..1b256ea430900
--- /dev/null
+++ b/aptos-move/aptos-gas-schedule-updator/Cargo.toml
@@ -0,0 +1,28 @@
+[package]
+name = "aptos-gas-schedule-updator"
+version = "0.1.0"
+
+# Workspace inherited keys
+authors = { workspace = true }
+edition = { workspace = true }
+homepage = { workspace = true }
+license = { workspace = true }
+publish = { workspace = true }
+repository = { workspace = true }
+rust-version = { workspace = true }
+
+[dependencies]
+aptos-gas-schedule = { workspace = true }
+aptos-package-builder = { workspace = true }
+aptos-types = { workspace = true }
+
+move-core-types = { workspace = true }
+move-model = { workspace = true }
+
+anyhow = { workspace = true }
+bcs = { workspace = true }
+clap = { workspace = true }
+
+[dev-dependencies]
+aptos-framework = { workspace = true }
+tempfile = { workspace = true }
diff --git a/aptos-move/aptos-gas/src/gen.rs b/aptos-move/aptos-gas-schedule-updator/src/lib.rs
similarity index 83%
rename from aptos-move/aptos-gas/src/gen.rs
rename to aptos-move/aptos-gas-schedule-updator/src/lib.rs
index 556ea8bbbd66a..fc42bd3943e73 100644
--- a/aptos-move/aptos-gas/src/gen.rs
+++ b/aptos-move/aptos-gas-schedule-updator/src/lib.rs
@@ -1,9 +1,16 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::gas_meter::{AptosGasParameters, InitialGasSchedule, ToOnChainGasSchedule};
+//! This crate implements a script for generating governance proposals to update the
+//! on-chain gas schedule. It can be used as both a library and a standalone binary.
+//!
+//! The generated proposal includes a comment section, listing the contents of the
+//! gas schedule in a human readable format.
+
 use anyhow::Result;
-use aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION;
+use aptos_gas_schedule::{
+    AptosGasParameters, InitialGasSchedule, ToOnChainGasSchedule, LATEST_GAS_FEATURE_VERSION,
+};
 use aptos_package_builder::PackageBuilder;
 use aptos_types::on_chain_config::GasScheduleV2;
 use clap::Parser;
@@ -11,13 +18,6 @@ use move_core_types::account_address::AccountAddress;
 use move_model::{code_writer::CodeWriter, emit, emitln, model::Loc};
 use std::path::{Path, PathBuf};
 
-pub fn current_gas_schedule() -> GasScheduleV2 {
-    GasScheduleV2 {
-        feature_version: LATEST_GAS_FEATURE_VERSION,
-        entries: AptosGasParameters::initial().to_on_chain_gas_schedule(LATEST_GAS_FEATURE_VERSION),
-    }
-}
-
 fn generate_blob(writer: &CodeWriter, data: &[u8]) {
     emitln!(writer, "vector[");
     writer.indent();
@@ -42,7 +42,7 @@ fn generate_script(gas_schedule: &GasScheduleV2) -> Result<String> {
     assert!(gas_schedule_blob.len() < 65536);
 
     let writer = CodeWriter::new(Loc::default());
-    emitln!(writer, "// Gas schedule upgrade proposal\n");
+    emitln!(writer, "// Gas schedule update proposal\n");
 
     emitln!(
         writer,
@@ -102,12 +102,22 @@ fn aptos_framework_path() -> PathBuf {
     )
 }
 
+/// Command line arguments to the gas schedule update proposal generation tool.
 #[derive(Debug, Parser)]
 pub struct GenArgs {
     #[clap(short, long)]
     pub output: Option<String>,
 }
 
+/// Constructs the current gas schedule in on-chain format.
+pub fn current_gas_schedule() -> GasScheduleV2 {
+    GasScheduleV2 {
+        feature_version: LATEST_GAS_FEATURE_VERSION,
+        entries: AptosGasParameters::initial().to_on_chain_gas_schedule(LATEST_GAS_FEATURE_VERSION),
+    }
+}
+
+/// Entrypoint for the update proposal generation tool.
 pub fn generate_update_proposal(args: &GenArgs) -> Result<()> {
     let mut pack = PackageBuilder::new("GasScheduleUpdate");
 
diff --git a/aptos-move/aptos-gas/src/bin/gen_proposal.rs b/aptos-move/aptos-gas-schedule-updator/src/main.rs
similarity index 75%
rename from aptos-move/aptos-gas/src/bin/gen_proposal.rs
rename to aptos-move/aptos-gas-schedule-updator/src/main.rs
index 5ed5eeafc13c6..ad5951070238e 100644
--- a/aptos-move/aptos-gas/src/bin/gen_proposal.rs
+++ b/aptos-move/aptos-gas-schedule-updator/src/main.rs
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use anyhow::Result;
-use aptos_gas::gen::{generate_update_proposal, GenArgs};
+use aptos_gas_schedule_updator::{generate_update_proposal, GenArgs};
 use clap::Parser;
 
 fn main() -> Result<()> {
diff --git a/aptos-move/aptos-gas/tests/gen_tests.rs b/aptos-move/aptos-gas-schedule-updator/tests/gen_tests.rs
similarity index 86%
rename from aptos-move/aptos-gas/tests/gen_tests.rs
rename to aptos-move/aptos-gas-schedule-updator/tests/gen_tests.rs
index 3089da4731adb..e5f1974a38d10 100644
--- a/aptos-move/aptos-gas/tests/gen_tests.rs
+++ b/aptos-move/aptos-gas-schedule-updator/tests/gen_tests.rs
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use aptos_framework::{BuildOptions, BuiltPackage};
-use aptos_gas::gen::{generate_update_proposal, GenArgs};
+use aptos_gas_schedule_updator::{generate_update_proposal, GenArgs};
 
 #[test]
 fn can_generate_and_build_update_proposal() {
diff --git a/aptos-move/aptos-gas-schedule/Cargo.toml b/aptos-move/aptos-gas-schedule/Cargo.toml
index 1560dd72ac5e8..251a62b359266 100644
--- a/aptos-move/aptos-gas-schedule/Cargo.toml
+++ b/aptos-move/aptos-gas-schedule/Cargo.toml
@@ -12,11 +12,10 @@ repository = { workspace = true }
 rust-version = { workspace = true }
 
 [dependencies]
-either = { workspace = true }
-aptos-types = { workspace = true }
-aptos-vm-types = { workspace = true }
 aptos-gas-algebra = { workspace = true }
 aptos-global-constants = { workspace = true }
+aptos-types = { workspace = true }
+either = { workspace = true }
 move-core-types = { workspace = true }
 move-vm-types = { workspace = true }
 paste = { workspace = true }
diff --git a/aptos-move/aptos-gas-schedule/run.py b/aptos-move/aptos-gas-schedule/run.py
deleted file mode 100644
index f2f412b32c5c5..0000000000000
--- a/aptos-move/aptos-gas-schedule/run.py
+++ /dev/null
@@ -1,202 +0,0 @@
-import re
-
-text = """
-        // nop
-        [nop: InternalGas, "nop", 10 * MUL],
-        // control flow
-        [ret: InternalGas, "ret", 60 * MUL],
-        [abort: InternalGas, "abort", 60 * MUL],
-
-        // Note(Gas): The costs of the branch instructions have been jacked up a bit intentionally
-        //            to prevent any single transaction from running for too long.
-        [br_true: InternalGas, "br_true", 120 * MUL],
-        [br_false: InternalGas, "br_false", 120 * MUL],
-        [branch: InternalGas, "branch", 80 * MUL],
-
-        // stack
-        [pop: InternalGas, "pop", 40 * MUL],
-        [ld_u8: InternalGas, "ld_u8", 60 * MUL],
-        [ld_u16: InternalGas, { 5.. => "ld_u16" }, 60 * MUL],
-        [ld_u32: InternalGas, { 5.. => "ld_u32" }, 60 * MUL],
-        [ld_u64: InternalGas, "ld_u64", 60 * MUL],
-        [ld_u128: InternalGas, "ld_u128", 80 * MUL],
-        [ld_u256: InternalGas, { 5.. => "ld_u256" }, 80 * MUL],
-        [ld_true: InternalGas, "ld_true", 60 * MUL],
-        [ld_false: InternalGas, "ld_false", 60 * MUL],
-        [ld_const_base: InternalGas, "ld_const.base", 650 * MUL],
-        [
-            ld_const_per_byte: InternalGasPerByte,
-            "ld_const.per_byte",
-            35 * MUL,
-            LD_CONST_PER_BYTE
-        ],
-        // borrow
-        [imm_borrow_loc: InternalGas, "imm_borrow_loc", 60 * MUL],
-        [mut_borrow_loc: InternalGas, "mut_borrow_loc", 60 * MUL],
-        [imm_borrow_field: InternalGas, "imm_borrow_field", 200 * MUL],
-        [mut_borrow_field: InternalGas, "mut_borrow_field", 200 * MUL],
-        [
-            imm_borrow_field_generic: InternalGas,
-            "imm_borrow_field_generic",
-            200 * MUL
-        ],
-        [
-            mut_borrow_field_generic: InternalGas,
-            "mut_borrow_field_generic",
-            200 * MUL
-        ],
-        // locals
-        [copy_loc_base: InternalGas, "copy_loc.base", 80 * MUL],
-        [
-            copy_loc_per_abs_val_unit: InternalGasPerAbstractValueUnit,
-            "copy_loc.per_abs_val_unit",
-            4 * MUL
-        ],
-        [move_loc_base: InternalGas, "move_loc.base", 120 * MUL],
-        [st_loc_base: InternalGas, "st_loc.base", 120 * MUL],
-        // call
-        [call_base: InternalGas, "call.base", 1000 * MUL],
-        [call_per_arg: InternalGasPerArg, "call.per_arg", 100 * MUL],
-        [call_per_local: InternalGasPerArg, { 1.. => "call.per_local" }, 100 * MUL],
-        [call_generic_base: InternalGas, "call_generic.base", 1000 * MUL],
-        [
-            call_generic_per_ty_arg: InternalGasPerArg,
-            "call_generic.per_ty_arg",
-            100 * MUL
-        ],
-        [
-            call_generic_per_arg: InternalGasPerArg,
-            "call_generic.per_arg",
-            100 * MUL
-        ],
-        [call_generic_per_local: InternalGasPerArg, { 1.. => "call_generic.per_local" }, 100 * MUL],
-        // struct
-        [pack_base: InternalGas, "pack.base", 220 * MUL],
-        [pack_per_field: InternalGasPerArg, "pack.per_field", 40 * MUL],
-        [pack_generic_base: InternalGas, "pack_generic.base", 220 * MUL],
-        [
-            pack_generic_per_field: InternalGasPerArg,
-            "pack_generic.per_field",
-            40 * MUL
-        ],
-        [unpack_base: InternalGas, "unpack.base", 220 * MUL],
-        [unpack_per_field: InternalGasPerArg, "unpack.per_field", 40 * MUL],
-        [unpack_generic_base: InternalGas, "unpack_generic.base", 220 * MUL],
-        [
-            unpack_generic_per_field: InternalGasPerArg,
-            "unpack_generic.per_field",
-            40 * MUL
-        ],
-        // ref
-        [read_ref_base: InternalGas, "read_ref.base", 200 * MUL],
-        [
-            read_ref_per_abs_val_unit: InternalGasPerAbstractValueUnit,
-            "read_ref.per_abs_val_unit",
-            4 * MUL
-        ],
-        [write_ref_base: InternalGas, "write_ref.base", 200 * MUL],
-        [freeze_ref: InternalGas, "freeze_ref", 10 * MUL],
-        // casting
-        [cast_u8: InternalGas, "cast_u8", 120 * MUL],
-        [cast_u16: InternalGas, { 5.. => "cast_u16" }, 120 * MUL],
-        [cast_u32: InternalGas, { 5.. => "cast_u32" }, 120 * MUL],
-        [cast_u64: InternalGas, "cast_u64", 120 * MUL],
-        [cast_u128: InternalGas, "cast_u128", 120 * MUL],
-        [cast_u256: InternalGas, { 5.. => "cast_u256" }, 120 * MUL],
-        // arithmetic
-        [add: InternalGas, "add", 160 * MUL],
-        [sub: InternalGas, "sub", 160 * MUL],
-        [mul: InternalGas, "mul", 160 * MUL],
-        [mod_: InternalGas, "mod", 160 * MUL],
-        [div: InternalGas, "div", 160 * MUL],
-        // bitwise
-        [bit_or: InternalGas, "bit_or", 160 * MUL],
-        [bit_and: InternalGas, "bit_and", 160 * MUL],
-        [xor: InternalGas, "bit_xor", 160 * MUL],
-        [shl: InternalGas, "bit_shl", 160 * MUL],
-        [shr: InternalGas, "bit_shr", 160 * MUL],
-        // boolean
-        [or: InternalGas, "or", 160 * MUL],
-        [and: InternalGas, "and", 160 * MUL],
-        [not: InternalGas, "not", 160 * MUL],
-        // comparison
-        [lt: InternalGas, "lt", 160 * MUL],
-        [gt: InternalGas, "gt", 160 * MUL],
-        [le: InternalGas, "le", 160 * MUL],
-        [ge: InternalGas, "ge", 160 * MUL],
-        [eq_base: InternalGas, "eq.base", 100 * MUL],
-        [
-            eq_per_abs_val_unit: InternalGasPerAbstractValueUnit,
-            "eq.per_abs_val_unit",
-            4 * MUL
-        ],
-        [neq_base: InternalGas, "neq.base", 100 * MUL],
-        [
-            neq_per_abs_val_unit: InternalGasPerAbstractValueUnit,
-            "neq.per_abs_val_unit",
-            4 * MUL
-        ],
-        // global
-        [
-            imm_borrow_global_base: InternalGas,
-            "imm_borrow_global.base",
-            500 * MUL
-        ],
-        [
-            imm_borrow_global_generic_base: InternalGas,
-            "imm_borrow_global_generic.base",
-            500 * MUL
-        ],
-        [
-            mut_borrow_global_base: InternalGas,
-            "mut_borrow_global.base",
-            500 * MUL
-        ],
-        [
-            mut_borrow_global_generic_base: InternalGas,
-            "mut_borrow_global_generic.base",
-            500 * MUL
-        ],
-        [exists_base: InternalGas, "exists.base", 250 * MUL],
-        [exists_generic_base: InternalGas, "exists_generic.base", 250 * MUL],
-        [move_from_base: InternalGas, "move_from.base", 350 * MUL],
-        [
-            move_from_generic_base: InternalGas,
-            "move_from_generic.base",
-            350 * MUL
-        ],
-        [move_to_base: InternalGas, "move_to.base", 500 * MUL],
-        [
-            move_to_generic_base: InternalGas,
-            "move_to_generic.base",
-            500 * MUL
-        ],
-        // vec
-        [vec_len_base: InternalGas, "vec_len.base", 220 * MUL],
-        [vec_imm_borrow_base: InternalGas, "vec_imm_borrow.base", 330 * MUL],
-        [vec_mut_borrow_base: InternalGas, "vec_mut_borrow.base", 330 * MUL],
-        [vec_push_back_base: InternalGas, "vec_push_back.base", 380 * MUL],
-        [vec_pop_back_base: InternalGas, "vec_pop_back.base", 260 * MUL],
-        [vec_swap_base: InternalGas, "vec_swap.base", 300 * MUL],
-        [vec_pack_base: InternalGas, "vec_pack.base", 600 * MUL],
-        [
-            vec_pack_per_elem: InternalGasPerArg,
-            "vec_pack.per_elem",
-            40 * MUL
-        ],
-        [vec_unpack_base: InternalGas, "vec_unpack.base", 500 * MUL],
-        [
-            vec_unpack_per_expected_elem: InternalGasPerArg,
-            "vec_unpack.per_expected_elem",
-            40 * MUL
-        ],
-"""
-
-
-def replace(match):
-    return str(int(match.group(1)) * 20)
-
-
-res = re.sub("([0-9]+) *\* *MUL", replace, text)
-
-print(res)
diff --git a/aptos-move/aptos-gas-schedule/src/gas_params/mod.rs b/aptos-move/aptos-gas-schedule/src/gas_params/mod.rs
deleted file mode 100644
index a28a089def479..0000000000000
--- a/aptos-move/aptos-gas-schedule/src/gas_params/mod.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::traits::{FromOnChainGasSchedule, InitialGasSchedule, ToOnChainGasSchedule};
-use std::collections::BTreeMap;
-
-mod instr;
-mod macros;
-mod misc;
-mod storage;
-mod transaction;
-
-pub use instr::{gas_params as instr_gas_params, InstructionGasParameters};
-pub use misc::{gas_params as misc_gas_params, AbstractValueSizeGasParameters, MiscGasParameters};
-pub use storage::*;
-pub use transaction::{gas_params as txn_gas_params, TransactionGasParameters};
-
-/// Gas parameters for everything that is needed to run the Aptos blockchain, including
-/// instructions, transactions and native functions from various packages.
-#[derive(Debug, Clone)]
-pub struct AptosGasParameters {
-    pub misc: MiscGasParameters,
-    pub instr: InstructionGasParameters,
-    pub txn: TransactionGasParameters,
-}
-
-impl FromOnChainGasSchedule for AptosGasParameters {
-    fn from_on_chain_gas_schedule(
-        gas_schedule: &BTreeMap<String, u64>,
-        feature_version: u64,
-    ) -> Result<Self, String> {
-        Ok(Self {
-            misc: FromOnChainGasSchedule::from_on_chain_gas_schedule(
-                gas_schedule,
-                feature_version,
-            )?,
-            instr: FromOnChainGasSchedule::from_on_chain_gas_schedule(
-                gas_schedule,
-                feature_version,
-            )?,
-            txn: FromOnChainGasSchedule::from_on_chain_gas_schedule(gas_schedule, feature_version)?,
-        })
-    }
-}
-
-impl ToOnChainGasSchedule for AptosGasParameters {
-    fn to_on_chain_gas_schedule(&self, feature_version: u64) -> Vec<(String, u64)> {
-        let mut entries = self.instr.to_on_chain_gas_schedule(feature_version);
-        entries.extend(self.txn.to_on_chain_gas_schedule(feature_version));
-        entries.extend(self.misc.to_on_chain_gas_schedule(feature_version));
-        entries
-    }
-}
-
-impl AptosGasParameters {
-    pub fn zeros() -> Self {
-        Self {
-            misc: MiscGasParameters::zeros(),
-            instr: InstructionGasParameters::zeros(),
-            txn: TransactionGasParameters::zeros(),
-        }
-    }
-}
-
-impl InitialGasSchedule for AptosGasParameters {
-    fn initial() -> Self {
-        Self {
-            misc: InitialGasSchedule::initial(),
-            instr: InitialGasSchedule::initial(),
-            txn: InitialGasSchedule::initial(),
-        }
-    }
-}
diff --git a/aptos-move/aptos-gas-schedule/src/gas_schedule/aptos_framework.rs b/aptos-move/aptos-gas-schedule/src/gas_schedule/aptos_framework.rs
new file mode 100644
index 0000000000000..5c7f2d801691f
--- /dev/null
+++ b/aptos-move/aptos-gas-schedule/src/gas_schedule/aptos_framework.rs
@@ -0,0 +1,202 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+//! This module defines the gas parameters for Aptos Framework & Stdlib.
+
+use crate::gas_schedule::NativeGasParameters;
+use aptos_gas_algebra::{
+    InternalGas, InternalGasPerAbstractValueUnit, InternalGasPerArg, InternalGasPerByte,
+};
+
+crate::gas_schedule::macros::define_gas_parameters!(
+    AptosFrameworkGasParameters,
+    "natives.aptos_framework",
+    NativeGasParameters => .aptos_framework,
+    [
+        [account_create_address_base: InternalGas, "account.create_address.base", 6000],
+        [account_create_signer_base: InternalGas, "account.create_signer.base", 6000],
+
+        // Algebra gas parameters begin.
+        // Generated at time 1680606720.0709136 by `scripts/algebra-gas/update_algebra_gas_params.py` with gas_per_ns=10.23.
+        [algebra_ark_bls12_381_fq12_add: InternalGas, { 8.. => "algebra.ark_bls12_381_fq12_add" }, 36380],
+        [algebra_ark_bls12_381_fq12_clone: InternalGas, { 8.. => "algebra.ark_bls12_381_fq12_clone" }, 4220],
+        [algebra_ark_bls12_381_fq12_deser: InternalGas, { 8.. => "algebra.ark_bls12_381_fq12_deser" }, 223600],
+        [algebra_ark_bls12_381_fq12_div: InternalGas, { 8.. => "algebra.ark_bls12_381_fq12_div" }, 5016260],
+        [algebra_ark_bls12_381_fq12_eq: InternalGas, { 8.. => "algebra.ark_bls12_381_fq12_eq" }, 14520],
+        [algebra_ark_bls12_381_fq12_from_u64: InternalGas, { 8.. => "algebra.ark_bls12_381_fq12_from_u64" }, 18020],
+        [algebra_ark_bls12_381_fq12_inv: InternalGas, { 8.. => "algebra.ark_bls12_381_fq12_inv" }, 4010460],
+        [algebra_ark_bls12_381_fq12_mul: InternalGas, { 8.. => "algebra.ark_bls12_381_fq12_mul" }, 997720],
+        [algebra_ark_bls12_381_fq12_neg: InternalGas, { 8.. => "algebra.ark_bls12_381_fq12_neg" }, 23620],
+        [algebra_ark_bls12_381_fq12_one: InternalGas, { 8.. => "algebra.ark_bls12_381_fq12_one" }, 220],
+        [algebra_ark_bls12_381_fq12_pow_u256: InternalGas, { 8.. => "algebra.ark_bls12_381_fq12_pow_u256" }, 293284140],
+        [algebra_ark_bls12_381_fq12_serialize: InternalGas, { 8.. => "algebra.ark_bls12_381_fq12_serialize" }, 161560],
+        [algebra_ark_bls12_381_fq12_square: InternalGas, { 8.. => "algebra.ark_bls12_381_fq12_square" }, 702900],
+        [algebra_ark_bls12_381_fq12_sub: InternalGas, { 8.. => "algebra.ark_bls12_381_fq12_sub" }, 35160],
+        [algebra_ark_bls12_381_fq12_zero: InternalGas, { 8.. => "algebra.ark_bls12_381_fq12_zero" }, 4220],
+        [algebra_ark_bls12_381_fr_add: InternalGas, { 8.. => "algebra.ark_bls12_381_fr_add" }, 4220],
+        [algebra_ark_bls12_381_fr_deser: InternalGas, { 8.. => "algebra.ark_bls12_381_fr_deser" }, 15040],
+        [algebra_ark_bls12_381_fr_div: InternalGas, { 8.. => "algebra.ark_bls12_381_fr_div" }, 1188800],
+        [algebra_ark_bls12_381_fr_eq: InternalGas, { 8.. => "algebra.ark_bls12_381_fr_eq" }, 4240],
+        [algebra_ark_bls12_381_fr_from_u64: InternalGas, { 8.. => "algebra.ark_bls12_381_fr_from_u64" }, 9880],
+        [algebra_ark_bls12_381_fr_inv: InternalGas, { 8.. => "algebra.ark_bls12_381_fr_inv" }, 1172200],
+        [algebra_ark_bls12_381_fr_mul: InternalGas, { 8.. => "algebra.ark_bls12_381_fr_mul" }, 10040],
+        [algebra_ark_bls12_381_fr_neg: InternalGas, { 8.. => "algebra.ark_bls12_381_fr_neg" }, 4260],
+        [algebra_ark_bls12_381_fr_one: InternalGas, { 8.. => "algebra.ark_bls12_381_fr_one" }, 4220],
+        [algebra_ark_bls12_381_fr_serialize: InternalGas, { 8.. => "algebra.ark_bls12_381_fr_serialize" }, 22060],
+        [algebra_ark_bls12_381_fr_square: InternalGas, { 8.. => "algebra.ark_bls12_381_fr_square" }, 9500],
+        [algebra_ark_bls12_381_fr_sub: InternalGas, { 8.. => "algebra.ark_bls12_381_fr_sub" }, 5800],
+        [algebra_ark_bls12_381_fr_zero: InternalGas, { 8.. => "algebra.ark_bls12_381_fr_zero" }, 4220],
+        [algebra_ark_bls12_381_g1_affine_deser_comp: InternalGas, { 8.. => "algebra.ark_bls12_381_g1_affine_deser_comp" }, 20591980],
+        [algebra_ark_bls12_381_g1_affine_deser_uncomp: InternalGas, { 8.. => "algebra.ark_bls12_381_g1_affine_deser_uncomp" }, 14412760],
+        [algebra_ark_bls12_381_g1_affine_serialize_comp: InternalGas, { 8.. => "algebra.ark_bls12_381_g1_affine_serialize_comp" }, 40280],
+        [algebra_ark_bls12_381_g1_affine_serialize_uncomp: InternalGas, { 8.. => "algebra.ark_bls12_381_g1_affine_serialize_uncomp" }, 48660],
+        [algebra_ark_bls12_381_g1_proj_add: InternalGas, { 8.. => "algebra.ark_bls12_381_g1_proj_add" }, 216120],
+        [algebra_ark_bls12_381_g1_proj_double: InternalGas, { 8.. => "algebra.ark_bls12_381_g1_proj_double" }, 105280],
+        [algebra_ark_bls12_381_g1_proj_eq: InternalGas, { 8.. => "algebra.ark_bls12_381_g1_proj_eq" }, 100700],
+        [algebra_ark_bls12_381_g1_proj_generator: InternalGas, { 8.. => "algebra.ark_bls12_381_g1_proj_generator" }, 220],
+        [algebra_ark_bls12_381_g1_proj_infinity: InternalGas, { 8.. => "algebra.ark_bls12_381_g1_proj_infinity" }, 220],
+        [algebra_ark_bls12_381_g1_proj_neg: InternalGas, { 8.. => "algebra.ark_bls12_381_g1_proj_neg" }, 220],
+        [algebra_ark_bls12_381_g1_proj_scalar_mul: InternalGas, { 8.. => "algebra.ark_bls12_381_g1_proj_scalar_mul" }, 50470420],
+        [algebra_ark_bls12_381_g1_proj_sub: InternalGas, { 8.. => "algebra.ark_bls12_381_g1_proj_sub" }, 222940],
+        [algebra_ark_bls12_381_g1_proj_to_affine: InternalGas, { 8.. => "algebra.ark_bls12_381_g1_proj_to_affine" }, 2420700],
+        [algebra_ark_bls12_381_g2_affine_deser_comp: InternalGas, { 8.. => "algebra.ark_bls12_381_g2_affine_deser_comp" }, 41201360],
+        [algebra_ark_bls12_381_g2_affine_deser_uncomp: InternalGas, { 8.. => "algebra.ark_bls12_381_g2_affine_deser_uncomp" }, 20359580],
+        [algebra_ark_bls12_381_g2_affine_serialize_comp: InternalGas, { 8.. => "algebra.ark_bls12_381_g2_affine_serialize_comp" }, 67560],
+        [algebra_ark_bls12_381_g2_affine_serialize_uncomp: InternalGas, { 8.. => "algebra.ark_bls12_381_g2_affine_serialize_uncomp" }, 84340],
+        [algebra_ark_bls12_381_g2_proj_add: InternalGas, { 8.. => "algebra.ark_bls12_381_g2_proj_add" }, 648020],
+        [algebra_ark_bls12_381_g2_proj_double: InternalGas, { 8.. => "algebra.ark_bls12_381_g2_proj_double" }, 296780],
+        [algebra_ark_bls12_381_g2_proj_eq: InternalGas, { 8.. => "algebra.ark_bls12_381_g2_proj_eq" }, 303100],
+        [algebra_ark_bls12_381_g2_proj_generator: InternalGas, { 8.. => "algebra.ark_bls12_381_g2_proj_generator" }, 220],
+        [algebra_ark_bls12_381_g2_proj_infinity: InternalGas, { 8.. => "algebra.ark_bls12_381_g2_proj_infinity" }, 220],
+        [algebra_ark_bls12_381_g2_proj_neg: InternalGas, { 8.. => "algebra.ark_bls12_381_g2_proj_neg" }, 220],
+        [algebra_ark_bls12_381_g2_proj_scalar_mul: InternalGas, { 8.. => "algebra.ark_bls12_381_g2_proj_scalar_mul" }, 150530160],
+        [algebra_ark_bls12_381_g2_proj_sub: InternalGas, { 8.. => "algebra.ark_bls12_381_g2_proj_sub" }, 657380],
+        [algebra_ark_bls12_381_g2_proj_to_affine: InternalGas, { 8.. => "algebra.ark_bls12_381_g2_proj_to_affine" }, 2577140],
+        [algebra_ark_bls12_381_multi_pairing_base: InternalGas, { 8.. => "algebra.ark_bls12_381_multi_pairing_base" }, 179972980],
+        [algebra_ark_bls12_381_multi_pairing_per_pair: InternalGasPerArg, { 8.. => "algebra.ark_bls12_381_multi_pairing_per_pair" }, 92052840],
+        [algebra_ark_bls12_381_pairing: InternalGas, { 8.. => "algebra.ark_bls12_381_pairing" }, 296644400],
+        [algebra_ark_h2c_bls12381g1_xmd_sha256_sswu_base: InternalGas, { 8.. => "algebra.ark_h2c_bls12381g1_xmd_sha256_sswu_base" }, 65038860],
+        [algebra_ark_h2c_bls12381g1_xmd_sha256_sswu_per_msg_byte: InternalGasPerByte, { 8.. => "algebra.ark_h2c_bls12381g1_xmd_sha256_sswu_per_msg_byte" }, 960],
+        [algebra_ark_h2c_bls12381g2_xmd_sha256_sswu_base: InternalGas, { 8.. => "algebra.ark_h2c_bls12381g2_xmd_sha256_sswu_base" }, 135460040],
+        [algebra_ark_h2c_bls12381g2_xmd_sha256_sswu_per_msg_byte: InternalGasPerByte, { 8.. => "algebra.ark_h2c_bls12381g2_xmd_sha256_sswu_per_msg_byte" }, 960],
+        // Algebra gas parameters end.
+
+        [bls12381_base: InternalGas, "bls12381.base", 3000],
+
+        [bls12381_per_pubkey_deserialize: InternalGasPerArg, "bls12381.per_pubkey_deserialize", 2180000],
+        [bls12381_per_pubkey_aggregate: InternalGasPerArg, "bls12381.per_pubkey_aggregate", 84000],
+        [bls12381_per_pubkey_subgroup_check: InternalGasPerArg, "bls12381.per_pubkey_subgroup_check", 7400000],
+
+        [bls12381_per_sig_deserialize: InternalGasPerArg, "bls12381.per_sig_deserialize", 4440000],
+        [bls12381_per_sig_aggregate: InternalGasPerArg, "bls12381.per_sig_aggregate", 233000],
+        [bls12381_per_sig_subgroup_check: InternalGasPerArg, "bls12381.per_sig_subgroup_check", 9210000],
+
+        [bls12381_per_sig_verify: InternalGasPerArg, "bls12381.per_sig_verify", 169700000],
+        [bls12381_per_pop_verify: InternalGasPerArg, "bls12381.per_pop_verify", 206000000],
+
+        [bls12381_per_pairing: InternalGasPerArg, "bls12381.per_pairing", 80260000],
+
+        [bls12381_per_msg_hashing: InternalGasPerArg, "bls12381.per_msg_hashing", 30800000],
+        [bls12381_per_byte_hashing: InternalGasPerByte, "bls12381.per_byte_hashing", 1000],
+
+        [ed25519_base: InternalGas, "signature.base", 3000],
+        [ed25519_per_pubkey_deserialize: InternalGasPerArg, "signature.per_pubkey_deserialize", 760000],
+        [ed25519_per_pubkey_small_order_check: InternalGasPerArg, "signature.per_pubkey_small_order_check", 127000],
+        [ed25519_per_sig_deserialize: InternalGasPerArg, "signature.per_sig_deserialize", 7500],
+        [ed25519_per_sig_strict_verify: InternalGasPerArg, "signature.per_sig_strict_verify", 5340000],
+        [ed25519_per_msg_hashing_base: InternalGasPerArg, "signature.per_msg_hashing_base", 64800],
+        [ed25519_per_msg_byte_hashing: InternalGasPerByte, "signature.per_msg_byte_hashing", 1200],
+
+        [secp256k1_base: InternalGas, "secp256k1.base", 3000],
+        [secp256k1_ecdsa_recover: InternalGasPerArg, "secp256k1.ecdsa_recover", 32200000],
+
+        [ristretto255_basepoint_mul: InternalGasPerArg, "ristretto255.basepoint_mul", 2560000],
+        [ristretto255_basepoint_double_mul: InternalGasPerArg, "ristretto255.basepoint_double_mul", 8800000],
+
+        [ristretto255_point_add: InternalGasPerArg, "ristretto255.point_add", 42700],
+        [ristretto255_point_compress: InternalGasPerArg, "ristretto255.point_compress", 800000],
+        [ristretto255_point_decompress: InternalGasPerArg, "ristretto255.point_decompress", 810000],
+        [ristretto255_point_equals: InternalGasPerArg, "ristretto255.point_equals", 46000],
+        [ristretto255_point_from_64_uniform_bytes: InternalGasPerArg, "ristretto255.point_from_64_uniform_bytes", 1630000],
+        [ristretto255_point_identity: InternalGasPerArg, "ristretto255.point_identity", 3000],
+        [ristretto255_point_mul: InternalGasPerArg, "ristretto255.point_mul", 9420000],
+        [ristretto255_point_neg: InternalGasPerArg, "ristretto255.point_neg", 7200],
+        [ristretto255_point_sub: InternalGasPerArg, "ristretto255.point_sub", 42600],
+        [ristretto255_point_parse_arg: InternalGasPerArg, "ristretto255.point_parse_arg", 3000],
+
+
+        // TODO(Alin): These SHA512 gas costs could be unified with the costs in our future SHA512 module
+        // (assuming same implementation complexity, which might not be the case
+        [ristretto255_sha512_per_byte: InternalGasPerByte, "ristretto255.scalar_sha512_per_byte", 1200],
+        [ristretto255_sha512_per_hash: InternalGasPerArg, "ristretto255.scalar_sha512_per_hash", 64800],
+
+        [ristretto255_scalar_add: InternalGasPerArg, "ristretto255.scalar_add", 15400],
+        [ristretto255_scalar_reduced_from_32_bytes: InternalGasPerArg, "ristretto255.scalar_reduced_from_32_bytes", 14200],
+        [ristretto255_scalar_uniform_from_64_bytes: InternalGasPerArg, "ristretto255.scalar_uniform_from_64_bytes", 24900],
+        [ristretto255_scalar_from_u128: InternalGasPerArg, "ristretto255.scalar_from_u128", 3500],
+        [ristretto255_scalar_from_u64: InternalGasPerArg, "ristretto255.scalar_from_u64", 3500],
+        [ristretto255_scalar_invert: InternalGasPerArg, "ristretto255.scalar_invert", 2200000],
+        [ristretto255_scalar_is_canonical: InternalGasPerArg, "ristretto255.scalar_is_canonical", 23000],
+        [ristretto255_scalar_mul: InternalGasPerArg, "ristretto255.scalar_mul", 21300],
+        [ristretto255_scalar_neg: InternalGasPerArg, "ristretto255.scalar_neg", 14500],
+        [ristretto255_scalar_sub: InternalGasPerArg, "ristretto255.scalar_sub", 21200],
+        [ristretto255_scalar_parse_arg: InternalGasPerArg, "ristretto255.scalar_parse_arg", 3000],
+
+        [hash_sip_hash_base: InternalGas, "hash.sip_hash.base", 20000],
+        [hash_sip_hash_per_byte: InternalGasPerByte, "hash.sip_hash.per_byte", 400],
+
+        [hash_keccak256_base: InternalGas, { 1.. => "hash.keccak256.base" }, 80000],
+        [hash_keccak256_per_byte: InternalGasPerByte, { 1.. => "hash.keccak256.per_byte" }, 900],
+
+        [type_info_type_of_base: InternalGas, "type_info.type_of.base", 6000],
+        // TODO(Gas): the on-chain name is wrong...
+        [type_info_type_of_per_byte_in_str: InternalGasPerByte, "type_info.type_of.per_abstract_memory_unit", 100],
+        [type_info_type_name_base: InternalGas, "type_info.type_name.base", 6000],
+        // TODO(Gas): the on-chain name is wrong...
+        [type_info_type_name_per_byte_in_str: InternalGasPerByte, "type_info.type_name.per_abstract_memory_unit", 100],
+        [type_info_chain_id_base: InternalGas, { 4.. => "type_info.chain_id.base" }, 3000],
+
+        // Reusing SHA2-512's cost from Ristretto
+        [hash_sha2_512_base: InternalGas, { 4.. => "hash.sha2_512.base" }, 3_240],
+        [hash_sha2_512_per_byte: InternalGasPerByte, { 4.. => "hash.sha2_512.per_byte" }, 60],
+        // Back-of-the-envelop approximation from SHA3-256's (4000 base, 45 per-byte) costs
+        [hash_sha3_512_base: InternalGas, { 4.. => "hash.sha3_512.base" }, 4_500],
+        [hash_sha3_512_per_byte: InternalGasPerByte, { 4.. => "hash.sha3_512.per_byte" }, 50],
+        // Using SHA2-256's cost
+        [hash_ripemd160_base: InternalGas, { 4.. => "hash.ripemd160.base" }, 3000],
+        [hash_ripemd160_per_byte: InternalGasPerByte, { 4.. => "hash.ripemd160.per_byte" }, 50],
+        [hash_blake2b_256_base: InternalGas, { 6.. => "hash.blake2b_256.base" }, 1750],
+        [hash_blake2b_256_per_byte: InternalGasPerByte, { 6.. => "hash.blake2b_256.per_byte" }, 15],
+
+        [util_from_bytes_base: InternalGas, "util.from_bytes.base", 6000],
+        [util_from_bytes_per_byte: InternalGasPerByte, "util.from_bytes.per_byte", 100],
+
+        [transaction_context_get_txn_hash_base: InternalGas, { 10.. => "transaction_context.get_txn_hash.base" }, 4000],
+        [transaction_context_get_script_hash_base: InternalGas, "transaction_context.get_script_hash.base", 4000],
+        // Based on SHA3-256's cost
+        [transaction_context_generate_unique_address_base: InternalGas, { 10.. => "transaction_context.generate_unique_address.base" }, 80000],
+
+        [code_request_publish_base: InternalGas, "code.request_publish.base", 10000],
+        [code_request_publish_per_byte: InternalGasPerByte, "code.request_publish.per_byte", 40],
+
+        // Note(Gas): These are storage operations so the values should not be multiplied.
+        [event_write_to_event_store_base: InternalGas, "event.write_to_event_store.base", 300_000],
+        // TODO(Gas): the on-chain name is wrong...
+        [event_write_to_event_store_per_abstract_value_unit: InternalGasPerAbstractValueUnit, "event.write_to_event_store.per_abstract_memory_unit", 5_000],
+
+        [state_storage_get_usage_base_cost: InternalGas, "state_storage.get_usage.base", 10000],
+
+        [aggregator_add_base: InternalGas, "aggregator.add.base", 6000],
+        [aggregator_read_base: InternalGas, "aggregator.read.base", 6000],
+        [aggregator_sub_base: InternalGas, "aggregator.sub.base", 6000],
+        [aggregator_destroy_base: InternalGas, "aggregator.destroy.base", 10000],
+        [aggregator_factory_new_aggregator_base: InternalGas, "aggregator_factory.new_aggregator.base", 10000],
+
+        [object_exists_at_base: InternalGas, { 7.. => "object.exists_at.base" }, 5000],
+        // These are dummy value, they copied from storage gas in aptos-core/aptos-vm/src/aptos_vm_impl.rs
+        [object_exists_at_per_byte_loaded: InternalGasPerByte, { 7.. => "object.exists_at.per_byte_loaded" }, 1000],
+        [object_exists_at_per_item_loaded: InternalGas, { 7.. => "object.exists_at.per_item_loaded" }, 8000],
+        [string_utils_base: InternalGas, { 8.. => "string_utils.format.base" }, 6000],
+        [string_utils_per_byte: InternalGasPerByte, { 8.. =>"string_utils.format.per_byte" }, 20],
+    ]
+);
diff --git a/aptos-move/aptos-gas-schedule/src/gas_params/instr.rs b/aptos-move/aptos-gas-schedule/src/gas_schedule/instr.rs
similarity index 97%
rename from aptos-move/aptos-gas-schedule/src/gas_params/instr.rs
rename to aptos-move/aptos-gas-schedule/src/gas_schedule/instr.rs
index b8478972f388d..4b7ae50b6fb9f 100644
--- a/aptos-move/aptos-gas-schedule/src/gas_params/instr.rs
+++ b/aptos-move/aptos-gas-schedule/src/gas_schedule/instr.rs
@@ -1,14 +1,17 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
+//! This module defines the gas parameters for all Move instructions.
+
+use crate::gas_schedule::VMGasParameters;
 use aptos_gas_algebra::{
     InternalGas, InternalGasPerAbstractValueUnit, InternalGasPerArg, InternalGasPerByte,
 };
 
-crate::gas_params::macros::define_gas_parameters!(
+crate::gas_schedule::macros::define_gas_parameters!(
     InstructionGasParameters,
     "instr",
-    .instr,
+    VMGasParameters => .instr,
     [
         // nop
         [nop: InternalGas, "nop", 200],
diff --git a/aptos-move/aptos-gas-schedule/src/gas_params/macros.rs b/aptos-move/aptos-gas-schedule/src/gas_schedule/macros.rs
similarity index 72%
rename from aptos-move/aptos-gas-schedule/src/gas_params/macros.rs
rename to aptos-move/aptos-gas-schedule/src/gas_schedule/macros.rs
index 4f90780d8bf3f..51fd348832abe 100644
--- a/aptos-move/aptos-gas-schedule/src/gas_params/macros.rs
+++ b/aptos-move/aptos-gas-schedule/src/gas_schedule/macros.rs
@@ -19,7 +19,7 @@ macro_rules! define_gas_parameters {
     (
         $params_name: ident,
         $prefix: literal,
-        $(.$field: ident)*,
+        $env: ty => $(.$field: ident)*,
         [$(
             [$name: ident: $ty: ident, $key_bindings: tt, $initial: expr $(, $tn: ident)? $(,)?]
         ),* $(,)?]
@@ -35,7 +35,7 @@ macro_rules! define_gas_parameters {
                 let mut params = $params_name::zeros();
 
                 $(
-                    if let Some(key) = $crate::gas_params::macros::define_gas_parameters_extract_key_at_version!($key_bindings, feature_version) {
+                    if let Some(key) = $crate::gas_schedule::macros::define_gas_parameters_extract_key_at_version!($key_bindings, feature_version) {
                         let name = format!("{}.{}", $prefix, key);
                         params.$name = gas_schedule.get(&name).cloned().ok_or_else(|| format!("Gas parameter {} does not exist. Feature version: {}.", name, feature_version))?.into();
                     }
@@ -51,7 +51,7 @@ macro_rules! define_gas_parameters {
                 let mut output = vec![];
 
                 $(
-                    if let Some(key) = $crate::gas_params::macros::define_gas_parameters_extract_key_at_version!($key_bindings, feature_version) {
+                    if let Some(key) = $crate::gas_schedule::macros::define_gas_parameters_extract_key_at_version!($key_bindings, feature_version) {
                         output.push((format!("{}.{}", $prefix, key), self.$name.into()))
                     }
                 )*
@@ -78,9 +78,10 @@ macro_rules! define_gas_parameters {
 
         #[allow(unused)]
         pub mod gas_params {
+            use super::*;
             use aptos_gas_algebra::{GasExpression, GasExpressionVisitor, GasMul, GasAdd};
             use $crate::{
-                gas_params::AptosGasParameters,
+                gas_schedule::AptosGasParameters,
             };
             use std::ops::{Add, Mul};
             use move_core_types::gas_algebra::{GasQuantity, GasQuantityGetUnit};
@@ -93,21 +94,24 @@ macro_rules! define_gas_parameters {
 
             $(
                 paste::paste! {
+                    #[derive(Debug)]
                     #[doc = "Type representing the `" $name "` gas parameter."]
                     #[allow(non_camel_case_types)]
                     pub struct [<$name:upper>];
 
-                    impl GasExpression<AptosGasParameters> for [<$name:upper>] {
+                    impl GasExpression<$env> for [<$name:upper>] {
                         type Unit =  <super::$ty as GasQuantityGetUnit>::Unit;
 
-                        fn materialize(
+                        #[inline]
+                        fn evaluate(
                             &self,
                             _feature_version: u64,
-                            gas_params: &$crate::gas_params::AptosGasParameters,
+                            gas_params: &$env,
                         ) -> GasQuantity<Self::Unit> {
                             get!(gas_params, $name)
                         }
 
+                        #[inline]
                         fn visit(&self, visitor: &mut impl GasExpressionVisitor) {
                             visitor.gas_param::<Self>();
                         }
@@ -117,6 +121,7 @@ macro_rules! define_gas_parameters {
                     {
                         type Output = GasAdd<Self, T>;
 
+                        #[inline]
                         fn add(self, rhs: T) -> Self::Output {
                             GasAdd { left: self, right: rhs }
                         }
@@ -126,21 +131,40 @@ macro_rules! define_gas_parameters {
                     {
                         type Output = GasMul<Self, T>;
 
+                        #[inline]
                         fn mul(self, rhs: T) -> Self::Output {
                             GasMul { left: self, right: rhs }
                         }
                     }
+
+                    impl Add<[<$name:upper>]> for GasQuantity<<super::$ty as GasQuantityGetUnit>::Unit> {
+                        type Output = GasAdd<Self, [<$name:upper>]>;
+
+                        #[inline]
+                        fn add(self, rhs: [<$name:upper>]) -> Self::Output {
+                            GasAdd { left: self, right: rhs }
+                        }
+                    }
+
+                    impl Mul<[<$name:upper>]> for GasQuantity<<super::$ty as GasQuantityGetUnit>::Unit> {
+                        type Output = GasMul<Self, [<$name:upper>]>;
+
+                        #[inline]
+                        fn mul(self, rhs: [<$name:upper>]) -> Self::Output {
+                            GasMul { left: self, right: rhs }
+                        }
+                    }
                 }
             )*
         }
 
         #[test]
         fn keys_should_be_unique_for_all_versions() {
-            for ver in 0..=aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION {
+            for ver in 0..=$crate::LATEST_GAS_FEATURE_VERSION {
                 let mut map = std::collections::BTreeMap::<&str, ()>::new();
 
                 $(
-                    if let Some(key) = $crate::params::define_gas_parameters_extract_key_at_version!($key_bindings, ver) {
+                    if let Some(key) = $crate::gas_schedule::macros::define_gas_parameters_extract_key_at_version!($key_bindings, ver) {
                         if map.insert(key, ()).is_some() {
                             panic!("duplicated key {} at version {}", key, ver);
                         }
diff --git a/aptos-move/aptos-gas-schedule/src/gas_params/misc.rs b/aptos-move/aptos-gas-schedule/src/gas_schedule/misc.rs
similarity index 98%
rename from aptos-move/aptos-gas-schedule/src/gas_params/misc.rs
rename to aptos-move/aptos-gas-schedule/src/gas_schedule/misc.rs
index b365689ebb977..c551f92310d81 100644
--- a/aptos-move/aptos-gas-schedule/src/gas_params/misc.rs
+++ b/aptos-move/aptos-gas-schedule/src/gas_schedule/misc.rs
@@ -1,16 +1,22 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::traits::{FromOnChainGasSchedule, InitialGasSchedule, ToOnChainGasSchedule};
+//! This module defines the miscellaneous gas parameters, currently only including the
+//! ones related to definition of abstract value size.
+
+use crate::{
+    gas_schedule::VMGasParameters,
+    traits::{FromOnChainGasSchedule, InitialGasSchedule, ToOnChainGasSchedule},
+};
 use aptos_gas_algebra::{AbstractValueSize, AbstractValueSizePerArg};
 use move_core_types::{account_address::AccountAddress, gas_algebra::NumArgs, u256::U256};
 use move_vm_types::views::{ValueView, ValueVisitor};
 use std::collections::BTreeMap;
 
-crate::gas_params::macros::define_gas_parameters!(
+crate::gas_schedule::macros::define_gas_parameters!(
     AbstractValueSizeGasParameters,
     "misc.abs_val",
-    .misc.abs_val,
+    VMGasParameters => .misc.abs_val,
     [
         // abstract value size
         [u8: AbstractValueSize, "u8", 40],
diff --git a/aptos-move/aptos-gas-schedule/src/gas_schedule/mod.rs b/aptos-move/aptos-gas-schedule/src/gas_schedule/mod.rs
new file mode 100644
index 0000000000000..e38b7e0878e39
--- /dev/null
+++ b/aptos-move/aptos-gas-schedule/src/gas_schedule/mod.rs
@@ -0,0 +1,199 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::traits::{FromOnChainGasSchedule, InitialGasSchedule, ToOnChainGasSchedule};
+use std::collections::BTreeMap;
+
+mod aptos_framework;
+mod instr;
+mod macros;
+mod misc;
+mod move_stdlib;
+mod table;
+mod transaction;
+
+pub use aptos_framework::AptosFrameworkGasParameters;
+pub use instr::InstructionGasParameters;
+pub use misc::{AbstractValueSizeGasParameters, MiscGasParameters};
+pub use move_stdlib::MoveStdlibGasParameters;
+pub use table::TableGasParameters;
+pub use transaction::TransactionGasParameters;
+
+pub mod gas_params {
+    use super::*;
+    pub use instr::gas_params as instr;
+    pub use misc::gas_params as misc;
+    pub use transaction::gas_params as txn;
+
+    pub mod natives {
+        use super::*;
+        pub use aptos_framework::gas_params as aptos_framework;
+        pub use move_stdlib::gas_params as move_stdlib;
+        pub use table::gas_params as table;
+    }
+}
+
+/// Gas parameters for everything that is needed to run the Aptos blockchain, including
+/// instructions, transactions and native functions from various packages.
+#[derive(Debug, Clone)]
+pub struct AptosGasParameters {
+    pub vm: VMGasParameters,
+    pub natives: NativeGasParameters,
+}
+
+impl FromOnChainGasSchedule for AptosGasParameters {
+    fn from_on_chain_gas_schedule(
+        gas_schedule: &BTreeMap<String, u64>,
+        feature_version: u64,
+    ) -> Result<Self, String> {
+        Ok(Self {
+            vm: FromOnChainGasSchedule::from_on_chain_gas_schedule(gas_schedule, feature_version)?,
+            natives: FromOnChainGasSchedule::from_on_chain_gas_schedule(
+                gas_schedule,
+                feature_version,
+            )?,
+        })
+    }
+}
+
+impl ToOnChainGasSchedule for AptosGasParameters {
+    fn to_on_chain_gas_schedule(&self, feature_version: u64) -> Vec<(String, u64)> {
+        let mut entries = self.vm.to_on_chain_gas_schedule(feature_version);
+        entries.extend(self.natives.to_on_chain_gas_schedule(feature_version));
+        entries
+    }
+}
+
+impl AptosGasParameters {
+    pub fn zeros() -> Self {
+        Self {
+            vm: VMGasParameters::zeros(),
+            natives: NativeGasParameters::zeros(),
+        }
+    }
+}
+
+impl InitialGasSchedule for AptosGasParameters {
+    fn initial() -> Self {
+        Self {
+            vm: InitialGasSchedule::initial(),
+            natives: InitialGasSchedule::initial(),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct VMGasParameters {
+    pub misc: MiscGasParameters,
+    pub instr: InstructionGasParameters,
+    pub txn: TransactionGasParameters,
+}
+
+impl FromOnChainGasSchedule for VMGasParameters {
+    fn from_on_chain_gas_schedule(
+        gas_schedule: &BTreeMap<String, u64>,
+        feature_version: u64,
+    ) -> Result<Self, String> {
+        Ok(Self {
+            misc: FromOnChainGasSchedule::from_on_chain_gas_schedule(
+                gas_schedule,
+                feature_version,
+            )?,
+            instr: FromOnChainGasSchedule::from_on_chain_gas_schedule(
+                gas_schedule,
+                feature_version,
+            )?,
+            txn: FromOnChainGasSchedule::from_on_chain_gas_schedule(gas_schedule, feature_version)?,
+        })
+    }
+}
+
+impl ToOnChainGasSchedule for VMGasParameters {
+    fn to_on_chain_gas_schedule(&self, feature_version: u64) -> Vec<(String, u64)> {
+        let mut entries = self.instr.to_on_chain_gas_schedule(feature_version);
+        entries.extend(self.txn.to_on_chain_gas_schedule(feature_version));
+        entries.extend(self.misc.to_on_chain_gas_schedule(feature_version));
+        entries
+    }
+}
+
+impl VMGasParameters {
+    pub fn zeros() -> Self {
+        Self {
+            misc: MiscGasParameters::zeros(),
+            instr: InstructionGasParameters::zeros(),
+            txn: TransactionGasParameters::zeros(),
+        }
+    }
+}
+
+impl InitialGasSchedule for VMGasParameters {
+    fn initial() -> Self {
+        Self {
+            misc: InitialGasSchedule::initial(),
+            instr: InitialGasSchedule::initial(),
+            txn: InitialGasSchedule::initial(),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct NativeGasParameters {
+    pub move_stdlib: MoveStdlibGasParameters,
+    pub table: TableGasParameters,
+    pub aptos_framework: AptosFrameworkGasParameters,
+}
+
+impl FromOnChainGasSchedule for NativeGasParameters {
+    fn from_on_chain_gas_schedule(
+        gas_schedule: &BTreeMap<String, u64>,
+        feature_version: u64,
+    ) -> Result<Self, String> {
+        Ok(Self {
+            move_stdlib: FromOnChainGasSchedule::from_on_chain_gas_schedule(
+                gas_schedule,
+                feature_version,
+            )?,
+            table: FromOnChainGasSchedule::from_on_chain_gas_schedule(
+                gas_schedule,
+                feature_version,
+            )?,
+            aptos_framework: FromOnChainGasSchedule::from_on_chain_gas_schedule(
+                gas_schedule,
+                feature_version,
+            )?,
+        })
+    }
+}
+
+impl ToOnChainGasSchedule for NativeGasParameters {
+    fn to_on_chain_gas_schedule(&self, feature_version: u64) -> Vec<(String, u64)> {
+        let mut entries = self.move_stdlib.to_on_chain_gas_schedule(feature_version);
+        entries.extend(self.table.to_on_chain_gas_schedule(feature_version));
+        entries.extend(
+            self.aptos_framework
+                .to_on_chain_gas_schedule(feature_version),
+        );
+        entries
+    }
+}
+
+impl NativeGasParameters {
+    pub fn zeros() -> Self {
+        Self {
+            move_stdlib: MoveStdlibGasParameters::zeros(),
+            table: TableGasParameters::zeros(),
+            aptos_framework: AptosFrameworkGasParameters::zeros(),
+        }
+    }
+}
+
+impl InitialGasSchedule for NativeGasParameters {
+    fn initial() -> Self {
+        Self {
+            move_stdlib: InitialGasSchedule::initial(),
+            table: InitialGasSchedule::initial(),
+            aptos_framework: InitialGasSchedule::initial(),
+        }
+    }
+}
diff --git a/aptos-move/aptos-gas-schedule/src/gas_schedule/move_stdlib.rs b/aptos-move/aptos-gas-schedule/src/gas_schedule/move_stdlib.rs
new file mode 100644
index 0000000000000..270243f37621c
--- /dev/null
+++ b/aptos-move/aptos-gas-schedule/src/gas_schedule/move_stdlib.rs
@@ -0,0 +1,35 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+//! This module defines the gas parameters for Move Stdlib.
+
+use crate::gas_schedule::NativeGasParameters;
+use aptos_gas_algebra::{InternalGas, InternalGasPerByte};
+
+crate::gas_schedule::macros::define_gas_parameters!(
+    MoveStdlibGasParameters,
+    "natives.move_stdlib",
+    NativeGasParameters => .move_stdlib,
+    [
+        [bcs_to_bytes_per_byte_serialized: InternalGasPerByte, "bcs.to_bytes.per_byte_serialized", 200],
+        [bcs_to_bytes_failure: InternalGas, "bcs.to_bytes.failure", 20000],
+
+        [hash_sha2_256_base: InternalGas, "hash.sha2_256.base", 60000],
+        [hash_sha2_256_per_byte: InternalGasPerByte, "hash.sha2_256.per_byte", 1000],
+        [hash_sha3_256_base: InternalGas, "hash.sha3_256.base", 80000],
+        [hash_sha3_256_per_byte: InternalGasPerByte, "hash.sha3_256.per_byte", 900],
+
+        // Note(Gas): this initial value is guesswork.
+        [signer_borrow_address_base: InternalGas, "signer.borrow_address.base", 4000],
+
+        // Note(Gas): these initial values are guesswork.
+        [string_check_utf8_base: InternalGas, "string.check_utf8.base", 6000],
+        [string_check_utf8_per_byte: InternalGasPerByte, "string.check_utf8.per_byte", 160],
+        [string_is_char_boundary_base: InternalGas, "string.is_char_boundary.base", 6000],
+        [string_sub_string_base: InternalGas, "string.sub_string.base", 8000],
+        [string_sub_string_per_byte: InternalGasPerByte, "string.sub_string.per_byte", 60],
+        [string_index_of_base: InternalGas, "string.index_of.base", 8000],
+        [string_index_of_per_byte_pattern: InternalGasPerByte, "string.index_of.per_byte_pattern", 400],
+        [string_index_of_per_byte_searched: InternalGasPerByte, "string.index_of.per_byte_searched", 200],
+    ]
+);
diff --git a/aptos-move/aptos-gas-schedule/src/gas_schedule/table.rs b/aptos-move/aptos-gas-schedule/src/gas_schedule/table.rs
new file mode 100644
index 0000000000000..305f6ddb1d96a
--- /dev/null
+++ b/aptos-move/aptos-gas-schedule/src/gas_schedule/table.rs
@@ -0,0 +1,38 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+//! This module defines the gas parameters for the table extension.
+
+use crate::gas_schedule::NativeGasParameters;
+use aptos_gas_algebra::{InternalGas, InternalGasPerByte};
+
+crate::gas_schedule::macros::define_gas_parameters!(
+    TableGasParameters,
+    "natives.table",
+    NativeGasParameters => .table,
+    [
+        // These are dummy value, they copied from storage gas in aptos-core/aptos-vm/src/aptos_vm_impl.rs
+        [common_load_base_legacy: InternalGas, "common.load.base", 8000],
+        [common_load_base_new: InternalGas, { 7.. => "common.load.base_new" }, 8000],
+        [common_load_per_byte: InternalGasPerByte, "common.load.per_byte", 1000],
+        [common_load_failure: InternalGas, "common.load.failure", 0],
+
+        [new_table_handle_base: InternalGas, "new_table_handle.base", 20000],
+
+        [add_box_base: InternalGas, "add_box.base", 24000],
+        [add_box_per_byte_serialized: InternalGasPerByte, "add_box.per_byte_serialized", 200],
+
+        [borrow_box_base: InternalGas, "borrow_box.base", 24000],
+        [borrow_box_per_byte_serialized: InternalGasPerByte, "borrow_box.per_byte_serialized", 200],
+
+        [contains_box_base: InternalGas, "contains_box.base", 24000],
+        [contains_box_per_byte_serialized: InternalGasPerByte, "contains_box.per_byte_serialized", 200],
+
+        [remove_box_base: InternalGas, "remove_box.base", 24000],
+        [remove_box_per_byte_serialized: InternalGasPerByte, "remove_box.per_byte_serialized", 200],
+
+        [destroy_empty_box_base: InternalGas, "destroy_empty_box.base", 24000],
+
+        [drop_unchecked_box_base: InternalGas, "drop_unchecked_box.base", 2000],
+    ]
+);
diff --git a/aptos-move/aptos-gas-schedule/src/gas_params/transaction.rs b/aptos-move/aptos-gas-schedule/src/gas_schedule/transaction.rs
similarity index 96%
rename from aptos-move/aptos-gas-schedule/src/gas_params/transaction.rs
rename to aptos-move/aptos-gas-schedule/src/gas_schedule/transaction.rs
index 3fb1b5bcb03a6..52a679082e827 100644
--- a/aptos-move/aptos-gas-schedule/src/gas_params/transaction.rs
+++ b/aptos-move/aptos-gas-schedule/src/gas_schedule/transaction.rs
@@ -1,7 +1,10 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
 //! This module defines all the gas parameters for transactions, along with their initial values
 //! in the genesis and a mapping between the Rust representation and the on-chain gas schedule.
 
-use crate::gas_params::AptosGasParameters;
+use crate::gas_schedule::VMGasParameters;
 use aptos_gas_algebra::{
     AbstractValueSize, Fee, FeePerByte, FeePerGasUnit, FeePerSlot, Gas, GasExpression,
     GasScalingFactor, GasUnit, NumSlots,
@@ -16,10 +19,10 @@ use move_core_types::gas_algebra::{
 
 const GAS_SCALING_FACTOR: u64 = 1_000_000;
 
-crate::gas_params::macros::define_gas_parameters!(
+crate::gas_schedule::macros::define_gas_parameters!(
     TransactionGasParameters,
     "txn",
-    .txn,
+    VMGasParameters => .txn,
     [
         // The flat minimum amount of gas required for any transaction.
         // Charged at the start of execution.
@@ -180,7 +183,7 @@ use gas_params::*;
 impl TransactionGasParameters {
     // TODO(Gas): Right now we are relying on this to avoid div by zero errors when using the all-zero
     //            gas parameters. See if there's a better way we can handle this.
-    pub(crate) fn scaling_factor(&self) -> GasScalingFactor {
+    pub fn scaling_factor(&self) -> GasScalingFactor {
         match u64::from(self.gas_unit_scaling_factor) {
             0 => 1.into(),
             x => x.into(),
@@ -232,7 +235,7 @@ impl TransactionGasParameters {
     pub fn calculate_intrinsic_gas(
         &self,
         transaction_size: NumBytes,
-    ) -> impl GasExpression<AptosGasParameters, Unit = InternalGasUnit> {
+    ) -> impl GasExpression<VMGasParameters, Unit = InternalGasUnit> {
         let excess = transaction_size
             .checked_sub(self.large_transaction_cutoff)
             .unwrap_or_else(|| 0.into());
diff --git a/aptos-move/aptos-gas-schedule/src/lib.rs b/aptos-move/aptos-gas-schedule/src/lib.rs
index 77e22108326ce..910ff1c5a84e7 100644
--- a/aptos-move/aptos-gas-schedule/src/lib.rs
+++ b/aptos-move/aptos-gas-schedule/src/lib.rs
@@ -1,10 +1,35 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-mod gas_params;
+//! This crate defines all the gas parameters utilized by the Aptos VM & native functions.
+//! It also provides traits for conversion between different representations.
+//!
+//! To define a new gas parameter, simply add a new entry to the appropriate file in the
+//! `src/gas_schedule` sub-directory. You will need to provide:
+//!
+//!   1. A name for the gas parameter. By convention, the name should be prefixed with the
+//!      operation (instruction, native function etc.) it is associated with, and be
+//!      descriptive of what it is about.
+//!
+//!   2. The type of the gas parameter, which should be a quantity with a specific unit.
+//!      The strong typing helps prevent common programming mistakes.
+//!
+//!   3. The on-chain name(s) of the gas parameter. You can express multi-versioned views
+//!      using the pattern match syntax, allowing the removal or renaming of gas parameters
+//!      in the on-chain gas schedule.
+//!
+//!   4. The current value of the gas parameter. This is used for testing & generating
+//!      gas schedule update proposals. Keep in mind that the value will only take effect
+//!      on chain after an update proposal including it has been applied.
+//!
+//!
+//! The generation macro will automatically generate a struct type representing the gas parameter,
+//! which can be then used in gas expressions once imported.
+
+mod gas_schedule;
 mod traits;
 mod ver;
 
-pub use gas_params::*;
+pub use gas_schedule::*;
 pub use traits::{FromOnChainGasSchedule, InitialGasSchedule, ToOnChainGasSchedule};
 pub use ver::LATEST_GAS_FEATURE_VERSION;
diff --git a/aptos-move/aptos-gas-schedule/src/ver.rs b/aptos-move/aptos-gas-schedule/src/ver.rs
index 5c30ebd932c2a..f7de84dcb0653 100644
--- a/aptos-move/aptos-gas-schedule/src/ver.rs
+++ b/aptos-move/aptos-gas-schedule/src/ver.rs
@@ -1,36 +1,40 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-// Change log:
-// - V10
-//   - Added generate_unique_address and get_txn_hash native functions
-//   - Storage gas charges (excluding "storage fees") stop respecting the storage gas curves
-// - V9
-//   - Accurate tracking of the cost of loading resource groups
-// - V8
-//   - Added BLS12-381 operations.
-// - V7
+/// Integer representing the latest gas feature version.
+/// The general rule is that this should bumped exactly once after each release, provided there
+/// exists some gas related changes.
+///
+/// Change log:
+/// - V10
+///   - Added generate_unique_address and get_txn_hash native functions
+///   - Storage gas charges (excluding "storage fees") stop respecting the storage gas curves
+/// - V9
+///   - Accurate tracking of the cost of loading resource groups
+/// - V8
+///   - Added BLS12-381 operations.
+/// - V7
 //   - Native support for exists<T>
-//   - New formulae for storage fees based on fixed APT costs
-//   - Lower gas price (other than the newly introduced storage fees) by upping the scaling factor
-// - V6
-//   - Added a new native function - blake2b_256.
-// - V5
-//   - u16, u32, u256
-//   - free_write_bytes_quota
-//   - configurable ChangeSetConfigs
-// - V4
-//   - Consider memory leaked for event natives
-// - V3
-//   - Add memory quota
-//   - Storage charges:
-//     - Distinguish between new and existing resources
-//     - One item write comes with 1K free bytes
-//     - abort with STORAGE_WRITE_LIMIT_REACHED if WriteOps or Events are too large
-// - V2
-//   - Table
-//     - Fix the gas formula for loading resources so that they are consistent with other
-//       global operations.
-// - V1
-//   - TBA
+///   - New formulae for storage fees based on fixed APT costs
+///   - Lower gas price (other than the newly introduced storage fees) by upping the scaling factor
+/// - V6
+///   - Added a new native function - blake2b_256.
+/// - V5
+///   - u16, u32, u256
+////   - free_write_bytes_quota
+///   - configurable ChangeSetConfigs
+/// - V4
+///   - Consider memory leaked for event natives
+/// - V3
+///   - Add memory quota
+///   - Storage charges:
+///     - Distinguish between new and existing resources
+///     - One item write comes with 1K free bytes
+///     - abort with STORAGE_WRITE_LIMIT_REACHED if WriteOps or Events are too large
+/// - V2
+///   - Table
+///     - Fix the gas formula for loading resources so that they are consistent with other
+///       global operations.
+/// - V1
+///   - TBA
 pub const LATEST_GAS_FEATURE_VERSION: u64 = 10;
diff --git a/aptos-move/aptos-gas/src/aptos_framework.rs b/aptos-move/aptos-gas/src/aptos_framework.rs
deleted file mode 100644
index 550f4e490d1ef..0000000000000
--- a/aptos-move/aptos-gas/src/aptos_framework.rs
+++ /dev/null
@@ -1,193 +0,0 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::gas_meter::EXECUTION_GAS_MULTIPLIER as MUL;
-use aptos_framework::natives::GasParameters;
-
-crate::natives::define_gas_parameters_for_natives!(GasParameters, "aptos_framework", [
-    [.account.create_address.base, "account.create_address.base", 300 * MUL],
-    [.account.create_signer.base, "account.create_signer.base", 300 * MUL],
-
-    // Algebra gas parameters begin.
-    // Generated at time 1680606720.0709136 by `scripts/algebra-gas/update_algebra_gas_params.py` with gas_per_ns=10.23.
-    [.algebra.ark_bls12_381_fq12_add, { 8.. => "algebra.ark_bls12_381_fq12_add" }, 1_819 * MUL],
-    [.algebra.ark_bls12_381_fq12_clone, { 8.. => "algebra.ark_bls12_381_fq12_clone" }, 211 * MUL],
-    [.algebra.ark_bls12_381_fq12_deser, { 8.. => "algebra.ark_bls12_381_fq12_deser" }, 11_180 * MUL],
-    [.algebra.ark_bls12_381_fq12_div, { 8.. => "algebra.ark_bls12_381_fq12_div" }, 250_813 * MUL],
-    [.algebra.ark_bls12_381_fq12_eq, { 8.. => "algebra.ark_bls12_381_fq12_eq" }, 726 * MUL],
-    [.algebra.ark_bls12_381_fq12_from_u64, { 8.. => "algebra.ark_bls12_381_fq12_from_u64" }, 901 * MUL],
-    [.algebra.ark_bls12_381_fq12_inv, { 8.. => "algebra.ark_bls12_381_fq12_inv" }, 200_523 * MUL],
-    [.algebra.ark_bls12_381_fq12_mul, { 8.. => "algebra.ark_bls12_381_fq12_mul" }, 49_886 * MUL],
-    [.algebra.ark_bls12_381_fq12_neg, { 8.. => "algebra.ark_bls12_381_fq12_neg" }, 1_181 * MUL],
-    [.algebra.ark_bls12_381_fq12_one, { 8.. => "algebra.ark_bls12_381_fq12_one" }, 11 * MUL],
-    [.algebra.ark_bls12_381_fq12_pow_u256, { 8.. => "algebra.ark_bls12_381_fq12_pow_u256" }, 14_664_207 * MUL],
-    [.algebra.ark_bls12_381_fq12_serialize, { 8.. => "algebra.ark_bls12_381_fq12_serialize" }, 8_078 * MUL],
-    [.algebra.ark_bls12_381_fq12_square, { 8.. => "algebra.ark_bls12_381_fq12_square" }, 35_145 * MUL],
-    [.algebra.ark_bls12_381_fq12_sub, { 8.. => "algebra.ark_bls12_381_fq12_sub" }, 1_758 * MUL],
-    [.algebra.ark_bls12_381_fq12_zero, { 8.. => "algebra.ark_bls12_381_fq12_zero" }, 211 * MUL],
-    [.algebra.ark_bls12_381_fr_add, { 8.. => "algebra.ark_bls12_381_fr_add" }, 211 * MUL],
-    [.algebra.ark_bls12_381_fr_deser, { 8.. => "algebra.ark_bls12_381_fr_deser" }, 752 * MUL],
-    [.algebra.ark_bls12_381_fr_div, { 8.. => "algebra.ark_bls12_381_fr_div" }, 59_440 * MUL],
-    [.algebra.ark_bls12_381_fr_eq, { 8.. => "algebra.ark_bls12_381_fr_eq" }, 212 * MUL],
-    [.algebra.ark_bls12_381_fr_from_u64, { 8.. => "algebra.ark_bls12_381_fr_from_u64" }, 494 * MUL],
-    [.algebra.ark_bls12_381_fr_inv, { 8.. => "algebra.ark_bls12_381_fr_inv" }, 58_610 * MUL],
-    [.algebra.ark_bls12_381_fr_mul, { 8.. => "algebra.ark_bls12_381_fr_mul" }, 502 * MUL],
-    [.algebra.ark_bls12_381_fr_neg, { 8.. => "algebra.ark_bls12_381_fr_neg" }, 213 * MUL],
-    [.algebra.ark_bls12_381_fr_one, { 8.. => "algebra.ark_bls12_381_fr_one" }, 211 * MUL],
-    [.algebra.ark_bls12_381_fr_serialize, { 8.. => "algebra.ark_bls12_381_fr_serialize" }, 1_103 * MUL],
-    [.algebra.ark_bls12_381_fr_square, { 8.. => "algebra.ark_bls12_381_fr_square" }, 475 * MUL],
-    [.algebra.ark_bls12_381_fr_sub, { 8.. => "algebra.ark_bls12_381_fr_sub" }, 290 * MUL],
-    [.algebra.ark_bls12_381_fr_zero, { 8.. => "algebra.ark_bls12_381_fr_zero" }, 211 * MUL],
-    [.algebra.ark_bls12_381_g1_affine_deser_comp, { 8.. => "algebra.ark_bls12_381_g1_affine_deser_comp" }, 1_029_599 * MUL],
-    [.algebra.ark_bls12_381_g1_affine_deser_uncomp, { 8.. => "algebra.ark_bls12_381_g1_affine_deser_uncomp" }, 720_638 * MUL],
-    [.algebra.ark_bls12_381_g1_affine_serialize_comp, { 8.. => "algebra.ark_bls12_381_g1_affine_serialize_comp" }, 2_014 * MUL],
-    [.algebra.ark_bls12_381_g1_affine_serialize_uncomp, { 8.. => "algebra.ark_bls12_381_g1_affine_serialize_uncomp" }, 2_433 * MUL],
-    [.algebra.ark_bls12_381_g1_proj_add, { 8.. => "algebra.ark_bls12_381_g1_proj_add" }, 10_806 * MUL],
-    [.algebra.ark_bls12_381_g1_proj_double, { 8.. => "algebra.ark_bls12_381_g1_proj_double" }, 5_264 * MUL],
-    [.algebra.ark_bls12_381_g1_proj_eq, { 8.. => "algebra.ark_bls12_381_g1_proj_eq" }, 5_035 * MUL],
-    [.algebra.ark_bls12_381_g1_proj_generator, { 8.. => "algebra.ark_bls12_381_g1_proj_generator" }, 11 * MUL],
-    [.algebra.ark_bls12_381_g1_proj_infinity, { 8.. => "algebra.ark_bls12_381_g1_proj_infinity" }, 11 * MUL],
-    [.algebra.ark_bls12_381_g1_proj_neg, { 8.. => "algebra.ark_bls12_381_g1_proj_neg" }, 11 * MUL],
-    [.algebra.ark_bls12_381_g1_proj_scalar_mul, { 8.. => "algebra.ark_bls12_381_g1_proj_scalar_mul" }, 2_523_521 * MUL],
-    [.algebra.ark_bls12_381_g1_proj_sub, { 8.. => "algebra.ark_bls12_381_g1_proj_sub" }, 11_147 * MUL],
-    [.algebra.ark_bls12_381_g1_proj_to_affine, { 8.. => "algebra.ark_bls12_381_g1_proj_to_affine" }, 121_035 * MUL],
-    [.algebra.ark_bls12_381_g2_affine_deser_comp, { 8.. => "algebra.ark_bls12_381_g2_affine_deser_comp" }, 2_060_068 * MUL],
-    [.algebra.ark_bls12_381_g2_affine_deser_uncomp, { 8.. => "algebra.ark_bls12_381_g2_affine_deser_uncomp" }, 1_017_979 * MUL],
-    [.algebra.ark_bls12_381_g2_affine_serialize_comp, { 8.. => "algebra.ark_bls12_381_g2_affine_serialize_comp" }, 3_378 * MUL],
-    [.algebra.ark_bls12_381_g2_affine_serialize_uncomp, { 8.. => "algebra.ark_bls12_381_g2_affine_serialize_uncomp" }, 4_217 * MUL],
-    [.algebra.ark_bls12_381_g2_proj_add, { 8.. => "algebra.ark_bls12_381_g2_proj_add" }, 32_401 * MUL],
-    [.algebra.ark_bls12_381_g2_proj_double, { 8.. => "algebra.ark_bls12_381_g2_proj_double" }, 14_839 * MUL],
-    [.algebra.ark_bls12_381_g2_proj_eq, { 8.. => "algebra.ark_bls12_381_g2_proj_eq" }, 15_155 * MUL],
-    [.algebra.ark_bls12_381_g2_proj_generator, { 8.. => "algebra.ark_bls12_381_g2_proj_generator" }, 11 * MUL],
-    [.algebra.ark_bls12_381_g2_proj_infinity, { 8.. => "algebra.ark_bls12_381_g2_proj_infinity" }, 11 * MUL],
-    [.algebra.ark_bls12_381_g2_proj_neg, { 8.. => "algebra.ark_bls12_381_g2_proj_neg" }, 11 * MUL],
-    [.algebra.ark_bls12_381_g2_proj_scalar_mul, { 8.. => "algebra.ark_bls12_381_g2_proj_scalar_mul" }, 7_526_508 * MUL],
-    [.algebra.ark_bls12_381_g2_proj_sub, { 8.. => "algebra.ark_bls12_381_g2_proj_sub" }, 32_869 * MUL],
-    [.algebra.ark_bls12_381_g2_proj_to_affine, { 8.. => "algebra.ark_bls12_381_g2_proj_to_affine" }, 128_857 * MUL],
-    [.algebra.ark_bls12_381_multi_pairing_base, { 8.. => "algebra.ark_bls12_381_multi_pairing_base" }, 8_998_649 * MUL],
-    [.algebra.ark_bls12_381_multi_pairing_per_pair, { 8.. => "algebra.ark_bls12_381_multi_pairing_per_pair" }, 4_602_642 * MUL],
-    [.algebra.ark_bls12_381_pairing, { 8.. => "algebra.ark_bls12_381_pairing" }, 14_832_220 * MUL],
-    [.algebra.ark_h2c_bls12381g1_xmd_sha256_sswu_base, { 8.. => "algebra.ark_h2c_bls12381g1_xmd_sha256_sswu_base" }, 3_251_943 * MUL],
-    [.algebra.ark_h2c_bls12381g1_xmd_sha256_sswu_per_msg_byte, { 8.. => "algebra.ark_h2c_bls12381g1_xmd_sha256_sswu_per_msg_byte" }, 48 * MUL],
-    [.algebra.ark_h2c_bls12381g2_xmd_sha256_sswu_base, { 8.. => "algebra.ark_h2c_bls12381g2_xmd_sha256_sswu_base" }, 6_773_002 * MUL],
-    [.algebra.ark_h2c_bls12381g2_xmd_sha256_sswu_per_msg_byte, { 8.. => "algebra.ark_h2c_bls12381g2_xmd_sha256_sswu_per_msg_byte" }, 48 * MUL],
-    // Algebra gas parameters end.
-
-    [.bls12381.base, "bls12381.base", 150 * MUL],
-
-    [.bls12381.per_pubkey_deserialize, "bls12381.per_pubkey_deserialize", 109_000 * MUL],
-    [.bls12381.per_pubkey_aggregate, "bls12381.per_pubkey_aggregate", 4_200 * MUL],
-    [.bls12381.per_pubkey_subgroup_check, "bls12381.per_pubkey_subgroup_check", 370_000 * MUL],
-
-    [.bls12381.per_sig_deserialize, "bls12381.per_sig_deserialize", 222_000 * MUL],
-    [.bls12381.per_sig_aggregate, "bls12381.per_sig_aggregate", 11_650 * MUL],
-    [.bls12381.per_sig_subgroup_check, "bls12381.per_sig_subgroup_check", 460_500 * MUL],
-
-    [.bls12381.per_sig_verify, "bls12381.per_sig_verify", 8_485_000 * MUL],
-    [.bls12381.per_pop_verify, "bls12381.per_pop_verify", 10_300_000 * MUL],
-
-    [.bls12381.per_pairing, "bls12381.per_pairing", 4_013_000 * MUL],
-
-    [.bls12381.per_msg_hashing, "bls12381.per_msg_hashing", 1_540_000 * MUL],
-    [.bls12381.per_byte_hashing, "bls12381.per_byte_hashing", 50 * MUL],
-
-    [.ed25519.base, "signature.base", 150 * MUL],
-    [.ed25519.per_pubkey_deserialize, "signature.per_pubkey_deserialize", 38_000 * MUL],
-    [.ed25519.per_pubkey_small_order_check, "signature.per_pubkey_small_order_check", 6_350 * MUL],
-    [.ed25519.per_sig_deserialize, "signature.per_sig_deserialize", 375 * MUL],
-    [.ed25519.per_sig_strict_verify, "signature.per_sig_strict_verify", 267_000 * MUL],
-    [.ed25519.per_msg_hashing_base, "signature.per_msg_hashing_base", 3_240 * MUL],
-    [.ed25519.per_msg_byte_hashing, "signature.per_msg_byte_hashing", 60 * MUL],
-
-    [.secp256k1.base, "secp256k1.base", 150 * MUL],
-    [.secp256k1.ecdsa_recover, "secp256k1.ecdsa_recover", 1_610_000 * MUL],
-
-    [.ristretto255.basepoint_mul, "ristretto255.basepoint_mul", 128_000 * MUL],
-    [.ristretto255.basepoint_double_mul, "ristretto255.basepoint_double_mul", 440_000 * MUL],
-
-    [.ristretto255.point_add, "ristretto255.point_add", 2_135 * MUL],
-    [.ristretto255.point_compress, "ristretto255.point_compress", 40_000 * MUL],
-    [.ristretto255.point_decompress, "ristretto255.point_decompress", 40_500 * MUL],
-    [.ristretto255.point_equals, "ristretto255.point_equals", 2_300 * MUL],
-    [.ristretto255.point_from_64_uniform_bytes, "ristretto255.point_from_64_uniform_bytes", 81_500 * MUL],
-    [.ristretto255.point_identity, "ristretto255.point_identity", 150 * MUL],
-    [.ristretto255.point_mul, "ristretto255.point_mul", 471_000 * MUL],
-    [.ristretto255.point_neg, "ristretto255.point_neg", 360 * MUL],
-    [.ristretto255.point_sub, "ristretto255.point_sub", 2_130 * MUL],
-    [.ristretto255.point_parse_arg, "ristretto255.point_parse_arg", 150 * MUL],
-
-
-    // TODO(Alin): These SHA512 gas costs could be unified with the costs in our future SHA512 module
-    // (assuming same implementation complexity, which might not be the case
-    [.ristretto255.sha512_per_byte, "ristretto255.scalar_sha512_per_byte", 60 * MUL],
-    [.ristretto255.sha512_per_hash, "ristretto255.scalar_sha512_per_hash", 3_240 * MUL],
-
-    [.ristretto255.scalar_add, "ristretto255.scalar_add", 770 * MUL],
-    [.ristretto255.scalar_reduced_from_32_bytes, "ristretto255.scalar_reduced_from_32_bytes", 710 * MUL],
-    [.ristretto255.scalar_uniform_from_64_bytes, "ristretto255.scalar_uniform_from_64_bytes", 1_245 * MUL],
-    [.ristretto255.scalar_from_u128, "ristretto255.scalar_from_u128", 175 * MUL],
-    [.ristretto255.scalar_from_u64, "ristretto255.scalar_from_u64", 175 * MUL],
-    [.ristretto255.scalar_invert, "ristretto255.scalar_invert", 110_000 * MUL],
-    [.ristretto255.scalar_is_canonical, "ristretto255.scalar_is_canonical", 1_150 * MUL],
-    [.ristretto255.scalar_mul, "ristretto255.scalar_mul", 1_065 * MUL],
-    [.ristretto255.scalar_neg, "ristretto255.scalar_neg", 725 * MUL],
-    [.ristretto255.scalar_sub, "ristretto255.scalar_sub", 1_060 * MUL],
-    [.ristretto255.scalar_parse_arg, "ristretto255.scalar_parse_arg", 150 * MUL],
-
-    [.hash.sip_hash.base, "hash.sip_hash.base", 1000 * MUL],
-    [.hash.sip_hash.per_byte, "hash.sip_hash.per_byte", 20 * MUL],
-
-    [.hash.keccak256.base, { 1.. => "hash.keccak256.base" }, 4000 * MUL],
-    [.hash.keccak256.per_byte, { 1.. => "hash.keccak256.per_byte" }, 45 * MUL],
-
-    [.type_info.type_of.base, "type_info.type_of.base", 300 * MUL],
-    // TODO(Gas): the on-chain name is wrong...
-    [.type_info.type_of.per_byte_in_str, "type_info.type_of.per_abstract_memory_unit", 5 * MUL],
-    [.type_info.type_name.base, "type_info.type_name.base", 300 * MUL],
-    // TODO(Gas): the on-chain name is wrong...
-    [.type_info.type_name.per_byte_in_str, "type_info.type_name.per_abstract_memory_unit", 5 * MUL],
-    [.type_info.chain_id.base, { 4.. => "type_info.chain_id.base" }, 150 * MUL],
-
-    // Reusing SHA2-512's cost from Ristretto
-    [.hash.sha2_512.base, { 4.. => "hash.sha2_512.base" }, 3_240],
-    [.hash.sha2_512.per_byte, { 4.. => "hash.sha2_512.per_byte" }, 60],
-    // Back-of-the-envelop approximation from SHA3-256's (4000 base, 45 per-byte) costs
-    [.hash.sha3_512.base, { 4.. => "hash.sha3_512.base" }, 4_500],
-    [.hash.sha3_512.per_byte, { 4.. => "hash.sha3_512.per_byte" }, 50],
-    // Using SHA2-256's cost
-    [.hash.ripemd160.base, { 4.. => "hash.ripemd160.base" }, 3000],
-    [.hash.ripemd160.per_byte, { 4.. => "hash.ripemd160.per_byte" }, 50],
-    [.hash.blake2b_256.base, { 6.. => "hash.blake2b_256.base" }, 1750],
-    [.hash.blake2b_256.per_byte, { 6.. => "hash.blake2b_256.per_byte" }, 15],
-
-    [.util.from_bytes.base, "util.from_bytes.base", 300 * MUL],
-    [.util.from_bytes.per_byte, "util.from_bytes.per_byte", 5 * MUL],
-
-    [.transaction_context.get_txn_hash.base, { 10.. => "transaction_context.get_txn_hash.base" }, 200 * MUL],
-    [.transaction_context.get_script_hash.base, "transaction_context.get_script_hash.base", 200 * MUL],
-    // Based on SHA3-256's cost
-    [.transaction_context.generate_unique_address.base, { 10.. => "transaction_context.generate_unique_address.base" }, 4000 * MUL],
-
-    [.code.request_publish.base, "code.request_publish.base", 500 * MUL],
-    [.code.request_publish.per_byte, "code.request_publish.per_byte", 2 * MUL],
-
-    // Note(Gas): These are storage operations so the values should not be multiplied.
-    [.event.write_to_event_store.base, "event.write_to_event_store.base", 300_000],
-    // TODO(Gas): the on-chain name is wrong...
-    [.event.write_to_event_store.per_abstract_value_unit, "event.write_to_event_store.per_abstract_memory_unit", 5_000],
-
-    [.state_storage.get_usage.base_cost, "state_storage.get_usage.base", 500 * MUL],
-
-    [.aggregator.add.base, "aggregator.add.base", 300 * MUL],
-    [.aggregator.read.base, "aggregator.read.base", 300 * MUL],
-    [.aggregator.sub.base, "aggregator.sub.base", 300 * MUL],
-    [.aggregator.destroy.base, "aggregator.destroy.base", 500 * MUL],
-    [.aggregator_factory.new_aggregator.base, "aggregator_factory.new_aggregator.base", 500 * MUL],
-
-    [.object.exists_at.base, { 7.. => "object.exists_at.base" }, 250 * MUL],
-    // These are dummy value, they copied from storage gas in aptos-core/aptos-vm/src/aptos_vm_impl.rs
-    [.object.exists_at.per_byte_loaded, { 7.. => "object.exists_at.per_byte_loaded" }, 1000],
-    [.object.exists_at.per_item_loaded, { 7.. => "object.exists_at.per_item_loaded" }, 8000],
-    [.string_utils.base, {8.. => "string_utils.format.base"}, 300 * MUL],
-    [.string_utils.per_byte, {8.. =>"string_utils.format.per_byte"}, MUL],
-]);
diff --git a/aptos-move/aptos-gas/src/gas_meter.rs b/aptos-move/aptos-gas/src/gas_meter.rs
deleted file mode 100644
index f0b492e7323b0..0000000000000
--- a/aptos-move/aptos-gas/src/gas_meter.rs
+++ /dev/null
@@ -1,1019 +0,0 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
-//! This module contains the official gas meter implementation, along with some top-level gas
-//! parameters and traits to help manipulate them.
-
-use aptos_gas_algebra::{Fee, FeePerGasUnit, Gas, GasExpression, GasScalingFactor, Octa};
-use aptos_gas_schedule::{
-    instr_gas_params::*, txn_gas_params::*, FromOnChainGasSchedule, InitialGasSchedule,
-    InstructionGasParameters, MiscGasParameters, StorageGasParameters, ToOnChainGasSchedule,
-    TransactionGasParameters,
-};
-use aptos_logger::error;
-use aptos_types::{
-    contract_event::ContractEvent, state_store::state_key::StateKey, write_set::WriteOp,
-};
-use move_binary_format::{
-    errors::{Location, PartialVMError, PartialVMResult, VMResult},
-    file_format::CodeOffset,
-};
-use move_core_types::{
-    account_address::AccountAddress,
-    gas_algebra::{InternalGas, InternalGasUnit, NumArgs, NumBytes},
-    language_storage::ModuleId,
-    vm_status::StatusCode,
-};
-use move_vm_types::{
-    gas::{GasMeter as MoveGasMeter, SimpleInstruction},
-    views::{TypeView, ValueView},
-};
-use std::collections::BTreeMap;
-
-pub(crate) const EXECUTION_GAS_MULTIPLIER: u64 = 20;
-
-/// Gas parameters for all native functions.
-#[derive(Debug, Clone)]
-pub struct NativeGasParameters {
-    pub move_stdlib: aptos_move_stdlib::natives::GasParameters,
-    pub aptos_framework: aptos_framework::natives::GasParameters,
-    pub table: move_table_extension::GasParameters,
-}
-
-impl FromOnChainGasSchedule for NativeGasParameters {
-    fn from_on_chain_gas_schedule(
-        gas_schedule: &BTreeMap<String, u64>,
-        feature_version: u64,
-    ) -> Result<Self, String> {
-        Ok(Self {
-            move_stdlib: FromOnChainGasSchedule::from_on_chain_gas_schedule(
-                gas_schedule,
-                feature_version,
-            )?,
-            aptos_framework: FromOnChainGasSchedule::from_on_chain_gas_schedule(
-                gas_schedule,
-                feature_version,
-            )?,
-            table: FromOnChainGasSchedule::from_on_chain_gas_schedule(
-                gas_schedule,
-                feature_version,
-            )?,
-        })
-    }
-}
-
-impl ToOnChainGasSchedule for NativeGasParameters {
-    fn to_on_chain_gas_schedule(&self, feature_version: u64) -> Vec<(String, u64)> {
-        let mut entries = self.move_stdlib.to_on_chain_gas_schedule(feature_version);
-        entries.extend(
-            self.aptos_framework
-                .to_on_chain_gas_schedule(feature_version),
-        );
-        entries.extend(self.table.to_on_chain_gas_schedule(feature_version));
-        entries
-    }
-}
-
-impl NativeGasParameters {
-    pub fn zeros() -> Self {
-        Self {
-            move_stdlib: aptos_move_stdlib::natives::GasParameters::zeros(),
-            aptos_framework: aptos_framework::natives::GasParameters::zeros(),
-            table: move_table_extension::GasParameters::zeros(),
-        }
-    }
-}
-
-impl InitialGasSchedule for NativeGasParameters {
-    fn initial() -> Self {
-        Self {
-            move_stdlib: InitialGasSchedule::initial(),
-            aptos_framework: InitialGasSchedule::initial(),
-            table: InitialGasSchedule::initial(),
-        }
-    }
-}
-
-/// Gas parameters for everything that is needed to run the Aptos blockchain, including
-/// instructions, transactions and native functions from various packages.
-#[derive(Debug, Clone)]
-pub struct AptosGasParameters {
-    pub misc: MiscGasParameters,
-    pub instr: InstructionGasParameters,
-    pub txn: TransactionGasParameters,
-    pub natives: NativeGasParameters,
-}
-
-impl FromOnChainGasSchedule for AptosGasParameters {
-    fn from_on_chain_gas_schedule(
-        gas_schedule: &BTreeMap<String, u64>,
-        feature_version: u64,
-    ) -> Result<Self, String> {
-        Ok(Self {
-            misc: FromOnChainGasSchedule::from_on_chain_gas_schedule(
-                gas_schedule,
-                feature_version,
-            )?,
-            instr: FromOnChainGasSchedule::from_on_chain_gas_schedule(
-                gas_schedule,
-                feature_version,
-            )?,
-            txn: FromOnChainGasSchedule::from_on_chain_gas_schedule(gas_schedule, feature_version)?,
-            natives: FromOnChainGasSchedule::from_on_chain_gas_schedule(
-                gas_schedule,
-                feature_version,
-            )?,
-        })
-    }
-}
-
-impl ToOnChainGasSchedule for AptosGasParameters {
-    fn to_on_chain_gas_schedule(&self, feature_version: u64) -> Vec<(String, u64)> {
-        let mut entries = self.instr.to_on_chain_gas_schedule(feature_version);
-        entries.extend(self.txn.to_on_chain_gas_schedule(feature_version));
-        entries.extend(self.natives.to_on_chain_gas_schedule(feature_version));
-        entries.extend(self.misc.to_on_chain_gas_schedule(feature_version));
-        entries
-    }
-}
-
-impl AptosGasParameters {
-    pub fn zeros() -> Self {
-        Self {
-            misc: MiscGasParameters::zeros(),
-            instr: InstructionGasParameters::zeros(),
-            txn: TransactionGasParameters::zeros(),
-            natives: NativeGasParameters::zeros(),
-        }
-    }
-}
-
-impl InitialGasSchedule for AptosGasParameters {
-    fn initial() -> Self {
-        Self {
-            misc: InitialGasSchedule::initial(),
-            instr: InitialGasSchedule::initial(),
-            txn: InitialGasSchedule::initial(),
-            natives: InitialGasSchedule::initial(),
-        }
-    }
-}
-
-/// Trait representing a gas meter used inside the Aptos VM.
-///
-/// It extends Move VM's `GasMeter` trait with a few Aptos-specific callbacks, along with
-/// some primitives that would allow gas meters to be composable.
-pub trait AptosGasMeter: MoveGasMeter {
-    type Algebra: GasAlgebra;
-
-    /// Returns a reference to the underlying algebra object.
-    fn algebra(&self) -> &Self::Algebra;
-
-    /// Returns a mutable reference to the underlying algebra object.
-    fn algebra_mut(&mut self) -> &mut Self::Algebra;
-
-    /// Charges fee for utilizing short-term or long-term storage.
-    ///
-    /// Since the fee is measured in APT/Octa, it needs to be converted into gas units
-    /// according to the given unit price.
-    fn charge_storage_fee(
-        &mut self,
-        amount: Fee,
-        gas_unit_price: FeePerGasUnit,
-    ) -> PartialVMResult<()>;
-
-    /// Charges an intrinsic cost for executing the transaction.
-    ///
-    /// The cost stays constant for transactions below a certain size, but will grow proportionally
-    /// for bigger ones.
-    fn charge_intrinsic_gas_for_transaction(&mut self, txn_size: NumBytes) -> VMResult<()>;
-
-    /// Charges IO gas for an item in the write set.
-    ///
-    /// This is to be differentiated from the storage fee, which is meant to cover the long-term
-    /// storage costs.
-    fn charge_io_gas_for_write(&mut self, key: &StateKey, op: &WriteOp) -> VMResult<()>;
-
-    /// Calculates the storage fee for a write operation.
-    fn storage_fee_per_write(&self, key: &StateKey, op: &WriteOp) -> Fee;
-
-    /// Calculates the storage fee for an event.
-    fn storage_fee_per_event(&self, event: &ContractEvent) -> Fee;
-
-    /// Calculates the discount applied to the event storage fees, based on a free quota.
-    fn storage_discount_for_events(&self, total_cost: Fee) -> Fee;
-
-    /// Calculates the storage fee for the transaction.
-    fn storage_fee_for_transaction_storage(&self, txn_size: NumBytes) -> Fee;
-
-    /// Charges the storage fees for writes, events & txn storage in a lump sum, minimizing the
-    /// loss of precision.
-    ///
-    /// The contract requires that this function behaviors in a way that is consistent to
-    /// the ones defining the costs.
-    /// Due to this reason, you should normally not override the default implementation,
-    /// unless you are doing something special, such as injecting additional logging logic.
-    fn charge_storage_fee_for_all<'a>(
-        &mut self,
-        write_ops: impl IntoIterator<Item = (&'a StateKey, &'a WriteOp)>,
-        events: impl IntoIterator<Item = &'a ContractEvent>,
-        txn_size: NumBytes,
-        gas_unit_price: FeePerGasUnit,
-    ) -> VMResult<()> {
-        // The new storage fee are only active since version 7.
-        if self.feature_version() < 7 {
-            return Ok(());
-        }
-
-        // TODO(Gas): right now, some of our tests use a unit price of 0 and this is a hack
-        // to avoid causing them issues. We should revisit the problem and figure out a
-        // better way to handle this.
-        if gas_unit_price.is_zero() {
-            return Ok(());
-        }
-
-        // Calculate the storage fees.
-        let write_fee = write_ops.into_iter().fold(Fee::new(0), |acc, (key, op)| {
-            acc + self.storage_fee_per_write(key, op)
-        });
-        let event_fee = events.into_iter().fold(Fee::new(0), |acc, event| {
-            acc + self.storage_fee_per_event(event)
-        });
-        let event_discount = self.storage_discount_for_events(event_fee);
-        let event_net_fee = event_fee
-            .checked_sub(event_discount)
-            .expect("discount should always be less than or equal to total amount");
-        let txn_fee = self.storage_fee_for_transaction_storage(txn_size);
-        let fee = write_fee + event_net_fee + txn_fee;
-
-        self.charge_storage_fee(fee, gas_unit_price)
-            .map_err(|err| err.finish(Location::Undefined))?;
-
-        Ok(())
-    }
-
-    // Below are getters reexported from the gas algebra.
-    // Gas meter instances should not reimplement these themselves.
-
-    /// Returns the gas feature version.
-    fn feature_version(&self) -> u64 {
-        self.algebra().feature_version()
-    }
-
-    /// Returns the struct that contains all (non-storage) gas parameters.
-    fn gas_params(&self) -> &AptosGasParameters {
-        self.algebra().gas_params()
-    }
-
-    // Returns a reference to the struct containing all storage gas parameters.
-    fn storage_gas_params(&self) -> &StorageGasParameters {
-        self.algebra().storage_gas_params()
-    }
-
-    /// Returns the remaining balance, measured in (external) gas units.
-    ///
-    /// The number should be rounded down when converting from internal to external gas units.
-    fn balance(&self) -> Gas {
-        self.algebra()
-            .balance_internal()
-            .to_unit_round_down_with_params(&self.gas_params().txn)
-    }
-
-    /// Returns the scaling factor between internal and external gas units.
-    fn gas_unit_scaling_factor(&self) -> GasScalingFactor {
-        self.algebra().gas_params().txn.scaling_factor()
-    }
-
-    /// Return the total gas used for execution.
-    fn execution_gas_used(&self) -> Gas {
-        self.algebra()
-            .execution_gas_used()
-            .to_unit_round_up_with_params(&self.gas_params().txn)
-    }
-
-    /// Return the total gas used for io.
-    fn io_gas_used(&self) -> Gas {
-        self.algebra()
-            .io_gas_used()
-            .to_unit_round_up_with_params(&self.gas_params().txn)
-    }
-
-    /// Return the total gas used for storage.
-    fn storage_fee_used_in_gas_units(&self) -> Gas {
-        self.algebra()
-            .storage_fee_used_in_gas_units()
-            .to_unit_round_up_with_params(&self.gas_params().txn)
-    }
-
-    /// Return the total fee used for storage.
-    fn storage_fee_used(&self) -> Fee {
-        self.algebra().storage_fee_used()
-    }
-}
-
-pub trait GasAlgebra {
-    fn feature_version(&self) -> u64;
-
-    fn gas_params(&self) -> &AptosGasParameters;
-
-    fn storage_gas_params(&self) -> &StorageGasParameters;
-
-    fn balance_internal(&self) -> InternalGas;
-
-    fn charge_execution(
-        &mut self,
-        abstract_amount: impl GasExpression<AptosGasParameters, Unit = InternalGasUnit>,
-    ) -> PartialVMResult<()>;
-
-    fn charge_io(
-        &mut self,
-        abstract_amount: impl GasExpression<AptosGasParameters, Unit = InternalGasUnit>,
-    ) -> PartialVMResult<()>;
-
-    fn charge_storage_fee(
-        &mut self,
-        abstract_amount: impl GasExpression<AptosGasParameters, Unit = Octa>,
-        gas_unit_price: FeePerGasUnit,
-    ) -> PartialVMResult<()>;
-
-    fn execution_gas_used(&self) -> InternalGas;
-
-    fn io_gas_used(&self) -> InternalGas;
-
-    fn storage_fee_used_in_gas_units(&self) -> InternalGas;
-
-    fn storage_fee_used(&self) -> Fee;
-}
-
-pub struct StandardGasAlgebra {
-    feature_version: u64,
-    gas_params: AptosGasParameters,
-    storage_gas_params: StorageGasParameters,
-
-    balance: InternalGas,
-
-    execution_gas_used: InternalGas,
-    io_gas_used: InternalGas,
-    // The gas consumed by the storage operations.
-    storage_fee_in_internal_units: InternalGas,
-    // The storage fee consumed by the storage operations.
-    storage_fee_used: Fee,
-}
-
-impl StandardGasAlgebra {
-    pub fn new(
-        gas_feature_version: u64,
-        gas_params: AptosGasParameters,
-        storage_gas_params: StorageGasParameters,
-        balance: impl Into<Gas>,
-    ) -> Self {
-        let balance = balance.into().to_unit_with_params(&gas_params.txn);
-
-        Self {
-            feature_version: gas_feature_version,
-            gas_params,
-            storage_gas_params,
-            balance,
-            execution_gas_used: 0.into(),
-            io_gas_used: 0.into(),
-            storage_fee_in_internal_units: 0.into(),
-            storage_fee_used: 0.into(),
-        }
-    }
-}
-
-impl StandardGasAlgebra {
-    fn charge(&mut self, amount: InternalGas) -> PartialVMResult<()> {
-        match self.balance.checked_sub(amount) {
-            Some(new_balance) => {
-                self.balance = new_balance;
-                Ok(())
-            },
-            None => {
-                self.balance = 0.into();
-                Err(PartialVMError::new(StatusCode::OUT_OF_GAS))
-            },
-        }
-    }
-}
-
-impl GasAlgebra for StandardGasAlgebra {
-    fn feature_version(&self) -> u64 {
-        self.feature_version
-    }
-
-    fn gas_params(&self) -> &AptosGasParameters {
-        &self.gas_params
-    }
-
-    fn storage_gas_params(&self) -> &StorageGasParameters {
-        &self.storage_gas_params
-    }
-
-    fn balance_internal(&self) -> InternalGas {
-        self.balance
-    }
-
-    fn charge_execution(
-        &mut self,
-        abstract_amount: impl GasExpression<AptosGasParameters, Unit = InternalGasUnit>,
-    ) -> PartialVMResult<()> {
-        let amount = abstract_amount.materialize(self.feature_version, &self.gas_params);
-
-        self.charge(amount)?;
-
-        self.execution_gas_used += amount;
-        if self.feature_version >= 7
-            && self.execution_gas_used > self.gas_params.txn.max_execution_gas
-        {
-            Err(PartialVMError::new(StatusCode::EXECUTION_LIMIT_REACHED))
-        } else {
-            Ok(())
-        }
-    }
-
-    fn charge_io(
-        &mut self,
-        abstract_amount: impl GasExpression<AptosGasParameters, Unit = InternalGasUnit>,
-    ) -> PartialVMResult<()> {
-        let amount = abstract_amount.materialize(self.feature_version, &self.gas_params);
-
-        self.charge(amount)?;
-
-        self.io_gas_used += amount;
-        if self.feature_version >= 7 && self.io_gas_used > self.gas_params.txn.max_io_gas {
-            Err(PartialVMError::new(StatusCode::IO_LIMIT_REACHED))
-        } else {
-            Ok(())
-        }
-    }
-
-    fn charge_storage_fee(
-        &mut self,
-        abstract_amount: impl GasExpression<AptosGasParameters, Unit = Octa>,
-        gas_unit_price: FeePerGasUnit,
-    ) -> PartialVMResult<()> {
-        let amount = abstract_amount.materialize(self.feature_version, &self.gas_params);
-
-        let txn_params = &self.gas_params.txn;
-
-        // Because the storage fees are defined in terms of fixed APT costs, we need
-        // to convert them into gas units.
-        //
-        // u128 is used to protect against overflow and preserve as much precision as
-        // possible in the extreme cases.
-        fn div_ceil(n: u128, d: u128) -> u128 {
-            if n % d == 0 {
-                n / d
-            } else {
-                n / d + 1
-            }
-        }
-        let gas_consumed_internal = div_ceil(
-            (u64::from(amount) as u128) * (u64::from(txn_params.gas_unit_scaling_factor) as u128),
-            u64::from(gas_unit_price) as u128,
-        );
-        let gas_consumed_internal = InternalGas::new(
-            if gas_consumed_internal > u64::MAX as u128 {
-                error!(
-                    "Something's wrong in the gas schedule: gas_consumed_internal ({}) > u64::MAX",
-                    gas_consumed_internal
-                );
-                u64::MAX
-            } else {
-                gas_consumed_internal as u64
-            },
-        );
-
-        self.charge(gas_consumed_internal)?;
-
-        self.storage_fee_in_internal_units += gas_consumed_internal;
-        self.storage_fee_used += amount;
-        if self.feature_version >= 7 && self.storage_fee_used > self.gas_params.txn.max_storage_fee
-        {
-            return Err(PartialVMError::new(StatusCode::STORAGE_LIMIT_REACHED));
-        }
-
-        Ok(())
-    }
-
-    fn execution_gas_used(&self) -> InternalGas {
-        self.execution_gas_used
-    }
-
-    fn io_gas_used(&self) -> InternalGas {
-        self.io_gas_used
-    }
-
-    fn storage_fee_used_in_gas_units(&self) -> InternalGas {
-        self.storage_fee_in_internal_units
-    }
-
-    fn storage_fee_used(&self) -> Fee {
-        self.storage_fee_used
-    }
-}
-
-/// The official gas meter used inside the Aptos VM.
-/// It maintains an internal gas counter, measured in internal gas units, and carries an environment
-/// consisting all the gas parameters, which it can lookup when performing gas calculations.
-pub struct StandardGasMeter<A> {
-    algebra: A,
-}
-
-impl<A> StandardGasMeter<A>
-where
-    A: GasAlgebra,
-{
-    pub fn new(algebra: A) -> Self {
-        Self { algebra }
-    }
-
-    pub fn feature_version(&self) -> u64 {
-        self.algebra.feature_version()
-    }
-}
-
-impl<A> MoveGasMeter for StandardGasMeter<A>
-where
-    A: GasAlgebra,
-{
-    #[inline]
-    fn balance_internal(&self) -> InternalGas {
-        self.algebra.balance_internal()
-    }
-
-    #[inline]
-    fn charge_br_false(&mut self, _target_offset: Option<CodeOffset>) -> PartialVMResult<()> {
-        self.algebra.charge_execution(BR_FALSE)
-    }
-
-    #[inline]
-    fn charge_br_true(&mut self, _target_offset: Option<CodeOffset>) -> PartialVMResult<()> {
-        self.algebra.charge_execution(BR_TRUE)
-    }
-
-    #[inline]
-    fn charge_branch(&mut self, _target_offset: CodeOffset) -> PartialVMResult<()> {
-        self.algebra.charge_execution(BRANCH)
-    }
-
-    #[inline]
-    fn charge_simple_instr(&mut self, instr: SimpleInstruction) -> PartialVMResult<()> {
-        macro_rules! dispatch {
-            ($($name: ident => $cost: expr),* $(,)?) => {
-                match instr {
-                    $(SimpleInstruction::$name => self.algebra.charge_execution($cost)),*
-                }
-            };
-        }
-
-        dispatch! {
-            Nop => NOP,
-
-            Abort => ABORT,
-            Ret => RET,
-
-            LdU8 => LD_U8,
-            LdU16 => LD_U16,
-            LdU32 => LD_U32,
-            LdU64 => LD_U64,
-            LdU128 => LD_U128,
-            LdU256 => LD_U256,
-            LdTrue => LD_TRUE,
-            LdFalse => LD_FALSE,
-
-            ImmBorrowLoc => IMM_BORROW_LOC,
-            MutBorrowLoc => MUT_BORROW_LOC,
-            ImmBorrowField => IMM_BORROW_FIELD,
-            MutBorrowField => MUT_BORROW_FIELD,
-            ImmBorrowFieldGeneric => IMM_BORROW_FIELD_GENERIC,
-            MutBorrowFieldGeneric => MUT_BORROW_FIELD_GENERIC,
-            FreezeRef => FREEZE_REF,
-
-            CastU8 => CAST_U8,
-            CastU16 => CAST_U16,
-            CastU32 => CAST_U32,
-            CastU64 => CAST_U64,
-            CastU128 => CAST_U128,
-            CastU256 => CAST_U256,
-
-            Add => ADD,
-            Sub => SUB,
-            Mul => MUL,
-            Mod => MOD_,
-            Div => DIV,
-
-            BitOr => BIT_OR,
-            BitAnd => BIT_AND,
-            Xor => XOR,
-            Shl => SHL,
-            Shr => SHR,
-
-            Or => OR,
-            And => AND,
-            Not => NOT,
-
-            Lt => LT,
-            Gt => GT,
-            Le => LE,
-            Ge => GE,
-        }
-    }
-
-    #[inline]
-    fn charge_native_function_before_execution(
-        &mut self,
-        _ty_args: impl ExactSizeIterator<Item = impl TypeView>,
-        _args: impl ExactSizeIterator<Item = impl ValueView>,
-    ) -> PartialVMResult<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn charge_native_function(
-        &mut self,
-        amount: InternalGas,
-        _ret_vals: Option<impl ExactSizeIterator<Item = impl ValueView>>,
-    ) -> PartialVMResult<()> {
-        // TODO(Gas): Is this correct???
-        self.algebra.charge_execution(amount)
-    }
-
-    #[inline]
-    fn charge_load_resource(
-        &mut self,
-        _addr: AccountAddress,
-        _ty: impl TypeView,
-        val: Option<impl ValueView>,
-        bytes_loaded: NumBytes,
-    ) -> PartialVMResult<()> {
-        // TODO(Gas): check if this is correct.
-        if self.feature_version() <= 8 && val.is_none() && bytes_loaded != 0.into() {
-            return Err(PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR).with_message("in legacy versions, number of bytes loaded must be zero when the resource does not exist ".to_string()));
-        }
-        let cost = self
-            .storage_gas_params()
-            .pricing
-            .calculate_read_gas(val.is_some(), bytes_loaded);
-        self.algebra.charge_io(cost)
-    }
-
-    #[inline]
-    fn charge_pop(&mut self, _popped_val: impl ValueView) -> PartialVMResult<()> {
-        self.algebra.charge_execution(POP)
-    }
-
-    #[inline]
-    fn charge_call(
-        &mut self,
-        _module_id: &ModuleId,
-        _func_name: &str,
-        args: impl ExactSizeIterator<Item = impl ValueView>,
-        num_locals: NumArgs,
-    ) -> PartialVMResult<()> {
-        let cost = CALL_BASE + CALL_PER_ARG * NumArgs::new(args.len() as u64);
-
-        match self.feature_version() {
-            0..=2 => self.algebra.charge_execution(cost),
-            3.. => self
-                .algebra
-                .charge_execution(cost + CALL_PER_LOCAL * num_locals),
-        }
-    }
-
-    #[inline]
-    fn charge_call_generic(
-        &mut self,
-        _module_id: &ModuleId,
-        _func_name: &str,
-        ty_args: impl ExactSizeIterator<Item = impl TypeView>,
-        args: impl ExactSizeIterator<Item = impl ValueView>,
-        num_locals: NumArgs,
-    ) -> PartialVMResult<()> {
-        let cost = CALL_GENERIC_BASE
-            + CALL_GENERIC_PER_TY_ARG * NumArgs::new(ty_args.len() as u64)
-            + CALL_GENERIC_PER_ARG * NumArgs::new(args.len() as u64);
-
-        match self.feature_version() {
-            0..=2 => self.algebra.charge_execution(cost),
-            3.. => self
-                .algebra
-                .charge_execution(cost + CALL_GENERIC_PER_LOCAL * num_locals),
-        }
-    }
-
-    #[inline]
-    fn charge_ld_const(&mut self, size: NumBytes) -> PartialVMResult<()> {
-        self.algebra
-            .charge_execution(LD_CONST_BASE + LD_CONST_PER_BYTE * size)
-    }
-
-    #[inline]
-    fn charge_ld_const_after_deserialization(
-        &mut self,
-        _val: impl ValueView,
-    ) -> PartialVMResult<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn charge_copy_loc(&mut self, val: impl ValueView) -> PartialVMResult<()> {
-        let (stack_size, heap_size) = self
-            .gas_params()
-            .misc
-            .abs_val
-            .abstract_value_size_stack_and_heap(val, self.feature_version());
-
-        // Note(Gas): this makes a deep copy so we need to charge for the full value size
-        self.algebra
-            .charge_execution(COPY_LOC_BASE + COPY_LOC_PER_ABS_VAL_UNIT * (stack_size + heap_size))
-    }
-
-    #[inline]
-    fn charge_move_loc(&mut self, _val: impl ValueView) -> PartialVMResult<()> {
-        self.algebra.charge_execution(MOVE_LOC_BASE)
-    }
-
-    #[inline]
-    fn charge_store_loc(&mut self, _val: impl ValueView) -> PartialVMResult<()> {
-        self.algebra.charge_execution(ST_LOC_BASE)
-    }
-
-    #[inline]
-    fn charge_pack(
-        &mut self,
-        is_generic: bool,
-        args: impl ExactSizeIterator<Item = impl ValueView>,
-    ) -> PartialVMResult<()> {
-        let num_args = NumArgs::new(args.len() as u64);
-
-        match is_generic {
-            false => self
-                .algebra
-                .charge_execution(PACK_BASE + PACK_PER_FIELD * num_args),
-            true => self
-                .algebra
-                .charge_execution(PACK_GENERIC_BASE + PACK_GENERIC_PER_FIELD * num_args),
-        }
-    }
-
-    #[inline]
-    fn charge_unpack(
-        &mut self,
-        is_generic: bool,
-        args: impl ExactSizeIterator<Item = impl ValueView>,
-    ) -> PartialVMResult<()> {
-        let num_args = NumArgs::new(args.len() as u64);
-
-        match is_generic {
-            false => self
-                .algebra
-                .charge_execution(UNPACK_BASE + UNPACK_PER_FIELD * num_args),
-            true => self
-                .algebra
-                .charge_execution(UNPACK_GENERIC_BASE + UNPACK_GENERIC_PER_FIELD * num_args),
-        }
-    }
-
-    #[inline]
-    fn charge_read_ref(&mut self, val: impl ValueView) -> PartialVMResult<()> {
-        let (stack_size, heap_size) = self
-            .gas_params()
-            .misc
-            .abs_val
-            .abstract_value_size_stack_and_heap(val, self.feature_version());
-
-        // Note(Gas): this makes a deep copy so we need to charge for the full value size
-        self.algebra
-            .charge_execution(READ_REF_BASE + READ_REF_PER_ABS_VAL_UNIT * (stack_size + heap_size))
-    }
-
-    #[inline]
-    fn charge_write_ref(
-        &mut self,
-        _new_val: impl ValueView,
-        _old_val: impl ValueView,
-    ) -> PartialVMResult<()> {
-        self.algebra.charge_execution(WRITE_REF_BASE)
-    }
-
-    #[inline]
-    fn charge_eq(&mut self, lhs: impl ValueView, rhs: impl ValueView) -> PartialVMResult<()> {
-        let abs_val_params = &self.gas_params().misc.abs_val;
-
-        let cost = EQ_BASE
-            + EQ_PER_ABS_VAL_UNIT
-                * (abs_val_params.abstract_value_size_dereferenced(lhs, self.feature_version())
-                    + abs_val_params.abstract_value_size_dereferenced(rhs, self.feature_version()));
-
-        self.algebra.charge_execution(cost)
-    }
-
-    #[inline]
-    fn charge_neq(&mut self, lhs: impl ValueView, rhs: impl ValueView) -> PartialVMResult<()> {
-        let abs_val_params = &self.gas_params().misc.abs_val;
-
-        let cost = NEQ_BASE
-            + NEQ_PER_ABS_VAL_UNIT
-                * (abs_val_params.abstract_value_size_dereferenced(lhs, self.feature_version())
-                    + abs_val_params.abstract_value_size_dereferenced(rhs, self.feature_version()));
-
-        self.algebra.charge_execution(cost)
-    }
-
-    #[inline]
-    fn charge_borrow_global(
-        &mut self,
-        is_mut: bool,
-        is_generic: bool,
-        _ty: impl TypeView,
-        _is_success: bool,
-    ) -> PartialVMResult<()> {
-        match (is_mut, is_generic) {
-            (false, false) => self.algebra.charge_execution(IMM_BORROW_GLOBAL_BASE),
-            (false, true) => self
-                .algebra
-                .charge_execution(IMM_BORROW_GLOBAL_GENERIC_BASE),
-            (true, false) => self.algebra.charge_execution(MUT_BORROW_GLOBAL_BASE),
-            (true, true) => self
-                .algebra
-                .charge_execution(MUT_BORROW_GLOBAL_GENERIC_BASE),
-        }
-    }
-
-    #[inline]
-    fn charge_exists(
-        &mut self,
-        is_generic: bool,
-        _ty: impl TypeView,
-        _exists: bool,
-    ) -> PartialVMResult<()> {
-        match is_generic {
-            false => self.algebra.charge_execution(EXISTS_BASE),
-            true => self.algebra.charge_execution(EXISTS_GENERIC_BASE),
-        }
-    }
-
-    #[inline]
-    fn charge_move_from(
-        &mut self,
-        is_generic: bool,
-        _ty: impl TypeView,
-        _val: Option<impl ValueView>,
-    ) -> PartialVMResult<()> {
-        match is_generic {
-            false => self.algebra.charge_execution(MOVE_FROM_BASE),
-            true => self.algebra.charge_execution(MOVE_FROM_GENERIC_BASE),
-        }
-    }
-
-    #[inline]
-    fn charge_move_to(
-        &mut self,
-        is_generic: bool,
-        _ty: impl TypeView,
-        _val: impl ValueView,
-        _is_success: bool,
-    ) -> PartialVMResult<()> {
-        match is_generic {
-            false => self.algebra.charge_execution(MOVE_TO_BASE),
-            true => self.algebra.charge_execution(MOVE_TO_GENERIC_BASE),
-        }
-    }
-
-    #[inline]
-    fn charge_vec_pack<'a>(
-        &mut self,
-        _ty: impl TypeView + 'a,
-        args: impl ExactSizeIterator<Item = impl ValueView>,
-    ) -> PartialVMResult<()> {
-        let num_args = NumArgs::new(args.len() as u64);
-
-        self.algebra
-            .charge_execution(VEC_PACK_BASE + VEC_PACK_PER_ELEM * num_args)
-    }
-
-    #[inline]
-    fn charge_vec_unpack(
-        &mut self,
-        _ty: impl TypeView,
-        expect_num_elements: NumArgs,
-        _elems: impl ExactSizeIterator<Item = impl ValueView>,
-    ) -> PartialVMResult<()> {
-        self.algebra
-            .charge_execution(VEC_UNPACK_BASE + VEC_UNPACK_PER_EXPECTED_ELEM * expect_num_elements)
-    }
-
-    #[inline]
-    fn charge_vec_len(&mut self, _ty: impl TypeView) -> PartialVMResult<()> {
-        self.algebra.charge_execution(VEC_LEN_BASE)
-    }
-
-    #[inline]
-    fn charge_vec_borrow(
-        &mut self,
-        is_mut: bool,
-        _ty: impl TypeView,
-        _is_success: bool,
-    ) -> PartialVMResult<()> {
-        match is_mut {
-            false => self.algebra.charge_execution(VEC_IMM_BORROW_BASE),
-            true => self.algebra.charge_execution(VEC_MUT_BORROW_BASE),
-        }
-    }
-
-    #[inline]
-    fn charge_vec_push_back(
-        &mut self,
-        _ty: impl TypeView,
-        _val: impl ValueView,
-    ) -> PartialVMResult<()> {
-        self.algebra.charge_execution(VEC_PUSH_BACK_BASE)
-    }
-
-    #[inline]
-    fn charge_vec_pop_back(
-        &mut self,
-        _ty: impl TypeView,
-        _val: Option<impl ValueView>,
-    ) -> PartialVMResult<()> {
-        self.algebra.charge_execution(VEC_POP_BACK_BASE)
-    }
-
-    #[inline]
-    fn charge_vec_swap(&mut self, _ty: impl TypeView) -> PartialVMResult<()> {
-        self.algebra.charge_execution(VEC_SWAP_BASE)
-    }
-
-    #[inline]
-    fn charge_drop_frame(
-        &mut self,
-        _locals: impl Iterator<Item = impl ValueView>,
-    ) -> PartialVMResult<()> {
-        Ok(())
-    }
-}
-
-impl<A> AptosGasMeter for StandardGasMeter<A>
-where
-    A: GasAlgebra,
-{
-    type Algebra = A;
-
-    #[inline]
-    fn algebra(&self) -> &Self::Algebra {
-        &self.algebra
-    }
-
-    #[inline]
-    fn algebra_mut(&mut self) -> &mut Self::Algebra {
-        &mut self.algebra
-    }
-
-    #[inline]
-    fn charge_storage_fee(
-        &mut self,
-        amount: Fee,
-        gas_unit_price: FeePerGasUnit,
-    ) -> PartialVMResult<()> {
-        self.algebra.charge_storage_fee(amount, gas_unit_price)
-    }
-
-    fn charge_io_gas_for_write(&mut self, key: &StateKey, op: &WriteOp) -> VMResult<()> {
-        let cost = self.storage_gas_params().pricing.io_gas_per_write(key, op);
-        self.algebra
-            .charge_io(cost)
-            .map_err(|e| e.finish(Location::Undefined))
-    }
-
-    fn storage_fee_per_write(&self, key: &StateKey, op: &WriteOp) -> Fee {
-        self.gas_params().txn.storage_fee_per_write(key, op)
-    }
-
-    fn storage_fee_per_event(&self, event: &ContractEvent) -> Fee {
-        self.gas_params().txn.storage_fee_per_event(event)
-    }
-
-    fn storage_discount_for_events(&self, total_cost: Fee) -> Fee {
-        self.gas_params()
-            .txn
-            .storage_discount_for_events(total_cost)
-    }
-
-    fn storage_fee_for_transaction_storage(&self, txn_size: NumBytes) -> Fee {
-        self.gas_params()
-            .txn
-            .storage_fee_for_transaction_storage(txn_size)
-    }
-
-    fn charge_intrinsic_gas_for_transaction(&mut self, txn_size: NumBytes) -> VMResult<()> {
-        let excess = txn_size
-            .checked_sub(self.gas_params().txn.large_transaction_cutoff)
-            .unwrap_or_else(|| 0.into());
-
-        self.algebra
-            .charge_execution(MIN_TRANSACTION_GAS_UNITS + INTRINSIC_GAS_PER_BYTE * excess)
-            .map_err(|e| e.finish(Location::Undefined))
-    }
-}
diff --git a/aptos-move/aptos-gas/src/lib.rs b/aptos-move/aptos-gas/src/lib.rs
deleted file mode 100644
index 163f14610f856..0000000000000
--- a/aptos-move/aptos-gas/src/lib.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
-//! This crate is the core of the gas metering system of the Aptos blockchain.
-//!
-//! More specifically, it
-//!   - Is home to the gas meter implementation
-//!   - Defines the gas parameters and formulae for instructions
-//!   - Defines the gas parameters for transactions
-//!   - Sets the initial values for all gas parameters, including the instruction, transaction
-//!     move-stdlib and aptos-framework ones.
-//!   - Defines a bi-directional mapping between the (Rust) gas parameter structs and their
-//!     corresponding representation on-chain.
-//!
-//! The reason why we need two different representations is that they serve different purposes:
-//!   - The Rust structs are used for quick (static) lookups by the gas meter and native functions
-//!     when calculating gas costs.
-//!   - The on-chain gas schedule needs to be extensible and unordered so we can upgrade it easily
-//!     in the future.
-
-#[macro_use]
-mod natives;
-
-mod aptos_framework;
-mod gas_meter;
-pub mod gen;
-mod move_stdlib;
-mod table;
-
-pub use gas_meter::{
-    AptosGasMeter, AptosGasParameters, FromOnChainGasSchedule, InitialGasSchedule,
-    NativeGasParameters, StandardGasAlgebra, StandardGasMeter, ToOnChainGasSchedule,
-};
diff --git a/aptos-move/aptos-gas/src/move_stdlib.rs b/aptos-move/aptos-gas/src/move_stdlib.rs
deleted file mode 100644
index 011a1177336a0..0000000000000
--- a/aptos-move/aptos-gas/src/move_stdlib.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::gas_meter::EXECUTION_GAS_MULTIPLIER as MUL;
-use aptos_move_stdlib::natives::GasParameters;
-
-#[cfg(all(test, not(feature = "testing")))]
-const UNIT_TEST_ENTRIES: usize = 0;
-
-#[cfg(all(test, feature = "testing"))]
-const UNIT_TEST_ENTRIES: usize = 2;
-
-crate::natives::define_gas_parameters_for_natives!(GasParameters, "move_stdlib", [
-    [.bcs.to_bytes.per_byte_serialized, "bcs.to_bytes.per_byte_serialized", 10 * MUL],
-    [.bcs.to_bytes.failure, "bcs.to_bytes.failure", 1000 * MUL],
-
-    [.hash.sha2_256.base, "hash.sha2_256.base", 3000 * MUL],
-    [.hash.sha2_256.per_byte, "hash.sha2_256.per_byte", 50 * MUL],
-    [.hash.sha3_256.base, "hash.sha3_256.base", 4000 * MUL],
-    [.hash.sha3_256.per_byte, "hash.sha3_256.per_byte", 45 * MUL],
-
-    // Note(Gas): this initial value is guesswork.
-    [.signer.borrow_address.base, "signer.borrow_address.base", 200 * MUL],
-
-    // Note(Gas): these initial values are guesswork.
-    [.string.check_utf8.base, "string.check_utf8.base", 300 * MUL],
-    [.string.check_utf8.per_byte, "string.check_utf8.per_byte", 8 * MUL],
-    [.string.is_char_boundary.base, "string.is_char_boundary.base", 300 * MUL],
-    [.string.sub_string.base, "string.sub_string.base", 400 * MUL],
-    [.string.sub_string.per_byte, "string.sub_string.per_byte", 3 * MUL],
-    [.string.index_of.base, "string.index_of.base", 400 * MUL],
-    [.string.index_of.per_byte_pattern, "string.index_of.per_byte_pattern", 20 * MUL],
-    [.string.index_of.per_byte_searched, "string.index_of.per_byte_searched", 10 * MUL],
-], allow_unmapped = 1 /* bcs */ + 2 /* hash */ + 8 /* vector */ + UNIT_TEST_ENTRIES);
diff --git a/aptos-move/aptos-gas/src/natives.rs b/aptos-move/aptos-gas/src/natives.rs
deleted file mode 100644
index e3f05f5229b7d..0000000000000
--- a/aptos-move/aptos-gas/src/natives.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
-//! This module defines some macros to help implement the mapping between the on-chain gas schedule
-//! and its rust representation.
-
-macro_rules! define_gas_parameters_for_natives_extract_key_at_version {
-    ($key: literal, $cur_ver: expr) => {
-        Some($key)
-    };
-
-    ({ $($ver: pat => $key: literal),+ }, $cur_ver: expr) => {
-        match $cur_ver {
-            $($ver => Some($key)),+,
-            _ => None,
-        }
-    }
-}
-
-macro_rules! define_gas_parameters_for_natives {
-    (
-        $param_ty: ty,
-        $package_name: literal,
-        [$([$(.$field: ident)+, $key_bindings: tt, $initial_val: expr]),+ $(,)?]
-        $(, allow_unmapped = $allow_unmapped: expr)?
-    ) => {
-        impl crate::gas_meter::FromOnChainGasSchedule for $param_ty {
-            #[allow(unused_variables)]
-            fn from_on_chain_gas_schedule(gas_schedule: &std::collections::BTreeMap<String, u64>, feature_version: u64) -> Result<Self, String> {
-                let mut params = <$param_ty>::zeros();
-
-                $(
-                    if let Some(key) =  $crate::natives::define_gas_parameters_for_natives_extract_key_at_version!($key_bindings, feature_version) {
-                        let name = format!("{}.{}", $package_name, key);
-                        params $(.$field)+ = gas_schedule.get(&name).cloned().ok_or_else(|| format!("Gas parameter {} does not exist. Feature version: {}.", name, feature_version))?.into();
-                    }
-                )*
-
-                Ok(params)
-            }
-        }
-
-        impl crate::gas_meter::ToOnChainGasSchedule for $param_ty {
-            #[allow(unused_variables)]
-            fn to_on_chain_gas_schedule(&self, feature_version: u64) -> Vec<(String, u64)> {
-                let mut output = vec![];
-
-                $(
-                    if let Some(key) = $crate::natives::define_gas_parameters_for_natives_extract_key_at_version!($key_bindings, feature_version) {
-                        output.push((format!("{}.{}", $package_name, key), u64::from(self $(.$field)+)));
-                    }
-                )*
-
-                output
-            }
-        }
-
-        impl crate::gas_meter::InitialGasSchedule for $param_ty {
-            fn initial() -> Self {
-                let mut params = <$param_ty>::zeros();
-
-                $(
-                    params $(.$field)+ = $initial_val.into();
-                )*
-
-                params
-            }
-        }
-
-        #[test]
-        fn keys_should_be_unique_for_all_versions() {
-            for ver in 0..=aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION {
-                let mut map = std::collections::BTreeMap::<&str, ()>::new();
-
-                $(
-                    if let Some(key) = $crate::natives::define_gas_parameters_for_natives_extract_key_at_version!($key_bindings, ver) {
-                        if map.insert(key, ()).is_some() {
-                            panic!("duplicated key {} at version {}", key, ver);
-                        }
-                    }
-                )*
-            }
-        }
-
-
-
-        #[test]
-        fn paths_must_be_unique() {
-            let mut map = std::collections::BTreeMap::<&str, ()>::new();
-
-            for path in [$(stringify!($($field).*)),*] {
-                if map.insert(path.clone(), ()).is_some() {
-                    panic!("duplicated path {}", path);
-                }
-            }
-        }
-
-        #[test]
-        fn all_parameters_mapped() {
-            let total = format!("{:?}", &<$param_ty>::zeros()).matches(": 0").count();
-            let mapped = [$(stringify!($($field).*)),*].len() $(+ $allow_unmapped)?;
-            if mapped != total {
-                panic!("only {} out of the {} entries are mapped", mapped, total)
-            }
-        }
-    };
-}
-
-pub(crate) use define_gas_parameters_for_natives;
-pub(crate) use define_gas_parameters_for_natives_extract_key_at_version;
diff --git a/aptos-move/aptos-gas/src/table.rs b/aptos-move/aptos-gas/src/table.rs
deleted file mode 100644
index ae156f67a67da..0000000000000
--- a/aptos-move/aptos-gas/src/table.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::gas_meter::EXECUTION_GAS_MULTIPLIER as MUL;
-use move_table_extension::GasParameters;
-
-crate::natives::define_gas_parameters_for_natives!(GasParameters, "table", [
-    // These are dummy value, they copied from storage gas in aptos-core/aptos-vm/src/aptos_vm_impl.rs
-    [.common.load_base_legacy, "common.load.base", 8000],
-    [.common.load_base_new, { 7.. => "common.load.base_new" }, 8000],
-    [.common.load_per_byte, "common.load.per_byte", 1000],
-    [.common.load_failure, "common.load.failure", 0],
-
-    [.new_table_handle.base, "new_table_handle.base", 1000 * MUL],
-
-    [.add_box.base, "add_box.base", 1200 * MUL],
-    [.add_box.per_byte_serialized, "add_box.per_byte_serialized", 10 * MUL],
-
-    [.borrow_box.base, "borrow_box.base", 1200 * MUL],
-    [.borrow_box.per_byte_serialized, "borrow_box.per_byte_serialized", 10 * MUL],
-
-    [.contains_box.base, "contains_box.base", 1200 * MUL],
-    [.contains_box.per_byte_serialized, "contains_box.per_byte_serialized", 10 * MUL],
-
-    [.remove_box.base, "remove_box.base", 1200 * MUL],
-    [.remove_box.per_byte_serialized, "remove_box.per_byte_serialized", 10 * MUL],
-
-    [.destroy_empty_box.base, "destroy_empty_box.base", 1200 * MUL],
-
-    [.drop_unchecked_box.base, "drop_unchecked_box.base", 100 * MUL],
-]);
diff --git a/aptos-move/aptos-memory-usage-tracker/Cargo.toml b/aptos-move/aptos-memory-usage-tracker/Cargo.toml
index 2daf424954945..d54a5b4454e10 100644
--- a/aptos-move/aptos-memory-usage-tracker/Cargo.toml
+++ b/aptos-move/aptos-memory-usage-tracker/Cargo.toml
@@ -12,8 +12,8 @@ repository = { workspace = true }
 rust-version = { workspace = true }
 
 [dependencies]
-aptos-gas = { workspace = true }
 aptos-gas-algebra = { workspace = true }
+aptos-gas-meter = { workspace = true }
 aptos-types = { workspace = true }
 move-binary-format = { workspace = true }
 move-core-types = { workspace = true }
diff --git a/aptos-move/aptos-memory-usage-tracker/src/lib.rs b/aptos-move/aptos-memory-usage-tracker/src/lib.rs
index f3d5decacec09..cd0ba35fa2302 100644
--- a/aptos-move/aptos-memory-usage-tracker/src/lib.rs
+++ b/aptos-move/aptos-memory-usage-tracker/src/lib.rs
@@ -1,8 +1,8 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use aptos_gas::AptosGasMeter;
 use aptos_gas_algebra::{AbstractValueSize, Fee, FeePerGasUnit, InternalGas, NumArgs, NumBytes};
+use aptos_gas_meter::AptosGasMeter;
 use aptos_types::{
     account_config::CORE_CODE_ADDRESS, contract_event::ContractEvent,
     state_store::state_key::StateKey, write_set::WriteOp,
@@ -33,7 +33,7 @@ where
     G: AptosGasMeter,
 {
     pub fn new(base: G) -> Self {
-        let memory_quota = base.gas_params().txn.memory_quota;
+        let memory_quota = base.vm_gas_params().txn.memory_quota;
 
         Self {
             base,
@@ -194,7 +194,7 @@ where
         if !self.should_leak_memory_for_native {
             self.release_heap_memory(args.clone().fold(AbstractValueSize::zero(), |acc, val| {
                 acc + self
-                    .gas_params()
+                    .vm_gas_params()
                     .misc
                     .abs_val
                     .abstract_heap_size(val, self.feature_version())
@@ -214,7 +214,7 @@ where
         if let Some(ret_vals) = ret_vals.clone() {
             self.use_heap_memory(ret_vals.fold(AbstractValueSize::zero(), |acc, val| {
                 acc + self
-                    .gas_params()
+                    .vm_gas_params()
                     .misc
                     .abs_val
                     .abstract_heap_size(val, self.feature_version())
@@ -236,7 +236,7 @@ where
             // TODO(Gas): Rewrite this in a better way.
             if let Some(val) = &val {
                 self.use_heap_memory(
-                    self.gas_params()
+                    self.vm_gas_params()
                         .misc
                         .abs_val
                         .abstract_heap_size(val, self.feature_version()),
@@ -250,7 +250,7 @@ where
     #[inline]
     fn charge_pop(&mut self, popped_val: impl ValueView) -> PartialVMResult<()> {
         self.release_heap_memory(
-            self.gas_params()
+            self.vm_gas_params()
                 .misc
                 .abs_val
                 .abstract_heap_size(&popped_val, self.feature_version()),
@@ -265,7 +265,7 @@ where
         val: impl ValueView,
     ) -> PartialVMResult<()> {
         self.use_heap_memory(
-            self.gas_params()
+            self.vm_gas_params()
                 .misc
                 .abs_val
                 .abstract_heap_size(&val, self.feature_version()),
@@ -277,7 +277,7 @@ where
     #[inline]
     fn charge_copy_loc(&mut self, val: impl ValueView) -> PartialVMResult<()> {
         let heap_size = self
-            .gas_params()
+            .vm_gas_params()
             .misc
             .abs_val
             .abstract_heap_size(&val, self.feature_version());
@@ -295,7 +295,7 @@ where
     ) -> PartialVMResult<()> {
         self.use_heap_memory(args.clone().fold(AbstractValueSize::zero(), |acc, val| {
             acc + self
-                .gas_params()
+                .vm_gas_params()
                 .misc
                 .abs_val
                 .abstract_stack_size(val, self.feature_version())
@@ -312,7 +312,7 @@ where
     ) -> PartialVMResult<()> {
         self.release_heap_memory(args.clone().fold(AbstractValueSize::zero(), |acc, val| {
             acc + self
-                .gas_params()
+                .vm_gas_params()
                 .misc
                 .abs_val
                 .abstract_stack_size(val, self.feature_version())
@@ -324,7 +324,7 @@ where
     #[inline]
     fn charge_read_ref(&mut self, val: impl ValueView) -> PartialVMResult<()> {
         let heap_size = self
-            .gas_params()
+            .vm_gas_params()
             .misc
             .abs_val
             .abstract_heap_size(&val, self.feature_version());
@@ -341,7 +341,7 @@ where
         old_val: impl ValueView,
     ) -> PartialVMResult<()> {
         self.release_heap_memory(
-            self.gas_params()
+            self.vm_gas_params()
                 .misc
                 .abs_val
                 .abstract_heap_size(&old_val, self.feature_version()),
@@ -353,13 +353,13 @@ where
     #[inline]
     fn charge_eq(&mut self, lhs: impl ValueView, rhs: impl ValueView) -> PartialVMResult<()> {
         self.release_heap_memory(
-            self.gas_params()
+            self.vm_gas_params()
                 .misc
                 .abs_val
                 .abstract_heap_size(&lhs, self.feature_version()),
         );
         self.release_heap_memory(
-            self.gas_params()
+            self.vm_gas_params()
                 .misc
                 .abs_val
                 .abstract_heap_size(&rhs, self.feature_version()),
@@ -371,13 +371,13 @@ where
     #[inline]
     fn charge_neq(&mut self, lhs: impl ValueView, rhs: impl ValueView) -> PartialVMResult<()> {
         self.release_heap_memory(
-            self.gas_params()
+            self.vm_gas_params()
                 .misc
                 .abs_val
                 .abstract_heap_size(&lhs, self.feature_version()),
         );
         self.release_heap_memory(
-            self.gas_params()
+            self.vm_gas_params()
                 .misc
                 .abs_val
                 .abstract_heap_size(&rhs, self.feature_version()),
@@ -393,7 +393,7 @@ where
         args: impl ExactSizeIterator<Item = impl ValueView> + Clone,
     ) -> PartialVMResult<()> {
         self.use_heap_memory(args.clone().fold(AbstractValueSize::zero(), |acc, val| {
-            acc + self.gas_params().misc.abs_val.abstract_packed_size(val)
+            acc + self.vm_gas_params().misc.abs_val.abstract_packed_size(val)
         }))?;
 
         self.base.charge_vec_pack(ty, args)
@@ -407,7 +407,7 @@ where
         elems: impl ExactSizeIterator<Item = impl ValueView> + Clone,
     ) -> PartialVMResult<()> {
         self.release_heap_memory(elems.clone().fold(AbstractValueSize::zero(), |acc, val| {
-            acc + self.gas_params().misc.abs_val.abstract_packed_size(val)
+            acc + self.vm_gas_params().misc.abs_val.abstract_packed_size(val)
         }));
 
         self.base.charge_vec_unpack(ty, expect_num_elements, elems)
@@ -419,7 +419,7 @@ where
         ty: impl TypeView,
         val: impl ValueView,
     ) -> PartialVMResult<()> {
-        self.use_heap_memory(self.gas_params().misc.abs_val.abstract_packed_size(&val))?;
+        self.use_heap_memory(self.vm_gas_params().misc.abs_val.abstract_packed_size(&val))?;
 
         self.base.charge_vec_push_back(ty, val)
     }
@@ -431,7 +431,7 @@ where
         val: Option<impl ValueView>,
     ) -> PartialVMResult<()> {
         if let Some(val) = &val {
-            self.release_heap_memory(self.gas_params().misc.abs_val.abstract_packed_size(val));
+            self.release_heap_memory(self.vm_gas_params().misc.abs_val.abstract_packed_size(val));
         }
 
         self.base.charge_vec_pop_back(ty, val)
@@ -444,7 +444,7 @@ where
     ) -> PartialVMResult<()> {
         self.release_heap_memory(locals.clone().fold(AbstractValueSize::zero(), |acc, val| {
             acc + self
-                .gas_params()
+                .vm_gas_params()
                 .misc
                 .abs_val
                 .abstract_heap_size(val, self.feature_version())
diff --git a/aptos-move/aptos-native-interface/Cargo.toml b/aptos-move/aptos-native-interface/Cargo.toml
new file mode 100644
index 0000000000000..413ea285ba54e
--- /dev/null
+++ b/aptos-move/aptos-native-interface/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "aptos-native-interface"
+version = "0.1.0"
+
+# Workspace inherited keys
+authors = { workspace = true }
+edition = { workspace = true }
+homepage = { workspace = true }
+license = { workspace = true }
+publish = { workspace = true }
+repository = { workspace = true }
+rust-version = { workspace = true }
+
+[dependencies]
+aptos-gas-algebra = { workspace = true }
+aptos-gas-schedule = { workspace = true }
+aptos-types = { workspace = true }
+move-binary-format = { workspace = true }
+move-core-types = { workspace = true }
+move-vm-runtime = { workspace = true }
+move-vm-types = { workspace = true }
+smallvec = { workspace = true }
diff --git a/aptos-move/aptos-native-interface/src/builder.rs b/aptos-move/aptos-native-interface/src/builder.rs
new file mode 100644
index 0000000000000..246320af54dd5
--- /dev/null
+++ b/aptos-move/aptos-native-interface/src/builder.rs
@@ -0,0 +1,159 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::{
+    context::SafeNativeContext,
+    errors::{SafeNativeError, SafeNativeResult},
+};
+use aptos_gas_schedule::{MiscGasParameters, NativeGasParameters};
+use aptos_types::on_chain_config::{Features, TimedFeatures};
+use move_vm_runtime::native_functions::{NativeContext, NativeFunction};
+use move_vm_types::{
+    loaded_data::runtime_types::Type, natives::function::NativeResult, values::Value,
+};
+use smallvec::SmallVec;
+use std::{collections::VecDeque, sync::Arc};
+
+/// Data shared by all native functions, mostly on-chain configurations.
+#[derive(Debug)]
+struct SharedData {
+    gas_feature_version: u64,
+    native_gas_params: NativeGasParameters,
+    misc_gas_params: MiscGasParameters,
+    timed_features: TimedFeatures,
+    features: Features,
+}
+
+/// Factory object that allows one to build native functions with ease.
+///
+/// This enables native functions to access shared data, and interface with `SafeNativeContext`.
+#[derive(Debug)]
+pub struct SafeNativeBuilder {
+    data: Arc<SharedData>,
+    enable_incremental_gas_charging: bool,
+}
+
+impl SafeNativeBuilder {
+    /// Creates a new safe native builder.
+    ///
+    /// The configurations provided will be accessible by all native functions created later.
+    pub fn new(
+        gas_feature_version: u64,
+        native_gas_params: NativeGasParameters,
+        misc_gas_params: MiscGasParameters,
+        timed_features: TimedFeatures,
+        features: Features,
+    ) -> Self {
+        Self {
+            data: Arc::new(SharedData {
+                gas_feature_version,
+                native_gas_params,
+                misc_gas_params,
+                timed_features,
+                features,
+            }),
+            enable_incremental_gas_charging: true,
+        }
+    }
+
+    /// Controls the default incremental gas charging behavior of the natives created from this builder.
+    ///
+    /// Default: enabled.
+    pub fn set_incremental_gas_charging(&mut self, enable: bool) {
+        self.enable_incremental_gas_charging = enable;
+    }
+
+    /// Convenience function that allows one to set the incremental gas charging behavior only for
+    /// natives created within the given closure.
+    ///
+    /// This can be useful if you want to configure the default for natives from a particular group
+    /// without affecting the others.
+    pub fn with_incremental_gas_charging<F, R>(&mut self, enable: bool, action: F) -> R
+    where
+        F: FnOnce(&mut Self) -> R,
+    {
+        let old = self.enable_incremental_gas_charging;
+        self.enable_incremental_gas_charging = enable;
+        let res = action(self);
+        self.enable_incremental_gas_charging = old;
+        res
+    }
+
+    /// Transforms a raw native function into a closure that can be used inside the Move VM.
+    ///
+    /// The closure will have access to the common Aptos configurations (features, gas params etc.),
+    /// allowing the client to use [`SafeNativeContext`] instead of Move VM's [`NativeContext`].
+    pub fn make_native<F>(&self, native: F) -> NativeFunction
+    where
+        F: Fn(
+                &mut SafeNativeContext,
+                Vec<Type>,
+                VecDeque<Value>,
+            ) -> SafeNativeResult<SmallVec<[Value; 1]>>
+            + Send
+            + Sync
+            + 'static,
+    {
+        let data = Arc::clone(&self.data);
+
+        let enable_incremental_gas_charging = self.enable_incremental_gas_charging;
+
+        let closure = move |context: &mut NativeContext, ty_args, args| {
+            use SafeNativeError::*;
+
+            let gas_budget = context.gas_balance();
+
+            let mut context = SafeNativeContext {
+                inner: context,
+
+                timed_features: &data.timed_features,
+                features: &data.features,
+                gas_feature_version: data.gas_feature_version,
+                native_gas_params: &data.native_gas_params,
+                misc_gas_params: &data.misc_gas_params,
+
+                gas_budget,
+                gas_used: 0.into(),
+
+                enable_incremental_gas_charging,
+            };
+
+            let res: Result<SmallVec<[Value; 1]>, SafeNativeError> =
+                native(&mut context, ty_args, args);
+
+            match res {
+                Ok(ret_vals) => Ok(NativeResult::ok(context.gas_used, ret_vals)),
+                Err(err) => match err {
+                    Abort { abort_code } => Ok(NativeResult::err(context.gas_used, abort_code)),
+                    OutOfGas => Ok(NativeResult::out_of_gas(context.gas_used)),
+                    // TODO(Gas): Check if err is indeed an invariant violation.
+                    InvariantViolation(err) => Err(err),
+                },
+            }
+        };
+
+        Arc::new(closure)
+    }
+
+    pub fn make_named_natives<'a, 'b, I, S, F>(
+        &'a self,
+        natives: I,
+    ) -> impl Iterator<Item = (String, NativeFunction)> + 'a
+    where
+        'b: 'a,
+        F: Fn(
+                &mut SafeNativeContext,
+                Vec<Type>,
+                VecDeque<Value>,
+            ) -> SafeNativeResult<SmallVec<[Value; 1]>>
+            + Send
+            + Sync
+            + 'static,
+        S: Into<String>,
+        I: IntoIterator<Item = (S, F)> + 'b,
+    {
+        natives
+            .into_iter()
+            .map(|(func_name, func)| (func_name.into(), self.make_native(func)))
+    }
+}
diff --git a/aptos-move/aptos-native-interface/src/context.rs b/aptos-move/aptos-native-interface/src/context.rs
new file mode 100644
index 0000000000000..f42ca2ba92525
--- /dev/null
+++ b/aptos-move/aptos-native-interface/src/context.rs
@@ -0,0 +1,112 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::errors::{SafeNativeError, SafeNativeResult};
+use aptos_gas_algebra::{AbstractValueSize, GasExpression, GasQuantity, InternalGasUnit};
+use aptos_gas_schedule::{MiscGasParameters, NativeGasParameters};
+use aptos_types::on_chain_config::{Features, TimedFeatureFlag, TimedFeatures};
+use move_core_types::gas_algebra::InternalGas;
+use move_vm_runtime::native_functions::NativeContext;
+use move_vm_types::values::Value;
+use std::ops::{Deref, DerefMut};
+
+/// A proxy between the VM and the native functions, allowing the latter to query VM configurations
+/// or access certain VM functionalities.
+///
+/// It is a wrapper around Move VM's [`NativeContext`], providing improved and Aptos-specific APIs.
+/// Major features include incremental gas charging and less ambiguous error handling. For this
+/// reason, native functions should always use [`SafeNativeContext`] instead of [`NativeContext`].
+#[allow(unused)]
+pub struct SafeNativeContext<'a, 'b, 'c, 'd> {
+    pub(crate) inner: &'c mut NativeContext<'a, 'b, 'd>,
+
+    pub(crate) timed_features: &'c TimedFeatures,
+    pub(crate) features: &'c Features,
+    pub(crate) gas_feature_version: u64,
+
+    pub(crate) native_gas_params: &'c NativeGasParameters,
+    pub(crate) misc_gas_params: &'c MiscGasParameters,
+
+    pub(crate) gas_budget: InternalGas,
+    pub(crate) gas_used: InternalGas,
+
+    pub(crate) enable_incremental_gas_charging: bool,
+}
+
+impl<'a, 'b, 'c, 'd> Deref for SafeNativeContext<'a, 'b, 'c, 'd> {
+    type Target = NativeContext<'a, 'b, 'd>;
+
+    fn deref(&self) -> &Self::Target {
+        self.inner
+    }
+}
+
+impl<'a, 'b, 'c, 'd> DerefMut for SafeNativeContext<'a, 'b, 'c, 'd> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.inner
+    }
+}
+
+impl<'a, 'b, 'c, 'd> SafeNativeContext<'a, 'b, 'c, 'd> {
+    /// Always remember: first charge gas, then execute!
+    ///
+    /// In other words, this function **MUST** always be called **BEFORE** executing **any**
+    /// gas-metered operation or library call within a native function.
+    #[must_use = "must always propagate the error returned by this function to the native function that called it using the ? operator"]
+    pub fn charge(
+        &mut self,
+        abstract_amount: impl GasExpression<NativeGasParameters, Unit = InternalGasUnit>,
+    ) -> SafeNativeResult<()> {
+        let amount = abstract_amount.evaluate(self.gas_feature_version, self.native_gas_params);
+
+        self.gas_used += amount;
+
+        if self.gas_used > self.gas_budget && self.enable_incremental_gas_charging {
+            Err(SafeNativeError::OutOfGas)
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Evaluates the given gas expression within the current context immediately.
+    ///
+    /// This can be useful if you have branch conditions depending on gas parameters.
+    pub fn eval_gas<E>(&self, abstract_amount: E) -> GasQuantity<E::Unit>
+    where
+        E: GasExpression<NativeGasParameters>,
+    {
+        abstract_amount.evaluate(self.gas_feature_version, self.native_gas_params)
+    }
+
+    /// Computes the abstract size of the input value.
+    pub fn abs_val_size(&self, val: &Value) -> AbstractValueSize {
+        self.misc_gas_params
+            .abs_val
+            .abstract_value_size(val, self.gas_feature_version)
+    }
+
+    /// Returns the current gas feature version.
+    pub fn gas_feature_version(&self) -> u64 {
+        self.gas_feature_version
+    }
+
+    /// Returns a reference to the struct representing on-chain features.
+    pub fn get_feature_flags(&self) -> &Features {
+        self.features.deref()
+    }
+
+    /// Checks if the timed feature corresponding to the given flag is enabled.
+    pub fn timed_feature_enabled(&self, flag: TimedFeatureFlag) -> bool {
+        self.timed_features.is_enabled(flag)
+    }
+
+    /// Configures the behavior of [`Self::charge()`].
+    /// - If enabled, it will return an out of gas error as soon as the amount of gas used
+    ///   exceeds the remaining balance.
+    /// - If disabled, it will not return early errors, but the gas usage is still recorded,
+    ///   and the total amount will be reported back to the VM after the native function returns.
+    ///   This should only be used for backward compatibility reasons.
+    pub fn set_incremental_gas_charging(&mut self, enable: bool) {
+        self.enable_incremental_gas_charging = enable;
+    }
+}
diff --git a/aptos-move/aptos-native-interface/src/errors.rs b/aptos-move/aptos-native-interface/src/errors.rs
new file mode 100644
index 0000000000000..82526557a4194
--- /dev/null
+++ b/aptos-move/aptos-native-interface/src/errors.rs
@@ -0,0 +1,42 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+use move_binary_format::errors::PartialVMError;
+
+/// Saner representation of a native function error.
+#[allow(unused)]
+pub enum SafeNativeError {
+    /// Indicating that the native function has aborted due to some (user) errors.
+    ///
+    /// Equivalent to aborting in a regular Move function, so the same error convention should
+    /// be followed.
+    Abort { abort_code: u64 },
+
+    /// Indicating that the native function has run out of gas during execution.
+    ///
+    /// This will cause the VM to deduct all the remaining balance and abort the transaction,
+    /// so use it carefully!
+    /// Normally this should only be triggered by `SafeNativeContext::charge()` and you should
+    /// not return this manually without a good reason.
+    OutOfGas,
+
+    /// Indicating that the native function ran into some internal errors that shall not normally
+    /// be triggerable by user inputs.
+    InvariantViolation(PartialVMError),
+}
+
+/// Allows us to keep using the `?` operator on function calls that return `PartialVMResult` inside safe natives.
+///
+/// TODO(Gas): This automatic conversion is VERY PROBLEMATIC as it makes it extremely easy to
+///            accidentally propagate a non-invariant violation, which is a violation of the
+///            contract.
+///
+///            We are actively seeking to remove this implementation.
+///            Please help us stop the bleed by not using this conversion.
+impl From<PartialVMError> for SafeNativeError {
+    fn from(e: PartialVMError) -> Self {
+        SafeNativeError::InvariantViolation(e)
+    }
+}
+
+pub type SafeNativeResult<T> = Result<T, SafeNativeError>;
diff --git a/aptos-move/aptos-native-interface/src/helpers.rs b/aptos-move/aptos-native-interface/src/helpers.rs
new file mode 100644
index 0000000000000..067733df8c2fb
--- /dev/null
+++ b/aptos-move/aptos-native-interface/src/helpers.rs
@@ -0,0 +1,92 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/// Like `pop_arg!` but for safe natives that return `SafeNativeResult<T>`. Will return a
+/// `SafeNativeError::InvariantViolation(UNKNOWN_INVARIANT_VIOLATION_ERROR)` when there aren't
+/// enough arguments on the stack.
+#[macro_export]
+macro_rules! safely_pop_arg {
+    ($args:ident, $t:ty) => {{
+        use $crate::reexports::move_vm_types::natives::function::{PartialVMError, StatusCode};
+        match $args.pop_back() {
+            Some(val) => match val.value_as::<$t>() {
+                Ok(v) => v,
+                Err(e) => return Err($crate::SafeNativeError::InvariantViolation(e)),
+            },
+            None => {
+                return Err($crate::SafeNativeError::InvariantViolation(
+                    PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR),
+                ))
+            },
+        }
+    }};
+}
+
+/// Like `assert_eq!` but for safe natives that return `SafeNativeResult<T>`. Instead of panicking,
+/// will return a `SafeNativeError::InvariantViolation(UNKNOWN_INVARIANT_VIOLATION_ERROR)`.
+#[macro_export]
+macro_rules! safely_assert_eq {
+    ($left:expr, $right:expr $(,)?) => {{
+        use $crate::reexports::move_vm_types::natives::function::{PartialVMError, StatusCode};
+        match (&$left, &$right) {
+            (left_val, right_val) => {
+                if !(*left_val == *right_val) {
+                    return Err($crate::SafeNativeError::InvariantViolation(
+                        PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR),
+                    ));
+                }
+            },
+        }
+    }};
+}
+
+/// Pops a `Type` argument off the type argument stack inside a safe native. Returns a
+/// `SafeNativeError::InvariantViolation(UNKNOWN_INVARIANT_VIOLATION_ERROR)` in case there are not
+/// enough arguments on the stack.
+///
+/// NOTE: Expects as its argument an object that has a `fn pop(&self) -> Option<_>` method (e.g., a `Vec<_>`)
+#[macro_export]
+macro_rules! safely_pop_type_arg {
+    ($ty_args:ident) => {{
+        use $crate::reexports::move_vm_types::natives::function::{PartialVMError, StatusCode};
+        match $ty_args.pop() {
+            Some(ty) => ty,
+            None => {
+                return Err($crate::SafeNativeError::InvariantViolation(
+                    PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR),
+                ))
+            },
+        }
+    }};
+}
+
+/// Like `pop_vec_arg` but for safe natives that return `SafeNativeResult<T>`.
+/// (Duplicates code from above, unfortunately.)
+#[macro_export]
+macro_rules! safely_pop_vec_arg {
+    ($arguments:ident, $t:ty) => {{
+        // Replicating the code from pop_arg! here
+        use $crate::reexports::move_vm_types::natives::function::{PartialVMError, StatusCode};
+        let value_vec = match $arguments.pop_back().map(|v| v.value_as::<Vec<Value>>()) {
+            None => {
+                return Err($crate::SafeNativeError::InvariantViolation(
+                    PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR)
+                ))
+            }
+            Some(Err(e)) => return Err($crate::SafeNativeError::InvariantViolation(e)),
+            Some(Ok(v)) => v,
+        };
+
+        // Pop each Value from the popped Vec<Value>, cast it as a Vec<u8>, and push it to a Vec<Vec<u8>>
+        let mut vec_vec = vec![];
+        for value in value_vec {
+            let vec = match value.value_as::<$t>() {
+                Err(e) => return Err($crate::SafeNativeError::InvariantViolation(e)),
+                Ok(v) => v,
+            };
+            vec_vec.push(vec);
+        }
+
+        vec_vec
+    }};
+}
diff --git a/aptos-move/aptos-native-interface/src/lib.rs b/aptos-move/aptos-native-interface/src/lib.rs
new file mode 100644
index 0000000000000..a898626012000
--- /dev/null
+++ b/aptos-move/aptos-native-interface/src/lib.rs
@@ -0,0 +1,26 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+//! This crate defines interfaces that enable the extension of the Aptos VM with native functions.
+//!
+//! Native functions provide the ability to incorporate semantics that cannot be expressed in
+//! normal Move programs.
+//!
+//! They are also commonly used to accelerate certain operations, such as cryptographic hashes,
+//! by executing them in native code.
+
+mod builder;
+mod context;
+mod errors;
+mod native;
+
+#[macro_use]
+mod helpers;
+
+#[doc(hidden)]
+pub mod reexports;
+
+pub use builder::SafeNativeBuilder;
+pub use context::SafeNativeContext;
+pub use errors::{SafeNativeError, SafeNativeResult};
+pub use native::RawSafeNative;
diff --git a/aptos-move/aptos-native-interface/src/native.rs b/aptos-move/aptos-native-interface/src/native.rs
new file mode 100644
index 0000000000000..e917307b85c81
--- /dev/null
+++ b/aptos-move/aptos-native-interface/src/native.rs
@@ -0,0 +1,17 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::{context::SafeNativeContext, errors::SafeNativeResult};
+use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
+use smallvec::SmallVec;
+use std::collections::VecDeque;
+
+/// Type alias representing a raw native function.
+///
+/// A raw native needs to be made into a closure that carries various configurations before
+/// it can be used in the VM.
+pub type RawSafeNative = fn(
+    &mut SafeNativeContext,
+    Vec<Type>,
+    VecDeque<Value>,
+) -> SafeNativeResult<SmallVec<[Value; 1]>>;
diff --git a/aptos-move/aptos-native-interface/src/reexports.rs b/aptos-move/aptos-native-interface/src/reexports.rs
new file mode 100644
index 0000000000000..45de1f5aaf3bd
--- /dev/null
+++ b/aptos-move/aptos-native-interface/src/reexports.rs
@@ -0,0 +1,4 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+pub use move_vm_types;
diff --git a/aptos-move/aptos-release-builder/Cargo.toml b/aptos-move/aptos-release-builder/Cargo.toml
index a6eaae561404a..847b6ddf310e2 100644
--- a/aptos-move/aptos-release-builder/Cargo.toml
+++ b/aptos-move/aptos-release-builder/Cargo.toml
@@ -19,7 +19,7 @@ aptos-api-types = { workspace = true }
 aptos-build-info = { workspace = true }
 aptos-crypto = { workspace = true }
 aptos-framework = { workspace = true }
-aptos-gas = { workspace = true }
+aptos-gas-schedule-updator = { workspace = true }
 aptos-genesis = { workspace = true }
 aptos-rest-client = { workspace = true }
 aptos-temppath = { workspace = true }
diff --git a/aptos-move/aptos-release-builder/src/components/mod.rs b/aptos-move/aptos-release-builder/src/components/mod.rs
index 9436efcdf6d25..fae1000465334 100644
--- a/aptos-move/aptos-release-builder/src/components/mod.rs
+++ b/aptos-move/aptos-release-builder/src/components/mod.rs
@@ -122,7 +122,7 @@ impl ReleaseEntry {
                 }
             },
             ReleaseEntry::DefaultGas => {
-                let gas_schedule = aptos_gas::gen::current_gas_schedule();
+                let gas_schedule = aptos_gas_schedule_updator::current_gas_schedule();
                 if !fetch_and_equals::<GasScheduleV2>(client, &gas_schedule)? {
                     result.append(&mut gas::generate_gas_upgrade_proposal(
                         &gas_schedule,
@@ -259,7 +259,10 @@ impl ReleaseEntry {
                 }
             },
             ReleaseEntry::DefaultGas => {
-                if !fetch_and_equals(client_opt, &aptos_gas::gen::current_gas_schedule())? {
+                if !fetch_and_equals(
+                    client_opt,
+                    &aptos_gas_schedule_updator::current_gas_schedule(),
+                )? {
                     bail!("Gas schedule config mismatch: Expected Default");
                 }
             },
diff --git a/aptos-move/aptos-transaction-benchmarks/Cargo.toml b/aptos-move/aptos-transaction-benchmarks/Cargo.toml
index 8fd334adc0533..c699d53eaedae 100644
--- a/aptos-move/aptos-transaction-benchmarks/Cargo.toml
+++ b/aptos-move/aptos-transaction-benchmarks/Cargo.toml
@@ -18,7 +18,7 @@ aptos-block-executor = { workspace = true }
 aptos-block-partitioner = { workspace = true }
 aptos-crypto = { workspace = true }
 aptos-executor-service = { workspace = true }
-aptos-gas = { workspace = true, features = ["testing"] }
+aptos-gas-meter = { workspace = true, features = ["testing"] }
 aptos-language-e2e-tests = { workspace = true }
 aptos-logger = { workspace = true }
 aptos-metrics-core = { workspace = true }
diff --git a/aptos-move/aptos-transactional-test-harness/Cargo.toml b/aptos-move/aptos-transactional-test-harness/Cargo.toml
index a3547801eb816..058bdf82ac13b 100644
--- a/aptos-move/aptos-transactional-test-harness/Cargo.toml
+++ b/aptos-move/aptos-transactional-test-harness/Cargo.toml
@@ -18,7 +18,7 @@ aptos-api-types = { workspace = true }
 aptos-cached-packages = { workspace = true }
 aptos-crypto = { workspace = true }
 aptos-framework = { workspace = true }
-aptos-gas = { workspace = true }
+aptos-gas-schedule = { workspace = true }
 aptos-language-e2e-tests = { workspace = true }
 aptos-state-view = { workspace = true }
 aptos-storage-interface = { workspace = true }
diff --git a/aptos-move/aptos-transactional-test-harness/src/aptos_test_harness.rs b/aptos-move/aptos-transactional-test-harness/src/aptos_test_harness.rs
index 986caf304e9d9..656023ca498da 100644
--- a/aptos-move/aptos-transactional-test-harness/src/aptos_test_harness.rs
+++ b/aptos-move/aptos-transactional-test-harness/src/aptos_test_harness.rs
@@ -9,7 +9,7 @@ use aptos_crypto::{
     hash::HashValue,
     ValidCryptoMaterialStringExt,
 };
-use aptos_gas::{InitialGasSchedule, TransactionGasParameters};
+use aptos_gas_schedule::{InitialGasSchedule, TransactionGasParameters};
 use aptos_language_e2e_tests::data_store::{FakeDataStore, GENESIS_CHANGE_SET_HEAD};
 use aptos_state_view::TStateView;
 use aptos_types::{
diff --git a/aptos-move/aptos-vm-profiling/Cargo.toml b/aptos-move/aptos-vm-profiling/Cargo.toml
index 9109f9251f7a4..c12140318da16 100644
--- a/aptos-move/aptos-vm-profiling/Cargo.toml
+++ b/aptos-move/aptos-vm-profiling/Cargo.toml
@@ -18,8 +18,11 @@ once_cell = { workspace = true }
 smallvec = { workspace = true }
 
 aptos-cached-packages = { workspace = true }
+aptos-gas-schedule = { workspace = true }
 aptos-language-e2e-tests = { workspace = true }
 aptos-move-stdlib = { workspace = true }
+aptos-native-interface = { workspace = true }
+aptos-table-natives = { workspace = true }
 aptos-types = { workspace = true }
 aptos-vm = { workspace = true }
 aptos-vm-genesis = { workspace = true }
@@ -27,7 +30,6 @@ aptos-vm-genesis = { workspace = true }
 move-binary-format = { workspace = true }
 move-core-types = { workspace = true }
 move-ir-compiler = { workspace = true }
-move-table-extension = { workspace = true }
 move-vm-runtime = { workspace = true }
 move-vm-test-utils = { workspace = true }
 move-vm-types = { workspace = true }
diff --git a/aptos-move/aptos-vm-profiling/src/bins/run_move.rs b/aptos-move/aptos-vm-profiling/src/bins/run_move.rs
index 65ae38177507b..c4923f2aabbed 100644
--- a/aptos-move/aptos-vm-profiling/src/bins/run_move.rs
+++ b/aptos-move/aptos-vm-profiling/src/bins/run_move.rs
@@ -2,11 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use anyhow::{bail, Result};
-use aptos_move_stdlib::natives::{all_natives, GasParameters};
+use aptos_gas_schedule::{MiscGasParameters, NativeGasParameters, LATEST_GAS_FEATURE_VERSION};
+use aptos_move_stdlib::natives::all_natives;
+use aptos_native_interface::SafeNativeBuilder;
+use aptos_types::on_chain_config::{Features, TimedFeatures};
 use move_binary_format::CompiledModule;
 use move_core_types::{account_address::AccountAddress, ident_str, identifier::Identifier};
 use move_ir_compiler::Compiler;
-use move_table_extension::{self, NativeTableContext};
 use move_vm_runtime::{
     move_vm::MoveVM, native_extensions::NativeContextExtensions, native_functions::NativeFunction,
 };
@@ -125,18 +127,27 @@ fn main() -> Result<()> {
         bail!("Wrong number of arguments.")
     }
 
+    let mut builder = SafeNativeBuilder::new(
+        LATEST_GAS_FEATURE_VERSION,
+        NativeGasParameters::zeros(),
+        MiscGasParameters::zeros(),
+        TimedFeatures::enable_all(),
+        Features::default(),
+    );
+
     let stdlib_addr = AccountAddress::from_hex_literal("0x1").unwrap();
-    let mut natives = all_natives(stdlib_addr, GasParameters::zeros());
+    let mut natives = all_natives(stdlib_addr, &mut builder);
     natives.push((
         stdlib_addr,
         Identifier::new("Test").unwrap(),
         Identifier::new("create_signer").unwrap(),
         make_native_create_signer(),
     ));
-    natives.extend(move_table_extension::table_natives(
-        stdlib_addr,
-        move_table_extension::GasParameters::zeros(),
-    ));
+    // FIXME: Find a way to re-enalbe this.
+    //natives.extend(aptos_table_natives::table_natives(
+    //    stdlib_addr,
+    //    &mut builder,
+    //));
 
     let vm = MoveVM::new(natives).unwrap();
     let mut storage = InMemoryStorage::new();
@@ -148,8 +159,8 @@ fn main() -> Result<()> {
         storage.publish_or_overwrite_module(module.self_id(), blob);
     }
 
-    let mut extensions = NativeContextExtensions::default();
-    extensions.add(NativeTableContext::new([0; 32], &storage));
+    let extensions = NativeContextExtensions::default();
+    //extensions.add(NativeTableContext::new([0; 32], &storage));
 
     let mut sess = vm.new_session_with_extensions(&storage, extensions);
 
diff --git a/aptos-move/aptos-vm-types/Cargo.toml b/aptos-move/aptos-vm-types/Cargo.toml
index d8990e5eaa6ab..99be32dd228a4 100644
--- a/aptos-move/aptos-vm-types/Cargo.toml
+++ b/aptos-move/aptos-vm-types/Cargo.toml
@@ -15,8 +15,11 @@ rust-version = { workspace = true }
 [dependencies]
 anyhow = { workspace = true }
 aptos-aggregator = { workspace = true }
+aptos-gas-algebra = { workspace = true }
+aptos-gas-schedule = { workspace = true }
 aptos-state-view = { workspace = true }
 aptos-types = { workspace = true }
+either = { workspace = true }
 move-binary-format = { workspace = true }
 move-core-types = { workspace = true }
 
diff --git a/aptos-move/aptos-vm-types/src/lib.rs b/aptos-move/aptos-vm-types/src/lib.rs
index 14538a370d0a0..42708c1d1f4fc 100644
--- a/aptos-move/aptos-vm-types/src/lib.rs
+++ b/aptos-move/aptos-vm-types/src/lib.rs
@@ -4,6 +4,7 @@
 pub mod change_set;
 pub mod check_change_set;
 pub mod output;
+pub mod storage;
 
 #[cfg(test)]
 mod tests;
diff --git a/aptos-move/aptos-gas-schedule/src/gas_params/storage.rs b/aptos-move/aptos-vm-types/src/storage.rs
similarity index 87%
rename from aptos-move/aptos-gas-schedule/src/gas_params/storage.rs
rename to aptos-move/aptos-vm-types/src/storage.rs
index ef6ace1c29da8..dfc646051f942 100644
--- a/aptos-move/aptos-gas-schedule/src/gas_params/storage.rs
+++ b/aptos-move/aptos-vm-types/src/storage.rs
@@ -1,17 +1,16 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{
-    gas_params::{transaction::gas_params::*, AptosGasParameters},
-    ver::LATEST_GAS_FEATURE_VERSION,
-};
+use crate::{change_set::VMChangeSet, check_change_set::CheckChangeSet};
 use aptos_gas_algebra::GasExpression;
+use aptos_gas_schedule::{
+    gas_params::txn::*, AptosGasParameters, VMGasParameters, LATEST_GAS_FEATURE_VERSION,
+};
 use aptos_types::{
     on_chain_config::{ConfigStorage, OnChainConfig, StorageGasSchedule},
     state_store::state_key::StateKey,
     write_set::WriteOp,
 };
-use aptos_vm_types::{change_set::VMChangeSet, check_change_set::CheckChangeSet};
 use either::Either;
 use move_core_types::{
     gas_algebra::{
@@ -35,13 +34,13 @@ pub struct StoragePricingV1 {
 impl StoragePricingV1 {
     fn new(gas_params: &AptosGasParameters) -> Self {
         Self {
-            write_data_per_op: gas_params.txn.storage_io_per_state_slot_write,
-            write_data_per_new_item: gas_params.txn.write_data_per_new_item,
-            write_data_per_byte_in_key: gas_params.txn.storage_io_per_state_byte_write,
-            write_data_per_byte_in_val: gas_params.txn.write_data_per_byte_in_val,
-            load_data_base: gas_params.txn.storage_io_per_state_slot_read * NumArgs::new(1),
-            load_data_per_byte: gas_params.txn.storage_io_per_state_byte_read,
-            load_data_failure: gas_params.txn.load_data_failure,
+            write_data_per_op: gas_params.vm.txn.storage_io_per_state_slot_write,
+            write_data_per_new_item: gas_params.vm.txn.write_data_per_new_item,
+            write_data_per_byte_in_key: gas_params.vm.txn.storage_io_per_state_byte_write,
+            write_data_per_byte_in_val: gas_params.vm.txn.write_data_per_byte_in_val,
+            load_data_base: gas_params.vm.txn.storage_io_per_state_slot_read * NumArgs::new(1),
+            load_data_per_byte: gas_params.vm.txn.storage_io_per_state_byte_read,
+            load_data_failure: gas_params.vm.txn.load_data_failure,
         }
     }
 }
@@ -125,12 +124,12 @@ impl StoragePricingV2 {
         Self {
             feature_version,
             free_write_bytes_quota: Self::get_free_write_bytes_quota(feature_version, gas_params),
-            per_item_read: gas_params.txn.storage_io_per_state_slot_read,
-            per_item_create: gas_params.txn.storage_io_per_state_slot_write,
-            per_item_write: gas_params.txn.storage_io_per_state_slot_write,
-            per_byte_read: gas_params.txn.storage_io_per_state_byte_read,
-            per_byte_create: gas_params.txn.storage_io_per_state_byte_write,
-            per_byte_write: gas_params.txn.storage_io_per_state_byte_write,
+            per_item_read: gas_params.vm.txn.storage_io_per_state_slot_read,
+            per_item_create: gas_params.vm.txn.storage_io_per_state_slot_write,
+            per_item_write: gas_params.vm.txn.storage_io_per_state_slot_write,
+            per_byte_read: gas_params.vm.txn.storage_io_per_state_byte_read,
+            per_byte_create: gas_params.vm.txn.storage_io_per_state_byte_write,
+            per_byte_write: gas_params.vm.txn.storage_io_per_state_byte_write,
         }
     }
 
@@ -142,7 +141,7 @@ impl StoragePricingV2 {
             0 => unreachable!("PricingV2 not applicable for feature version 0"),
             1..=2 => 0.into(),
             3..=4 => 1024.into(),
-            5.. => gas_params.txn.free_write_bytes_quota,
+            5.. => gas_params.vm.txn.free_write_bytes_quota,
         }
     }
 
@@ -196,7 +195,7 @@ impl StoragePricingV3 {
     fn calculate_read_gas(
         &self,
         loaded: NumBytes,
-    ) -> impl GasExpression<AptosGasParameters, Unit = InternalGasUnit> {
+    ) -> impl GasExpression<VMGasParameters, Unit = InternalGasUnit> {
         STORAGE_IO_PER_STATE_SLOT_READ * NumArgs::from(1) + STORAGE_IO_PER_STATE_BYTE_READ * loaded
     }
 
@@ -213,7 +212,7 @@ impl StoragePricingV3 {
         &self,
         key: &StateKey,
         op: &WriteOp,
-    ) -> impl GasExpression<AptosGasParameters, Unit = InternalGasUnit> {
+    ) -> impl GasExpression<VMGasParameters, Unit = InternalGasUnit> {
         use WriteOp::*;
 
         match op {
@@ -265,7 +264,7 @@ impl StoragePricing {
         &self,
         resource_exists: bool,
         bytes_loaded: NumBytes,
-    ) -> impl GasExpression<AptosGasParameters, Unit = InternalGasUnit> {
+    ) -> impl GasExpression<VMGasParameters, Unit = InternalGasUnit> {
         use StoragePricing::*;
 
         match self {
@@ -285,7 +284,7 @@ impl StoragePricing {
         &self,
         key: &StateKey,
         op: &WriteOp,
-    ) -> impl GasExpression<AptosGasParameters, Unit = InternalGasUnit> {
+    ) -> impl GasExpression<VMGasParameters, Unit = InternalGasUnit> {
         use StoragePricing::*;
 
         match self {
@@ -354,13 +353,18 @@ impl ChangeSetConfigs {
     fn from_gas_params(gas_feature_version: u64, gas_params: &AptosGasParameters) -> Self {
         Self::new_impl(
             gas_feature_version,
-            gas_params.txn.max_bytes_per_write_op.into(),
+            gas_params.vm.txn.max_bytes_per_write_op.into(),
             gas_params
+                .vm
                 .txn
                 .max_bytes_all_write_ops_per_transaction
                 .into(),
-            gas_params.txn.max_bytes_per_event.into(),
-            gas_params.txn.max_bytes_all_events_per_transaction.into(),
+            gas_params.vm.txn.max_bytes_per_event.into(),
+            gas_params
+                .vm
+                .txn
+                .max_bytes_all_events_per_transaction
+                .into(),
         )
     }
 }
diff --git a/aptos-move/aptos-vm/Cargo.toml b/aptos-move/aptos-vm/Cargo.toml
index 46a1e0a69fb6d..4b7b578e6508d 100644
--- a/aptos-move/aptos-vm/Cargo.toml
+++ b/aptos-move/aptos-vm/Cargo.toml
@@ -20,8 +20,8 @@ aptos-block-partitioner = { workspace = true }
 aptos-crypto = { workspace = true }
 aptos-crypto-derive = { workspace = true }
 aptos-framework =  { workspace = true }
-aptos-gas = { workspace = true }
 aptos-gas-algebra = { workspace = true }
+aptos-gas-meter = { workspace = true }
 aptos-gas-schedule = { workspace = true }
 aptos-infallible = { workspace = true }
 aptos-logger = { workspace = true }
@@ -29,7 +29,9 @@ aptos-memory-usage-tracker = { workspace = true }
 aptos-metrics-core = { workspace = true }
 aptos-move-stdlib = { workspace = true }
 aptos-mvhashmap = { workspace = true }
+aptos-native-interface = { workspace = true }
 aptos-state-view = { workspace = true }
+aptos-table-natives = { workspace = true }
 aptos-types = { workspace = true }
 aptos-utils = { workspace = true }
 aptos-vm-logging = { workspace = true }
@@ -42,7 +44,6 @@ move-binary-format = { workspace = true }
 move-bytecode-utils = { workspace = true }
 move-bytecode-verifier = { workspace = true }
 move-core-types = { workspace = true }
-move-table-extension = { workspace = true }
 move-unit-test = { workspace = true, optional = true }
 move-vm-runtime = { workspace = true }
 move-vm-test-utils = { workspace = true }
diff --git a/aptos-move/aptos-vm/src/aptos_vm.rs b/aptos-move/aptos-vm/src/aptos_vm.rs
index ec2ed57f61442..262f53b584363 100644
--- a/aptos-move/aptos-vm/src/aptos_vm.rs
+++ b/aptos-move/aptos-vm/src/aptos_vm.rs
@@ -22,11 +22,9 @@ use aptos_aggregator::delta_change_set::DeltaChangeSet;
 use aptos_block_executor::txn_commit_hook::NoOpTransactionCommitHook;
 use aptos_crypto::HashValue;
 use aptos_framework::natives::code::PublishRequest;
-use aptos_gas::{
-    AptosGasMeter, AptosGasParameters, ChangeSetConfigs, StandardGasAlgebra, StandardGasMeter,
-    StorageGasParameters,
-};
 use aptos_gas_algebra::Gas;
+use aptos_gas_meter::{AptosGasMeter, StandardGasAlgebra, StandardGasMeter};
+use aptos_gas_schedule::VMGasParameters;
 use aptos_logger::{enabled, prelude::*, Level};
 use aptos_memory_usage_tracker::MemoryTrackedGasMeter;
 use aptos_state_view::StateView;
@@ -48,7 +46,11 @@ use aptos_types::{
 };
 use aptos_utils::{aptos_try, return_on_failure};
 use aptos_vm_logging::{log_schema::AdapterLogSchema, speculative_error, speculative_log};
-use aptos_vm_types::{change_set::VMChangeSet, output::VMOutput};
+use aptos_vm_types::{
+    change_set::VMChangeSet,
+    output::VMOutput,
+    storage::{ChangeSetConfigs, StorageGasParameters},
+};
 use fail::fail_point;
 use move_binary_format::{
     access::ModuleAccess,
@@ -1016,7 +1018,7 @@ impl AptosVM {
         Ok(MemoryTrackedGasMeter::new(StandardGasMeter::new(
             StandardGasAlgebra::new(
                 self.0.get_gas_feature_version(),
-                self.0.get_gas_parameters(log_context)?.clone(),
+                self.0.get_gas_parameters(log_context)?.vm.clone(),
                 self.0.get_storage_gas_parameters(log_context)?.clone(),
                 balance,
             ),
@@ -1159,7 +1161,7 @@ impl AptosVM {
     ) -> Result<(VMStatus, VMOutput, G), VMStatus>
     where
         G: AptosGasMeter,
-        F: FnOnce(u64, AptosGasParameters, StorageGasParameters, Gas) -> Result<G, VMStatus>,
+        F: FnOnce(u64, VMGasParameters, StorageGasParameters, Gas) -> Result<G, VMStatus>,
     {
         // TODO(Gas): revisit this.
         let vm = AptosVM::new(state_view);
@@ -1168,7 +1170,7 @@ impl AptosVM {
         let balance = TransactionMetadata::new(txn).max_gas_amount();
         let mut gas_meter = make_gas_meter(
             vm.0.get_gas_feature_version(),
-            vm.0.get_gas_parameters(log_context)?.clone(),
+            vm.0.get_gas_parameters(log_context)?.vm.clone(),
             vm.0.get_storage_gas_parameters(log_context)?.clone(),
             balance,
         )?;
@@ -1408,7 +1410,7 @@ impl AptosVM {
         let mut gas_meter =
             MemoryTrackedGasMeter::new(StandardGasMeter::new(StandardGasAlgebra::new(
                 vm.0.get_gas_feature_version(),
-                vm.0.get_gas_parameters(&log_context)?.clone(),
+                vm.0.get_gas_parameters(&log_context)?.vm.clone(),
                 vm.0.get_storage_gas_parameters(&log_context)?.clone(),
                 gas_budget,
             )));
@@ -1851,7 +1853,7 @@ impl AptosSimulationVM {
         let mut gas_meter =
             MemoryTrackedGasMeter::new(StandardGasMeter::new(StandardGasAlgebra::new(
                 self.0 .0.get_gas_feature_version(),
-                gas_params.clone(),
+                gas_params.vm.clone(),
                 storage_gas_params.clone(),
                 txn_data.max_gas_amount(),
             )));
diff --git a/aptos-move/aptos-vm/src/aptos_vm_impl.rs b/aptos-move/aptos-vm/src/aptos_vm_impl.rs
index a67f4dafc75ee..1c3e02379cb30 100644
--- a/aptos-move/aptos-vm/src/aptos_vm_impl.rs
+++ b/aptos-move/aptos-vm/src/aptos_vm_impl.rs
@@ -12,11 +12,10 @@ use crate::{
     transaction_validation::APTOS_TRANSACTION_VALIDATION,
 };
 use aptos_framework::RuntimeModuleMetadataV1;
-use aptos_gas::{
-    AbstractValueSizeGasParameters, AptosGasParameters, ChangeSetConfigs, FromOnChainGasSchedule,
-    NativeGasParameters, StorageGasParameters, StoragePricing,
-};
 use aptos_gas_algebra::{Gas, GasExpression};
+use aptos_gas_schedule::{
+    AptosGasParameters, FromOnChainGasSchedule, MiscGasParameters, NativeGasParameters,
+};
 use aptos_logger::{enabled, prelude::*, Level};
 use aptos_state_view::StateView;
 use aptos_types::{
@@ -31,7 +30,10 @@ use aptos_types::{
     vm_status::{StatusCode, VMStatus},
 };
 use aptos_vm_logging::{log_schema::AdapterLogSchema, prelude::*};
-use aptos_vm_types::output::VMOutput;
+use aptos_vm_types::{
+    output::VMOutput,
+    storage::{ChangeSetConfigs, StorageGasParameters, StoragePricing},
+};
 use fail::fail_point;
 use move_binary_format::{errors::VMResult, CompiledModule};
 use move_core_types::{
@@ -90,20 +92,20 @@ impl AptosVMImpl {
 
                 if let StoragePricing::V2(pricing) = &storage_gas_params.pricing {
                     // Overwrite table io gas parameters with global io pricing.
-                    let g = &mut gas_params.natives.table.common;
+                    let g = &mut gas_params.natives.table;
                     match gas_feature_version {
                         0..=1 => (),
                         2..=6 => {
-                            g.load_base_legacy = pricing.per_item_read * NumArgs::new(1);
-                            g.load_base_new = 0.into();
-                            g.load_per_byte = pricing.per_byte_read;
-                            g.load_failure = 0.into();
+                            g.common_load_base_legacy = pricing.per_item_read * NumArgs::new(1);
+                            g.common_load_base_new = 0.into();
+                            g.common_load_per_byte = pricing.per_byte_read;
+                            g.common_load_failure = 0.into();
                         },
                         7.. => {
-                            g.load_base_legacy = 0.into();
-                            g.load_base_new = pricing.per_item_read * NumArgs::new(1);
-                            g.load_per_byte = pricing.per_byte_read;
-                            g.load_failure = 0.into();
+                            g.common_load_base_legacy = 0.into();
+                            g.common_load_base_new = pricing.per_item_read * NumArgs::new(1);
+                            g.common_load_per_byte = pricing.per_byte_read;
+                            g.common_load_failure = 0.into();
                         },
                     }
                 }
@@ -116,12 +118,9 @@ impl AptosVMImpl {
         //            This only happens in a edge case that is probably related to write set transactions or genesis,
         //            which logically speaking, shouldn't be handled by the VM at all.
         //            We should clean up the logic here once we get that refactored.
-        let (native_gas_params, abs_val_size_gas_params) = match &gas_params {
-            Ok(gas_params) => (gas_params.natives.clone(), gas_params.misc.abs_val.clone()),
-            Err(_) => (
-                NativeGasParameters::zeros(),
-                AbstractValueSizeGasParameters::zeros(),
-            ),
+        let (native_gas_params, misc_gas_params) = match &gas_params {
+            Ok(gas_params) => (gas_params.natives.clone(), gas_params.vm.misc.clone()),
+            Err(_) => (NativeGasParameters::zeros(), MiscGasParameters::zeros()),
         };
 
         let features = Features::fetch_config(&storage).unwrap_or_default();
@@ -140,7 +139,7 @@ impl AptosVMImpl {
 
         let move_vm = MoveVmExt::new(
             native_gas_params,
-            abs_val_size_gas_params,
+            misc_gas_params,
             gas_feature_version,
             chain_id.id(),
             features.clone(),
@@ -213,7 +212,7 @@ impl AptosVMImpl {
         log_context: &AdapterLogSchema,
     ) -> Result<(), VMStatus> {
         let gas_params = self.get_gas_parameters(log_context)?;
-        let txn_gas_params = &gas_params.txn;
+        let txn_gas_params = &gas_params.vm.txn;
         let raw_bytes_len = txn_data.transaction_size;
         // The transaction is too large.
         if txn_data.transaction_size > txn_gas_params.max_transaction_size_in_bytes {
@@ -282,7 +281,7 @@ impl AptosVMImpl {
         // underlying `RawTransaction`
         let intrinsic_gas = txn_gas_params
             .calculate_intrinsic_gas(raw_bytes_len)
-            .materialize(self.gas_feature_version, gas_params)
+            .evaluate(self.gas_feature_version, &gas_params.vm)
             .to_unit_round_up_with_params(txn_gas_params);
 
         if txn_data.max_gas_amount() < intrinsic_gas {
diff --git a/aptos-move/aptos-vm/src/data_cache.rs b/aptos-move/aptos-vm/src/data_cache.rs
index 7f75f3d4d8bcb..7f0f38abad7c5 100644
--- a/aptos-move/aptos-vm/src/data_cache.rs
+++ b/aptos-move/aptos-vm/src/data_cache.rs
@@ -11,6 +11,7 @@ use crate::{
 use anyhow::Error;
 use aptos_framework::natives::state_storage::StateStorageUsageResolver;
 use aptos_state_view::StateView;
+use aptos_table_natives::{TableHandle, TableResolver};
 use aptos_types::{
     access_path::AccessPath,
     on_chain_config::{ConfigStorage, Features, OnChainConfig},
@@ -24,7 +25,6 @@ use move_core_types::{
     resolver::{resource_size, ModuleResolver, ResourceResolver},
     vm_status::StatusCode,
 };
-use move_table_extension::{TableHandle, TableResolver};
 use std::{cell::RefCell, collections::BTreeMap, ops::Deref};
 
 pub(crate) fn get_resource_group_from_metadata(
diff --git a/aptos-move/aptos-vm/src/move_vm_ext/resolver.rs b/aptos-move/aptos-vm/src/move_vm_ext/resolver.rs
index f90654d6bc428..c19aed8b826fa 100644
--- a/aptos-move/aptos-vm/src/move_vm_ext/resolver.rs
+++ b/aptos-move/aptos-vm/src/move_vm_ext/resolver.rs
@@ -3,13 +3,13 @@
 
 use aptos_framework::natives::state_storage::StateStorageUsageResolver;
 use aptos_state_view::StateView;
+use aptos_table_natives::TableResolver;
 use aptos_types::on_chain_config::ConfigStorage;
 use aptos_utils::aptos_try;
 use move_binary_format::errors::VMResult;
 use move_core_types::{
     account_address::AccountAddress, language_storage::StructTag, resolver::MoveResolver,
 };
-use move_table_extension::TableResolver;
 use std::collections::BTreeMap;
 
 pub trait MoveResolverExt:
diff --git a/aptos-move/aptos-vm/src/move_vm_ext/respawned_session.rs b/aptos-move/aptos-vm/src/move_vm_ext/respawned_session.rs
index c156c24e7ab96..78604462ab2f3 100644
--- a/aptos-move/aptos-vm/src/move_vm_ext/respawned_session.rs
+++ b/aptos-move/aptos-vm/src/move_vm_ext/respawned_session.rs
@@ -7,7 +7,6 @@ use crate::{
     move_vm_ext::{SessionExt, SessionId},
 };
 use anyhow::{bail, Result};
-use aptos_gas::ChangeSetConfigs;
 use aptos_state_view::{StateView, StateViewId, TStateView};
 use aptos_types::{
     state_store::{
@@ -15,7 +14,7 @@ use aptos_types::{
     },
     write_set::TransactionWrite,
 };
-use aptos_vm_types::change_set::VMChangeSet;
+use aptos_vm_types::{change_set::VMChangeSet, storage::ChangeSetConfigs};
 use move_core_types::vm_status::{err_msg, StatusCode, VMStatus};
 
 /// We finish the session after the user transaction is done running to get the change set and
diff --git a/aptos-move/aptos-vm/src/move_vm_ext/session.rs b/aptos-move/aptos-vm/src/move_vm_ext/session.rs
index b87680e0ff59b..62264d8174999 100644
--- a/aptos-move/aptos-vm/src/move_vm_ext/session.rs
+++ b/aptos-move/aptos-vm/src/move_vm_ext/session.rs
@@ -15,7 +15,7 @@ use aptos_framework::natives::{
     aggregator_natives::{AggregatorChange, AggregatorChangeSet, NativeAggregatorContext},
     code::{NativeCodeContext, PublishRequest},
 };
-use aptos_gas::ChangeSetConfigs;
+use aptos_table_natives::{NativeTableContext, TableChangeSet};
 use aptos_types::{
     block_metadata::BlockMetadata,
     contract_event::ContractEvent,
@@ -24,7 +24,7 @@ use aptos_types::{
     transaction::SignatureCheckedTransaction,
     write_set::{WriteOp, WriteSetMut},
 };
-use aptos_vm_types::change_set::VMChangeSet;
+use aptos_vm_types::{change_set::VMChangeSet, storage::ChangeSetConfigs};
 use move_binary_format::errors::{Location, PartialVMError, VMResult};
 use move_core_types::{
     account_address::AccountAddress,
@@ -34,7 +34,6 @@ use move_core_types::{
     language_storage::{ModuleId, StructTag},
     vm_status::{err_msg, StatusCode, VMStatus},
 };
-use move_table_extension::{NativeTableContext, TableChangeSet};
 use move_vm_runtime::{move_vm::MoveVM, session::Session};
 use serde::{Deserialize, Serialize};
 use std::{
diff --git a/aptos-move/aptos-vm/src/move_vm_ext/vm.rs b/aptos-move/aptos-vm/src/move_vm_ext/vm.rs
index 5f5c411ee1a52..f879f05016d5b 100644
--- a/aptos-move/aptos-vm/src/move_vm_ext/vm.rs
+++ b/aptos-move/aptos-vm/src/move_vm_ext/vm.rs
@@ -12,11 +12,11 @@ use aptos_framework::natives::{
     state_storage::NativeStateStorageContext,
     transaction_context::NativeTransactionContext,
 };
-use aptos_gas::{AbstractValueSizeGasParameters, NativeGasParameters};
+use aptos_gas_schedule::{MiscGasParameters, NativeGasParameters};
+use aptos_table_natives::NativeTableContext;
 use aptos_types::on_chain_config::{FeatureFlag, Features, TimedFeatureFlag, TimedFeatures};
 use move_binary_format::errors::VMResult;
 use move_bytecode_verifier::VerifierConfig;
-use move_table_extension::NativeTableContext;
 use move_vm_runtime::{
     config::VMConfig, move_vm::MoveVM, native_extensions::NativeContextExtensions,
 };
@@ -39,7 +39,7 @@ pub fn get_max_binary_format_version(features: &Features, gas_feature_version: u
 impl MoveVmExt {
     pub fn new(
         native_gas_params: NativeGasParameters,
-        abs_val_size_gas_params: AbstractValueSizeGasParameters,
+        misc_gas_params: MiscGasParameters,
         gas_feature_version: u64,
         chain_id: u8,
         features: Features,
@@ -56,14 +56,13 @@ impl MoveVmExt {
         let type_size_limit = true;
 
         let verifier_config = verifier_config(&features, &timed_features);
-        let features = Arc::new(features);
 
         Ok(Self {
             inner: MoveVM::new_with_config(
                 aptos_natives(
-                    native_gas_params,
-                    abs_val_size_gas_params,
                     gas_feature_version,
+                    native_gas_params,
+                    misc_gas_params,
                     timed_features,
                     features.clone(),
                 ),
@@ -77,7 +76,7 @@ impl MoveVmExt {
                 },
             )?,
             chain_id,
-            features,
+            features: Arc::new(features),
         })
     }
 
diff --git a/aptos-move/aptos-vm/src/natives.rs b/aptos-move/aptos-vm/src/natives.rs
index de27dc288f01d..b158438d71c52 100644
--- a/aptos-move/aptos-vm/src/natives.rs
+++ b/aptos-move/aptos-vm/src/natives.rs
@@ -4,8 +4,8 @@
 
 #[cfg(feature = "testing")]
 use aptos_framework::natives::cryptography::algebra::AlgebraContext;
-use aptos_gas::{AbstractValueSizeGasParameters, NativeGasParameters};
-use aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION;
+use aptos_gas_schedule::{MiscGasParameters, NativeGasParameters, LATEST_GAS_FEATURE_VERSION};
+use aptos_native_interface::SafeNativeBuilder;
 #[cfg(feature = "testing")]
 use aptos_types::chain_id::ChainId;
 use aptos_types::{
@@ -13,7 +13,6 @@ use aptos_types::{
     on_chain_config::{Features, TimedFeatures},
 };
 use move_vm_runtime::native_functions::NativeFunctionTable;
-use std::sync::Arc;
 #[cfg(feature = "testing")]
 use {
     aptos_framework::natives::{
@@ -30,26 +29,31 @@ use {
 static DUMMY_RESOLVER: Lazy<BlankStorage> = Lazy::new(|| BlankStorage);
 
 pub fn aptos_natives(
-    gas_params: NativeGasParameters,
-    abs_val_size_gas_params: AbstractValueSizeGasParameters,
     gas_feature_version: u64,
+    native_gas_params: NativeGasParameters,
+    misc_gas_params: MiscGasParameters,
     timed_features: TimedFeatures,
-    features: Arc<Features>,
+    features: Features,
 ) -> NativeFunctionTable {
-    aptos_move_stdlib::natives::all_natives(CORE_CODE_ADDRESS, gas_params.move_stdlib.clone())
+    let mut builder = SafeNativeBuilder::new(
+        gas_feature_version,
+        native_gas_params,
+        misc_gas_params,
+        timed_features,
+        features,
+    );
+
+    #[allow(unreachable_code)]
+    aptos_move_stdlib::natives::all_natives(CORE_CODE_ADDRESS, &mut builder)
         .into_iter()
         .filter(|(_, name, _, _)| name.as_str() != "vector")
         .chain(aptos_framework::natives::all_natives(
             CORE_CODE_ADDRESS,
-            gas_params.move_stdlib,
-            gas_params.aptos_framework,
-            timed_features,
-            features,
-            move |val| abs_val_size_gas_params.abstract_value_size(val, gas_feature_version),
+            &builder,
         ))
-        .chain(move_table_extension::table_natives(
+        .chain(aptos_table_natives::table_natives(
             CORE_CODE_ADDRESS,
-            gas_params.table,
+            &mut builder,
         ))
         .collect()
 }
@@ -57,11 +61,11 @@ pub fn aptos_natives(
 pub fn assert_no_test_natives(err_msg: &str) {
     assert!(
         aptos_natives(
-            NativeGasParameters::zeros(),
-            AbstractValueSizeGasParameters::zeros(),
             LATEST_GAS_FEATURE_VERSION,
+            NativeGasParameters::zeros(),
+            MiscGasParameters::zeros(),
             TimedFeatures::enable_all(),
-            Arc::new(Features::default())
+            Features::default()
         )
         .into_iter()
         .all(|(_, module_name, func_name, _)| {
@@ -91,6 +95,9 @@ pub fn configure_for_unit_test() {
 
 #[cfg(feature = "testing")]
 fn unit_test_extensions_hook(exts: &mut NativeContextExtensions) {
+    use aptos_table_natives::NativeTableContext;
+
+    exts.add(NativeTableContext::new([0u8; 32], &*DUMMY_RESOLVER));
     exts.add(NativeCodeContext::default());
     exts.add(NativeTransactionContext::new(
         vec![1],
diff --git a/aptos-move/e2e-move-tests/Cargo.toml b/aptos-move/e2e-move-tests/Cargo.toml
index 16ed248070fb6..72027aec38675 100644
--- a/aptos-move/e2e-move-tests/Cargo.toml
+++ b/aptos-move/e2e-move-tests/Cargo.toml
@@ -19,9 +19,9 @@ aptos-block-executor = { workspace = true }
 aptos-cached-packages = { workspace = true }
 aptos-crypto = { workspace = true }
 aptos-framework = { workspace = true }
-aptos-gas = { workspace = true, features = ["testing"] }
 aptos-gas-algebra = { workspace = true }
 aptos-gas-profiling = { workspace = true }
+aptos-gas-schedule = { workspace = true }
 aptos-keygen = { workspace = true }
 aptos-language-e2e-tests = { workspace = true }
 aptos-logger = { workspace = true }
diff --git a/aptos-move/e2e-move-tests/src/harness.rs b/aptos-move/e2e-move-tests/src/harness.rs
index 40f506560f291..766cb87298e1d 100644
--- a/aptos-move/e2e-move-tests/src/harness.rs
+++ b/aptos-move/e2e-move-tests/src/harness.rs
@@ -7,10 +7,10 @@ use aptos::move_tool::MemberId;
 use aptos_cached_packages::aptos_stdlib;
 use aptos_crypto::{ed25519::Ed25519PrivateKey, PrivateKey, Uniform};
 use aptos_framework::{natives::code::PackageMetadata, BuildOptions, BuiltPackage};
-use aptos_gas::{
+use aptos_gas_profiling::TransactionGasLog;
+use aptos_gas_schedule::{
     AptosGasParameters, FromOnChainGasSchedule, InitialGasSchedule, ToOnChainGasSchedule,
 };
-use aptos_gas_profiling::TransactionGasLog;
 use aptos_language_e2e_tests::{
     account::{Account, AccountData},
     executor::FakeExecutor,
@@ -537,7 +537,7 @@ impl MoveHarness {
         // explicitly manipulating gas entries. Wasn't obvious from the gas code how to
         // do this differently then below, so perhaps improve this...
         let entries = AptosGasParameters::initial()
-            .to_on_chain_gas_schedule(aptos_gas::LATEST_GAS_FEATURE_VERSION);
+            .to_on_chain_gas_schedule(aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION);
         let entries = entries
             .into_iter()
             .map(|(name, val)| {
@@ -549,7 +549,7 @@ impl MoveHarness {
             })
             .collect::<Vec<_>>();
         let gas_schedule = GasScheduleV2 {
-            feature_version: aptos_gas::LATEST_GAS_FEATURE_VERSION,
+            feature_version: aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION,
             entries,
         };
         let schedule_bytes = bcs::to_bytes(&gas_schedule).expect("bcs");
diff --git a/aptos-move/e2e-move-tests/src/tests/per_category_gas_limits.rs b/aptos-move/e2e-move-tests/src/tests/per_category_gas_limits.rs
index 24cd88dd13e61..99f7bae8cf6ab 100644
--- a/aptos-move/e2e-move-tests/src/tests/per_category_gas_limits.rs
+++ b/aptos-move/e2e-move-tests/src/tests/per_category_gas_limits.rs
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{assert_success, assert_vm_status, tests::common, MoveHarness};
-use aptos_gas_algebra::{Fee, Gas};
+use aptos_gas_algebra::{Fee, Gas, GasQuantity};
 use aptos_types::{account_address::AccountAddress, vm_status::StatusCode};
 use move_core_types::gas_algebra::InternalGas;
 use serde::{Deserialize, Serialize};
@@ -26,7 +26,8 @@ fn execution_limit_reached() {
 
     // Lower the max execution gas to 1000 units.
     h.modify_gas_schedule(|gas_params| {
-        gas_params.txn.max_execution_gas = Gas::new(1000) * gas_params.txn.gas_unit_scaling_factor
+        gas_params.vm.txn.max_execution_gas =
+            Gas::new(1000) * gas_params.vm.txn.gas_unit_scaling_factor
     });
 
     // Execute the loop. It should hit the execution limit before running out of gas.
@@ -43,8 +44,11 @@ fn execution_limit_reached() {
 fn bounded_execution_time() {
     let mut h = MoveHarness::new();
 
-    h.modify_gas_schedule(|gas_params| {
-        assert!(gas_params.txn.max_execution_gas < gas_params.instr.add * 10_000_000.into())
+    h.modify_gas_schedule(|gas_params: &mut aptos_gas_schedule::AptosGasParameters| {
+        assert!(
+            gas_params.vm.txn.max_execution_gas
+                < gas_params.vm.instr.add * GasQuantity::from(10_000_000)
+        )
     });
 }
 
@@ -57,7 +61,9 @@ fn io_limit_reached() {
     assert_success!(h.publish_package(&acc, &common::test_dir_path("execution_limit.data/test"),));
 
     // Lower the max io gas to lower than a single load_resource
-    h.modify_gas_schedule(|gas_params| gas_params.txn.max_io_gas = InternalGas::new(300_000 - 1));
+    h.modify_gas_schedule(|gas_params| {
+        gas_params.vm.txn.max_io_gas = InternalGas::new(300_000 - 1)
+    });
 
     // Execute the test function. The function will attempt to check if a resource exists and shall immediately hit the IO gas limit.
     let res = h.run_entry_function(
@@ -78,7 +84,7 @@ fn storage_limit_reached() {
     assert_success!(h.publish_package(&acc, &common::test_dir_path("execution_limit.data/test"),));
 
     // Lower the max storage fee to 10 Octa.
-    h.modify_gas_schedule(|gas_params| gas_params.txn.max_storage_fee = Fee::new(10));
+    h.modify_gas_schedule(|gas_params| gas_params.vm.txn.max_storage_fee = Fee::new(10));
 
     // Execute the test function. The function will attempt to publish a resource and shall immediately hit the storage fee limit.
     let res = h.run_entry_function(
diff --git a/aptos-move/e2e-tests/Cargo.toml b/aptos-move/e2e-tests/Cargo.toml
index 3cfa40a21b35e..03fd45aedb207 100644
--- a/aptos-move/e2e-tests/Cargo.toml
+++ b/aptos-move/e2e-tests/Cargo.toml
@@ -19,18 +19,20 @@ aptos-block-executor = { workspace = true }
 aptos-cached-packages ={ workspace = true }
 aptos-crypto = { workspace = true, features = ["fuzzing"] }
 aptos-framework = { workspace = true }
-aptos-gas-schedule = { workspace = true }
-aptos-gas = { workspace = true }
 aptos-gas-algebra = { workspace = true }
+aptos-gas-meter = { workspace = true }
 aptos-gas-profiling = { workspace = true }
+aptos-gas-schedule = { workspace = true }
 aptos-keygen = { workspace = true }
 aptos-memory-usage-tracker = { workspace = true }
 aptos-proptest-helpers = { workspace = true }
 aptos-state-view = { workspace = true }
+aptos-table-natives = { workspace = true }
 aptos-types = { workspace = true }
 aptos-vm = { workspace = true }
 aptos-vm-genesis = { workspace = true }
 aptos-vm-logging = { workspace = true }
+aptos-vm-types = { workspace = true }
 bcs = { workspace = true }
 goldenfile = { workspace = true }
 hex = { workspace = true }
@@ -38,7 +40,6 @@ move-binary-format = { workspace = true }
 move-command-line-common = { workspace = true }
 move-core-types = { workspace = true }
 move-ir-compiler = { workspace = true }
-move-table-extension = { workspace = true }
 move-vm-types = { workspace = true }
 num_cpus = { workspace = true }
 once_cell = { workspace = true }
diff --git a/aptos-move/e2e-tests/src/account_universe/bad_transaction.rs b/aptos-move/e2e-tests/src/account_universe/bad_transaction.rs
index 61dff46e40a48..c8e5e62adaf20 100644
--- a/aptos-move/e2e-tests/src/account_universe/bad_transaction.rs
+++ b/aptos-move/e2e-tests/src/account_universe/bad_transaction.rs
@@ -11,9 +11,8 @@ use aptos_crypto::{
     ed25519::{Ed25519PrivateKey, Ed25519PublicKey},
     test_utils::KeyPair,
 };
-use aptos_gas::{AptosGasParameters, InitialGasSchedule};
 use aptos_gas_algebra::{FeePerGasUnit, Gas, GasExpression};
-use aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION;
+use aptos_gas_schedule::{AptosGasParameters, InitialGasSchedule, LATEST_GAS_FEATURE_VERSION};
 use aptos_proptest_helpers::Index;
 use aptos_types::{
     transaction::{Script, SignedTransaction, TransactionStatus},
@@ -90,11 +89,11 @@ impl AUTransactionGen for InsufficientBalanceGen {
 
         // TODO: Move such config to AccountUniverse
         let gas_params = AptosGasParameters::initial();
-        let txn_gas_params = &gas_params.txn;
+        let txn_gas_params = &gas_params.vm.txn;
         let raw_bytes_len = txn.raw_txn_bytes_len() as u64;
         let min_cost: Gas = txn_gas_params
             .calculate_intrinsic_gas(raw_bytes_len.into())
-            .materialize(LATEST_GAS_FEATURE_VERSION, &gas_params)
+            .evaluate(LATEST_GAS_FEATURE_VERSION, &gas_params.vm)
             .to_unit_round_up_with_params(txn_gas_params);
 
         (
diff --git a/aptos-move/e2e-tests/src/data_store.rs b/aptos-move/e2e-tests/src/data_store.rs
index d68f2cd6a9b4f..f63e08c8fd05e 100644
--- a/aptos-move/e2e-tests/src/data_store.rs
+++ b/aptos-move/e2e-tests/src/data_store.rs
@@ -7,6 +7,7 @@
 use crate::account::AccountData;
 use anyhow::Result;
 use aptos_state_view::{in_memory_state_view::InMemoryStateView, TStateView};
+use aptos_table_natives::{TableHandle, TableResolver};
 use aptos_types::{
     access_path::AccessPath,
     account_config::CoinInfoResource,
@@ -22,7 +23,6 @@ use aptos_vm_genesis::{
     GenesisOptions,
 };
 use move_core_types::language_storage::ModuleId;
-use move_table_extension::{TableHandle, TableResolver};
 use once_cell::sync::Lazy;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
diff --git a/aptos-move/e2e-tests/src/executor.rs b/aptos-move/e2e-tests/src/executor.rs
index 64d213aa577e9..129ce4fe72aae 100644
--- a/aptos-move/e2e-tests/src/executor.rs
+++ b/aptos-move/e2e-tests/src/executor.rs
@@ -17,12 +17,9 @@ use aptos_bitvec::BitVec;
 use aptos_block_executor::txn_commit_hook::NoOpTransactionCommitHook;
 use aptos_crypto::HashValue;
 use aptos_framework::ReleaseBundle;
-use aptos_gas::{
-    AbstractValueSizeGasParameters, ChangeSetConfigs, NativeGasParameters, StandardGasAlgebra,
-    StandardGasMeter,
-};
+use aptos_gas_meter::{StandardGasAlgebra, StandardGasMeter};
 use aptos_gas_profiling::{GasProfiler, TransactionGasLog};
-use aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION;
+use aptos_gas_schedule::{MiscGasParameters, NativeGasParameters, LATEST_GAS_FEATURE_VERSION};
 use aptos_keygen::KeyGen;
 use aptos_memory_usage_tracker::MemoryTrackedGasMeter;
 use aptos_state_view::TStateView;
@@ -54,6 +51,7 @@ use aptos_vm::{
 };
 use aptos_vm_genesis::{generate_genesis_change_set_for_testing_with_count, GenesisOptions};
 use aptos_vm_logging::log_schema::AdapterLogSchema;
+use aptos_vm_types::storage::ChangeSetConfigs;
 use move_core_types::{
     account_address::AccountAddress,
     identifier::Identifier,
@@ -679,7 +677,7 @@ impl FakeExecutor {
             // TODO(Gas): we probably want to switch to non-zero costs in the future
             let vm = MoveVmExt::new(
                 NativeGasParameters::zeros(),
-                AbstractValueSizeGasParameters::zeros(),
+                MiscGasParameters::zeros(),
                 LATEST_GAS_FEATURE_VERSION,
                 self.chain_id,
                 self.features.clone(),
@@ -731,7 +729,7 @@ impl FakeExecutor {
             // TODO(Gas): we probably want to switch to non-zero costs in the future
             let vm = MoveVmExt::new(
                 NativeGasParameters::zeros(),
-                AbstractValueSizeGasParameters::zeros(),
+                MiscGasParameters::zeros(),
                 LATEST_GAS_FEATURE_VERSION,
                 self.chain_id,
                 self.features.clone(),
@@ -779,7 +777,7 @@ impl FakeExecutor {
         // TODO(Gas): we probably want to switch to non-zero costs in the future
         let vm = MoveVmExt::new(
             NativeGasParameters::zeros(),
-            AbstractValueSizeGasParameters::zeros(),
+            MiscGasParameters::zeros(),
             LATEST_GAS_FEATURE_VERSION,
             self.chain_id,
             self.features.clone(),
diff --git a/aptos-move/e2e-testsuite/Cargo.toml b/aptos-move/e2e-testsuite/Cargo.toml
index 000a1d39cc496..2897d5000cc2a 100644
--- a/aptos-move/e2e-testsuite/Cargo.toml
+++ b/aptos-move/e2e-testsuite/Cargo.toml
@@ -17,7 +17,8 @@ aptos-block-executor = { workspace = true }
 aptos-cached-packages = { workspace = true }
 aptos-crypto = { workspace = true }
 aptos-framework = { workspace = true }
-aptos-gas = { workspace = true, features = ["testing"] }
+aptos-gas-meter = { workspace = true, features = ['testing'] }
+aptos-gas-schedule = { workspace = true }
 aptos-keygen = { workspace = true }
 aptos-language-e2e-tests = { workspace = true }
 aptos-logger = { workspace = true }
@@ -27,6 +28,7 @@ aptos-types = { workspace = true }
 aptos-vm = { workspace = true, features = ['failpoints'] }
 aptos-vm-genesis = { workspace = true }
 aptos-vm-logging = { workspace = true }
+aptos-vm-types = { workspace = true }
 aptos-writeset-generator = { workspace = true }
 bcs = { workspace = true }
 fail = { workspace = true, features = ['failpoints'] }
diff --git a/aptos-move/e2e-testsuite/src/tests/failed_transaction_tests.rs b/aptos-move/e2e-testsuite/src/tests/failed_transaction_tests.rs
index e83317d44c2b0..e5a1df56ff8c2 100644
--- a/aptos-move/e2e-testsuite/src/tests/failed_transaction_tests.rs
+++ b/aptos-move/e2e-testsuite/src/tests/failed_transaction_tests.rs
@@ -2,10 +2,8 @@
 // Parts of the project are originally copyright © Meta Platforms, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-use aptos_gas::{
-    AptosGasParameters, StandardGasAlgebra, StandardGasMeter, StorageGasParameters,
-    LATEST_GAS_FEATURE_VERSION,
-};
+use aptos_gas_meter::{StandardGasAlgebra, StandardGasMeter};
+use aptos_gas_schedule::{AptosGasParameters, LATEST_GAS_FEATURE_VERSION};
 use aptos_language_e2e_tests::{common_transactions::peer_to_peer_txn, executor::FakeExecutor};
 use aptos_memory_usage_tracker::MemoryTrackedGasMeter;
 use aptos_state_view::TStateView;
@@ -15,6 +13,7 @@ use aptos_types::{
 };
 use aptos_vm::{data_cache::AsMoveResolver, transaction_metadata::TransactionMetadata, AptosVM};
 use aptos_vm_logging::log_schema::AdapterLogSchema;
+use aptos_vm_types::storage::StorageGasParameters;
 use move_core_types::vm_status::StatusCode::TYPE_MISMATCH;
 
 #[test]
@@ -43,7 +42,7 @@ fn failed_transaction_cleanup_test() {
 
     let mut gas_meter = MemoryTrackedGasMeter::new(StandardGasMeter::new(StandardGasAlgebra::new(
         LATEST_GAS_FEATURE_VERSION,
-        gas_params,
+        gas_params.vm,
         storage_gas_params,
         10_000,
     )));
diff --git a/aptos-move/e2e-testsuite/src/tests/verify_txn.rs b/aptos-move/e2e-testsuite/src/tests/verify_txn.rs
index a595180156664..166cee47a9f53 100644
--- a/aptos-move/e2e-testsuite/src/tests/verify_txn.rs
+++ b/aptos-move/e2e-testsuite/src/tests/verify_txn.rs
@@ -4,7 +4,7 @@
 
 use aptos_cached_packages::aptos_stdlib;
 use aptos_crypto::{ed25519::Ed25519PrivateKey, PrivateKey, Uniform};
-use aptos_gas::{InitialGasSchedule, TransactionGasParameters};
+use aptos_gas_schedule::{InitialGasSchedule, TransactionGasParameters};
 use aptos_language_e2e_tests::{
     assert_prologue_disparity, assert_prologue_parity, common_transactions::EMPTY_SCRIPT,
     compile::compile_module, current_function_name, executor::FakeExecutor, transaction_status_eq,
@@ -19,6 +19,7 @@ use aptos_types::{
 };
 use move_binary_format::file_format::CompiledModule;
 use move_core_types::{
+    gas_algebra::GasQuantity,
     identifier::Identifier,
     language_storage::{StructTag, TypeTag},
     vm_status::StatusCode::MODULE_ADDRESS_DOES_NOT_MATCH_SENDER,
@@ -289,7 +290,7 @@ fn verify_simple_payment() {
         .transaction()
         .script(Script::new(empty_script.clone(), vec![], vec![]))
         .sequence_number(10)
-        .gas_unit_price((txn_gas_params.max_price_per_gas_unit + 1.into()).into())
+        .gas_unit_price((txn_gas_params.max_price_per_gas_unit + GasQuantity::one()).into())
         .max_gas_amount(1_000_000)
         .sign();
     assert_prologue_parity!(
@@ -314,9 +315,10 @@ fn verify_simple_payment() {
         > u64::from(txn_gas_params.min_transaction_gas_units)
     {
         txn_gas_params.large_transaction_cutoff
-            + (u64::from(txn_gas_params.gas_unit_scaling_factor)
-                / u64::from(txn_gas_params.intrinsic_gas_per_byte))
-            .into()
+            + GasQuantity::from(
+                u64::from(txn_gas_params.gas_unit_scaling_factor)
+                    / u64::from(txn_gas_params.intrinsic_gas_per_byte),
+            )
     } else {
         0.into()
     };
@@ -343,7 +345,7 @@ fn verify_simple_payment() {
         .transaction()
         .script(Script::new(empty_script.clone(), vec![], vec![]))
         .sequence_number(10)
-        .max_gas_amount((txn_gas_params.maximum_number_of_gas_units + 1.into()).into())
+        .max_gas_amount((txn_gas_params.maximum_number_of_gas_units + GasQuantity::one()).into())
         .gas_unit_price((txn_gas_params.max_price_per_gas_unit).into())
         .sign();
     assert_prologue_parity!(
@@ -361,7 +363,7 @@ fn verify_simple_payment() {
             vec![TransactionArgument::U8(42); MAX_TRANSACTION_SIZE_IN_BYTES as usize],
         ))
         .sequence_number(10)
-        .max_gas_amount((txn_gas_params.maximum_number_of_gas_units + 1.into()).into())
+        .max_gas_amount((txn_gas_params.maximum_number_of_gas_units + GasQuantity::one()).into())
         .gas_unit_price((txn_gas_params.max_price_per_gas_unit).into())
         .sign();
     assert_prologue_parity!(
diff --git a/aptos-move/framework/Cargo.toml b/aptos-move/framework/Cargo.toml
index 6e479a2c91eff..b72c04e95c085 100644
--- a/aptos-move/framework/Cargo.toml
+++ b/aptos-move/framework/Cargo.toml
@@ -17,9 +17,12 @@ anyhow = { workspace = true }
 aptos-aggregator = { workspace = true }
 aptos-crypto = { workspace = true, features = ["fuzzing"] }
 aptos-gas-algebra = { workspace = true }
+aptos-gas-schedule = { workspace = true }
 aptos-move-stdlib = { workspace = true }
+aptos-native-interface = { workspace = true }
 aptos-sdk-builder = { workspace = true }
 aptos-state-view = { workspace = true }
+aptos-table-natives = { workspace = true }
 aptos-types = { workspace = true }
 ark-bls12-381 = { workspace = true }
 ark-ec = { workspace = true }
@@ -34,6 +37,7 @@ blst = { workspace = true }
 clap = { workspace = true }
 codespan-reporting = { workspace = true }
 curve25519-dalek = { workspace = true }
+either = { workspace = true }
 flate2 = { workspace = true }
 hex = { workspace = true }
 include_dir = { workspace = true }
@@ -50,7 +54,6 @@ move-package = { workspace = true }
 move-prover = { workspace = true }
 move-prover-boogie-backend = { workspace = true }
 move-stackless-bytecode = { workspace = true }
-move-table-extension = { workspace = true }
 move-vm-runtime = { workspace = true }
 move-vm-types = { workspace = true }
 num-traits = { workspace = true }
@@ -75,7 +78,7 @@ thiserror = { workspace = true }
 tiny-keccak = { workspace = true }
 
 [dev-dependencies]
-aptos-gas = { workspace = true }
+aptos-gas-meter = { workspace = true }
 aptos-language-e2e-tests = { workspace = true }
 aptos-vm = { workspace = true, features = ["testing"] }
 claims = { workspace = true }
diff --git a/aptos-move/framework/move-stdlib/Cargo.toml b/aptos-move/framework/move-stdlib/Cargo.toml
index 230306abfe8d6..0d749e1533bb6 100644
--- a/aptos-move/framework/move-stdlib/Cargo.toml
+++ b/aptos-move/framework/move-stdlib/Cargo.toml
@@ -11,6 +11,9 @@ publish = false
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
+either = { workspace = true }
+aptos-gas-schedule = { workspace = true }
+aptos-native-interface = { workspace = true }
 anyhow = "1.0.52"
 hex = "0.4.3"
 log = "0.4.14"
diff --git a/aptos-move/framework/move-stdlib/src/natives/bcs.rs b/aptos-move/framework/move-stdlib/src/natives/bcs.rs
index 7051a362092ea..3501c686f5db8 100644
--- a/aptos-move/framework/move-stdlib/src/natives/bcs.rs
+++ b/aptos-move/framework/move-stdlib/src/natives/bcs.rs
@@ -4,21 +4,22 @@
 // Copyright (c) The Move Contributors
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::natives::helpers::make_module_natives;
-use move_binary_format::errors::PartialVMResult;
+use aptos_gas_schedule::gas_params::natives::move_stdlib::*;
+use aptos_native_interface::{
+    safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext, SafeNativeError,
+    SafeNativeResult,
+};
 use move_core_types::{
-    gas_algebra::{InternalGas, InternalGasPerByte, NumBytes},
-    vm_status::sub_status::NFE_BCS_SERIALIZATION_FAILURE,
+    gas_algebra::NumBytes, vm_status::sub_status::NFE_BCS_SERIALIZATION_FAILURE,
 };
-use move_vm_runtime::native_functions::{NativeContext, NativeFunction};
+use move_vm_runtime::native_functions::NativeFunction;
 use move_vm_types::{
     loaded_data::runtime_types::Type,
-    natives::function::NativeResult,
-    pop_arg,
     values::{values_impl::Reference, Value},
 };
-use smallvec::smallvec;
-use std::{collections::VecDeque, sync::Arc};
+use smallvec::{smallvec, SmallVec};
+use std::collections::VecDeque;
+
 /***************************************************************************************************
  * native fun to_bytes
  *
@@ -30,76 +31,55 @@ use std::{collections::VecDeque, sync::Arc};
  *             will be charged.
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct ToBytesGasParameters {
-    pub per_byte_serialized: InternalGasPerByte,
-    pub legacy_min_output_size: NumBytes,
-    pub failure: InternalGas,
-}
-
 /// Rust implementation of Move's `native public fun to_bytes<T>(&T): vector<u8>`
 #[inline]
 fn native_to_bytes(
-    gas_params: &ToBytesGasParameters,
-    context: &mut NativeContext,
+    context: &mut SafeNativeContext,
     mut ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
     debug_assert!(ty_args.len() == 1);
     debug_assert!(args.len() == 1);
 
-    let mut cost = 0.into();
-
     // pop type and value
-    let ref_to_val = pop_arg!(args, Reference);
+    let ref_to_val = safely_pop_arg!(args, Reference);
     let arg_type = ty_args.pop().unwrap();
 
     // get type layout
     let layout = match context.type_to_type_layout(&arg_type)? {
         Some(layout) => layout,
         None => {
-            cost += gas_params.failure;
-            return Ok(NativeResult::err(cost, NFE_BCS_SERIALIZATION_FAILURE));
+            context.charge(BCS_TO_BYTES_FAILURE)?;
+            return Err(SafeNativeError::Abort {
+                abort_code: NFE_BCS_SERIALIZATION_FAILURE,
+            });
         },
     };
+
     // serialize value
     let val = ref_to_val.read_ref()?;
     let serialized_value = match val.simple_serialize(&layout) {
         Some(serialized_value) => serialized_value,
         None => {
-            cost += gas_params.failure;
-            return Ok(NativeResult::err(cost, NFE_BCS_SERIALIZATION_FAILURE));
+            context.charge(BCS_TO_BYTES_FAILURE)?;
+            return Err(SafeNativeError::Abort {
+                abort_code: NFE_BCS_SERIALIZATION_FAILURE,
+            });
         },
     };
-    cost += gas_params.per_byte_serialized
-        * std::cmp::max(
-            NumBytes::new(serialized_value.len() as u64),
-            gas_params.legacy_min_output_size,
-        );
+    context
+        .charge(BCS_TO_BYTES_PER_BYTE_SERIALIZED * NumBytes::new(serialized_value.len() as u64))?;
 
-    Ok(NativeResult::ok(cost, smallvec![Value::vector_u8(
-        serialized_value
-    )]))
-}
-
-pub fn make_native_to_bytes(gas_params: ToBytesGasParameters) -> NativeFunction {
-    Arc::new(
-        move |context, ty_args, args| -> PartialVMResult<NativeResult> {
-            native_to_bytes(&gas_params, context, ty_args, args)
-        },
-    )
+    Ok(smallvec![Value::vector_u8(serialized_value)])
 }
 
 /***************************************************************************************************
  * module
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub to_bytes: ToBytesGasParameters,
-}
-
-pub fn make_all(gas_params: GasParameters) -> impl Iterator<Item = (String, NativeFunction)> {
-    let natives = [("to_bytes", make_native_to_bytes(gas_params.to_bytes))];
+pub fn make_all(
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
+    let funcs = [("to_bytes", native_to_bytes as RawSafeNative)];
 
-    make_module_natives(natives)
+    builder.make_named_natives(funcs)
 }
diff --git a/aptos-move/framework/move-stdlib/src/natives/hash.rs b/aptos-move/framework/move-stdlib/src/natives/hash.rs
index db8e46a6b5b97..abb21713a8e24 100644
--- a/aptos-move/framework/move-stdlib/src/natives/hash.rs
+++ b/aptos-move/framework/move-stdlib/src/natives/hash.rs
@@ -4,17 +4,17 @@
 // Copyright (c) The Move Contributors
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::natives::helpers::make_module_natives;
-use move_binary_format::errors::PartialVMResult;
-use move_core_types::gas_algebra::{InternalGas, InternalGasPerByte, NumBytes};
-use move_vm_runtime::native_functions::{NativeContext, NativeFunction};
-use move_vm_types::{
-    loaded_data::runtime_types::Type, natives::function::NativeResult, pop_arg, values::Value,
+use aptos_gas_schedule::gas_params::natives::move_stdlib::*;
+use aptos_native_interface::{
+    safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext, SafeNativeResult,
 };
+use move_core_types::gas_algebra::NumBytes;
+use move_vm_runtime::native_functions::NativeFunction;
+use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use sha2::{Digest, Sha256};
 use sha3::Sha3_256;
-use smallvec::smallvec;
-use std::{collections::VecDeque, sync::Arc};
+use smallvec::{smallvec, SmallVec};
+use std::collections::VecDeque;
 
 /***************************************************************************************************
  * native fun sha2_256
@@ -22,44 +22,23 @@ use std::{collections::VecDeque, sync::Arc};
  *   gas cost: base_cost + unit_cost * max(input_length_in_bytes, legacy_min_input_len)
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct Sha2_256GasParameters {
-    pub base: InternalGas,
-    pub per_byte: InternalGasPerByte,
-    pub legacy_min_input_len: NumBytes,
-}
-
 #[inline]
 fn native_sha2_256(
-    gas_params: &Sha2_256GasParameters,
-    _context: &mut NativeContext,
+    context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
     debug_assert!(_ty_args.is_empty());
     debug_assert!(arguments.len() == 1);
 
-    let hash_arg = pop_arg!(arguments, Vec<u8>);
+    let hash_arg = safely_pop_arg!(arguments, Vec<u8>);
 
-    let cost = gas_params.base
-        + gas_params.per_byte
-            * std::cmp::max(
-                NumBytes::new(hash_arg.len() as u64),
-                gas_params.legacy_min_input_len,
-            );
+    context.charge(
+        HASH_SHA2_256_BASE + HASH_SHA2_256_PER_BYTE * NumBytes::new(hash_arg.len() as u64),
+    )?;
 
     let hash_vec = Sha256::digest(hash_arg.as_slice()).to_vec();
-    Ok(NativeResult::ok(cost, smallvec![Value::vector_u8(
-        hash_vec
-    )]))
-}
-
-pub fn make_native_sha2_256(gas_params: Sha2_256GasParameters) -> NativeFunction {
-    Arc::new(
-        move |context, ty_args, args| -> PartialVMResult<NativeResult> {
-            native_sha2_256(&gas_params, context, ty_args, args)
-        },
-    )
+    Ok(smallvec![Value::vector_u8(hash_vec)])
 }
 
 /***************************************************************************************************
@@ -68,60 +47,35 @@ pub fn make_native_sha2_256(gas_params: Sha2_256GasParameters) -> NativeFunction
  *   gas cost: base_cost + unit_cost * max(input_length_in_bytes, legacy_min_input_len)
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct Sha3_256GasParameters {
-    pub base: InternalGas,
-    pub per_byte: InternalGasPerByte,
-    pub legacy_min_input_len: NumBytes,
-}
-
 #[inline]
 fn native_sha3_256(
-    gas_params: &Sha3_256GasParameters,
-    _context: &mut NativeContext,
+    context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
     debug_assert!(_ty_args.is_empty());
     debug_assert!(arguments.len() == 1);
 
-    let hash_arg = pop_arg!(arguments, Vec<u8>);
+    let hash_arg = safely_pop_arg!(arguments, Vec<u8>);
 
-    let cost = gas_params.base
-        + gas_params.per_byte
-            * std::cmp::max(
-                NumBytes::new(hash_arg.len() as u64),
-                gas_params.legacy_min_input_len,
-            );
+    context.charge(
+        HASH_SHA3_256_BASE + HASH_SHA3_256_PER_BYTE * NumBytes::new(hash_arg.len() as u64),
+    )?;
 
     let hash_vec = Sha3_256::digest(hash_arg.as_slice()).to_vec();
-    Ok(NativeResult::ok(cost, smallvec![Value::vector_u8(
-        hash_vec
-    )]))
-}
-
-pub fn make_native_sha3_256(gas_params: Sha3_256GasParameters) -> NativeFunction {
-    Arc::new(
-        move |context, ty_args, args| -> PartialVMResult<NativeResult> {
-            native_sha3_256(&gas_params, context, ty_args, args)
-        },
-    )
+    Ok(smallvec![Value::vector_u8(hash_vec)])
 }
 
 /***************************************************************************************************
  * module
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub sha2_256: Sha2_256GasParameters,
-    pub sha3_256: Sha3_256GasParameters,
-}
-
-pub fn make_all(gas_params: GasParameters) -> impl Iterator<Item = (String, NativeFunction)> {
+pub fn make_all(
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
     let natives = [
-        ("sha2_256", make_native_sha2_256(gas_params.sha2_256)),
-        ("sha3_256", make_native_sha3_256(gas_params.sha3_256)),
+        ("sha2_256", native_sha2_256 as RawSafeNative),
+        ("sha3_256", native_sha3_256),
     ];
 
-    make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/move-stdlib/src/natives/helpers.rs b/aptos-move/framework/move-stdlib/src/natives/helpers.rs
deleted file mode 100644
index 4192ac1a29a6a..0000000000000
--- a/aptos-move/framework/move-stdlib/src/natives/helpers.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright © Aptos Foundation
-
-// Copyright (c) The Move Contributors
-// SPDX-License-Identifier: Apache-2.0
-
-use move_vm_runtime::native_functions::NativeFunction;
-
-pub fn make_module_natives(
-    natives: impl IntoIterator<Item = (impl Into<String>, NativeFunction)>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
-    natives
-        .into_iter()
-        .map(|(func_name, func)| (func_name.into(), func))
-}
diff --git a/aptos-move/framework/move-stdlib/src/natives/mod.rs b/aptos-move/framework/move-stdlib/src/natives/mod.rs
index 5e9027fc076e3..32ccfe002fc08 100644
--- a/aptos-move/framework/move-stdlib/src/natives/mod.rs
+++ b/aptos-move/framework/move-stdlib/src/natives/mod.rs
@@ -10,93 +10,14 @@ pub mod signer;
 pub mod string;
 #[cfg(feature = "testing")]
 pub mod unit_test;
-pub mod vector;
-
-mod helpers;
 
+use aptos_native_interface::SafeNativeBuilder;
 use move_core_types::account_address::AccountAddress;
 use move_vm_runtime::native_functions::{make_table_from_iter, NativeFunctionTable};
 
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub bcs: bcs::GasParameters,
-    pub hash: hash::GasParameters,
-    pub signer: signer::GasParameters,
-    pub string: string::GasParameters,
-    pub vector: vector::GasParameters,
-
-    #[cfg(feature = "testing")]
-    pub unit_test: unit_test::GasParameters,
-}
-
-impl GasParameters {
-    pub fn zeros() -> Self {
-        Self {
-            bcs: bcs::GasParameters {
-                to_bytes: bcs::ToBytesGasParameters {
-                    per_byte_serialized: 0.into(),
-                    legacy_min_output_size: 0.into(),
-                    failure: 0.into(),
-                },
-            },
-
-            hash: hash::GasParameters {
-                sha2_256: hash::Sha2_256GasParameters {
-                    base: 0.into(),
-                    per_byte: 0.into(),
-                    legacy_min_input_len: 0.into(),
-                },
-                sha3_256: hash::Sha3_256GasParameters {
-                    base: 0.into(),
-                    per_byte: 0.into(),
-                    legacy_min_input_len: 0.into(),
-                },
-            },
-            signer: signer::GasParameters {
-                borrow_address: signer::BorrowAddressGasParameters { base: 0.into() },
-            },
-            string: string::GasParameters {
-                check_utf8: string::CheckUtf8GasParameters {
-                    base: 0.into(),
-                    per_byte: 0.into(),
-                },
-                is_char_boundary: string::IsCharBoundaryGasParameters { base: 0.into() },
-                sub_string: string::SubStringGasParameters {
-                    base: 0.into(),
-                    per_byte: 0.into(),
-                },
-                index_of: string::IndexOfGasParameters {
-                    base: 0.into(),
-                    per_byte_pattern: 0.into(),
-                    per_byte_searched: 0.into(),
-                },
-            },
-            vector: vector::GasParameters {
-                empty: vector::EmptyGasParameters { base: 0.into() },
-                length: vector::LengthGasParameters { base: 0.into() },
-                push_back: vector::PushBackGasParameters {
-                    base: 0.into(),
-                    legacy_per_abstract_memory_unit: 0.into(),
-                },
-                borrow: vector::BorrowGasParameters { base: 0.into() },
-                pop_back: vector::PopBackGasParameters { base: 0.into() },
-                destroy_empty: vector::DestroyEmptyGasParameters { base: 0.into() },
-                swap: vector::SwapGasParameters { base: 0.into() },
-            },
-            #[cfg(feature = "testing")]
-            unit_test: unit_test::GasParameters {
-                create_signers_for_testing: unit_test::CreateSignersForTestingGasParameters {
-                    base_cost: 0.into(),
-                    unit_cost: 0.into(),
-                },
-            },
-        }
-    }
-}
-
 pub fn all_natives(
     move_std_addr: AccountAddress,
-    gas_params: GasParameters,
+    builder: &mut SafeNativeBuilder,
 ) -> NativeFunctionTable {
     let mut natives = vec![];
 
@@ -108,15 +29,16 @@ pub fn all_natives(
         };
     }
 
-    add_natives!("bcs", bcs::make_all(gas_params.bcs));
-    add_natives!("hash", hash::make_all(gas_params.hash));
-    add_natives!("signer", signer::make_all(gas_params.signer));
-    add_natives!("string", string::make_all(gas_params.string));
-    add_natives!("vector", vector::make_all(gas_params.vector));
-    #[cfg(feature = "testing")]
-    {
-        add_natives!("unit_test", unit_test::make_all(gas_params.unit_test));
-    }
+    builder.with_incremental_gas_charging(false, |builder| {
+        add_natives!("bcs", bcs::make_all(builder));
+        add_natives!("hash", hash::make_all(builder));
+        add_natives!("signer", signer::make_all(builder));
+        add_natives!("string", string::make_all(builder));
+        #[cfg(feature = "testing")]
+        {
+            add_natives!("unit_test", unit_test::make_all(builder));
+        }
+    });
 
     make_table_from_iter(move_std_addr, natives)
 }
diff --git a/aptos-move/framework/move-stdlib/src/natives/signer.rs b/aptos-move/framework/move-stdlib/src/natives/signer.rs
index 9f59916fdbd04..8cc86a6c935d2 100644
--- a/aptos-move/framework/move-stdlib/src/natives/signer.rs
+++ b/aptos-move/framework/move-stdlib/src/natives/signer.rs
@@ -4,18 +4,17 @@
 // Copyright (c) The Move Contributors
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::natives::helpers::make_module_natives;
-use move_binary_format::errors::PartialVMResult;
-use move_core_types::gas_algebra::InternalGas;
-use move_vm_runtime::native_functions::{NativeContext, NativeFunction};
+use aptos_gas_schedule::gas_params::natives::move_stdlib::*;
+use aptos_native_interface::{
+    safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext, SafeNativeResult,
+};
+use move_vm_runtime::native_functions::NativeFunction;
 use move_vm_types::{
     loaded_data::runtime_types::Type,
-    natives::function::NativeResult,
-    pop_arg,
     values::{values_impl::SignerRef, Value},
 };
-use smallvec::smallvec;
-use std::{collections::VecDeque, sync::Arc};
+use smallvec::{smallvec, SmallVec};
+use std::collections::VecDeque;
 
 /***************************************************************************************************
  * native fun borrow_address
@@ -23,49 +22,28 @@ use std::{collections::VecDeque, sync::Arc};
  *   gas cost: base_cost
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct BorrowAddressGasParameters {
-    pub base: InternalGas,
-}
-
 #[inline]
 fn native_borrow_address(
-    gas_params: &BorrowAddressGasParameters,
-    _context: &mut NativeContext,
+    context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
     debug_assert!(_ty_args.is_empty());
     debug_assert!(arguments.len() == 1);
 
-    let signer_reference = pop_arg!(arguments, SignerRef);
+    let signer_reference = safely_pop_arg!(arguments, SignerRef);
 
-    Ok(NativeResult::ok(gas_params.base, smallvec![
-        signer_reference.borrow_signer()?
-    ]))
-}
+    context.charge(SIGNER_BORROW_ADDRESS_BASE)?;
 
-pub fn make_native_borrow_address(gas_params: BorrowAddressGasParameters) -> NativeFunction {
-    Arc::new(
-        move |context, ty_args, args| -> PartialVMResult<NativeResult> {
-            native_borrow_address(&gas_params, context, ty_args, args)
-        },
-    )
+    Ok(smallvec![signer_reference.borrow_signer()?])
 }
 
 /***************************************************************************************************
  * module
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub borrow_address: BorrowAddressGasParameters,
-}
-
-pub fn make_all(gas_params: GasParameters) -> impl Iterator<Item = (String, NativeFunction)> {
-    let natives = [(
-        "borrow_address",
-        make_native_borrow_address(gas_params.borrow_address),
-    )];
-
-    make_module_natives(natives)
+pub fn make_all(
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
+    let natives = [("borrow_address", native_borrow_address as RawSafeNative)];
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/move-stdlib/src/natives/string.rs b/aptos-move/framework/move-stdlib/src/natives/string.rs
index 2ea24e3754adf..96f0e85a0ff98 100644
--- a/aptos-move/framework/move-stdlib/src/natives/string.rs
+++ b/aptos-move/framework/move-stdlib/src/natives/string.rs
@@ -6,17 +6,18 @@
 
 //! Implementation of native functions for utf8 strings.
 
-use crate::natives::helpers::make_module_natives;
-use move_binary_format::errors::PartialVMResult;
-use move_core_types::gas_algebra::{InternalGas, InternalGasPerByte, NumBytes};
-use move_vm_runtime::native_functions::{NativeContext, NativeFunction};
+use aptos_gas_schedule::gas_params::natives::move_stdlib::*;
+use aptos_native_interface::{
+    safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext, SafeNativeResult,
+};
+use move_core_types::gas_algebra::NumBytes;
+use move_vm_runtime::native_functions::NativeFunction;
 use move_vm_types::{
     loaded_data::runtime_types::Type,
-    natives::function::NativeResult,
-    pop_arg,
     values::{Value, VectorRef},
 };
-use std::{collections::VecDeque, sync::Arc};
+use smallvec::{smallvec, SmallVec};
+use std::collections::VecDeque;
 
 // The implementation approach delegates all utf8 handling to Rust.
 // This is possible without copying of bytes because (a) we can
@@ -32,35 +33,24 @@ use std::{collections::VecDeque, sync::Arc};
  *   gas cost: base_cost + unit_cost * length_in_bytes
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct CheckUtf8GasParameters {
-    pub base: InternalGas,
-    pub per_byte: InternalGasPerByte,
-}
-
 fn native_check_utf8(
-    gas_params: &CheckUtf8GasParameters,
-    _context: &mut NativeContext,
+    context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
     debug_assert!(args.len() == 1);
-    let s_arg = pop_arg!(args, VectorRef);
+    let s_arg = safely_pop_arg!(args, VectorRef);
     let s_ref = s_arg.as_bytes_ref();
-    let ok = std::str::from_utf8(s_ref.as_slice()).is_ok();
-    // TODO: extensible native cost tables
 
-    let cost = gas_params.base + gas_params.per_byte * NumBytes::new(s_ref.as_slice().len() as u64);
+    context.charge(
+        STRING_CHECK_UTF8_BASE
+            + STRING_CHECK_UTF8_PER_BYTE * NumBytes::new(s_ref.as_slice().len() as u64),
+    )?;
 
-    NativeResult::map_partial_vm_result_one(cost, Ok(Value::bool(ok)))
-}
+    let ok = std::str::from_utf8(s_ref.as_slice()).is_ok();
+    // TODO: extensible native cost tables
 
-pub fn make_native_check_utf8(gas_params: CheckUtf8GasParameters) -> NativeFunction {
-    Arc::new(
-        move |context, ty_args, args| -> PartialVMResult<NativeResult> {
-            native_check_utf8(&gas_params, context, ty_args, args)
-        },
-    )
+    Ok(smallvec![Value::bool(ok)])
 }
 
 /***************************************************************************************************
@@ -69,34 +59,24 @@ pub fn make_native_check_utf8(gas_params: CheckUtf8GasParameters) -> NativeFunct
  *   gas cost: base_cost
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct IsCharBoundaryGasParameters {
-    pub base: InternalGas,
-}
-
 fn native_is_char_boundary(
-    gas_params: &IsCharBoundaryGasParameters,
-    _context: &mut NativeContext,
+    context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
     debug_assert!(args.len() == 2);
-    let i = pop_arg!(args, u64);
-    let s_arg = pop_arg!(args, VectorRef);
+
+    context.charge(STRING_IS_CHAR_BOUNDARY_BASE)?;
+
+    let i = safely_pop_arg!(args, u64);
+    let s_arg = safely_pop_arg!(args, VectorRef);
     let s_ref = s_arg.as_bytes_ref();
     let ok = unsafe {
         // This is safe because we guarantee the bytes to be utf8.
         std::str::from_utf8_unchecked(s_ref.as_slice()).is_char_boundary(i as usize)
     };
-    NativeResult::map_partial_vm_result_one(gas_params.base, Ok(Value::bool(ok)))
-}
 
-pub fn make_native_is_char_boundary(gas_params: IsCharBoundaryGasParameters) -> NativeFunction {
-    Arc::new(
-        move |context, ty_args, args| -> PartialVMResult<NativeResult> {
-            native_is_char_boundary(&gas_params, context, ty_args, args)
-        },
-    )
+    Ok(smallvec![Value::bool(ok)])
 }
 
 /***************************************************************************************************
@@ -105,28 +85,26 @@ pub fn make_native_is_char_boundary(gas_params: IsCharBoundaryGasParameters) ->
  *   gas cost: base_cost + unit_cost * sub_string_length_in_bytes
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct SubStringGasParameters {
-    pub base: InternalGas,
-    pub per_byte: InternalGasPerByte,
-}
-
 fn native_sub_string(
-    gas_params: &SubStringGasParameters,
-    _context: &mut NativeContext,
+    context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
     debug_assert!(args.len() == 3);
-    let j = pop_arg!(args, u64) as usize;
-    let i = pop_arg!(args, u64) as usize;
+
+    context.charge(STRING_SUB_STRING_BASE)?;
+
+    let j = safely_pop_arg!(args, u64) as usize;
+    let i = safely_pop_arg!(args, u64) as usize;
 
     if j < i {
-        // TODO: what abort code should we use here?
-        return Ok(NativeResult::err(gas_params.base, 1));
+        // TODO: The abort code should follow the error convention.
+        return Err(aptos_native_interface::SafeNativeError::Abort { abort_code: 1 });
     }
 
-    let s_arg = pop_arg!(args, VectorRef);
+    context.charge(STRING_SUB_STRING_PER_BYTE * NumBytes::new((j - i) as u64))?;
+
+    let s_arg = safely_pop_arg!(args, VectorRef);
     let s_ref = s_arg.as_bytes_ref();
     let s_str = unsafe {
         // This is safe because we guarantee the bytes to be utf8.
@@ -134,16 +112,7 @@ fn native_sub_string(
     };
     let v = Value::vector_u8(s_str[i..j].as_bytes().iter().cloned());
 
-    let cost = gas_params.base + gas_params.per_byte * NumBytes::new((j - i) as u64);
-    NativeResult::map_partial_vm_result_one(cost, Ok(v))
-}
-
-pub fn make_native_sub_string(gas_params: SubStringGasParameters) -> NativeFunction {
-    Arc::new(
-        move |context, ty_args, args| -> PartialVMResult<NativeResult> {
-            native_sub_string(&gas_params, context, ty_args, args)
-        },
-    )
+    Ok(smallvec![v])
 }
 
 /***************************************************************************************************
@@ -152,76 +121,48 @@ pub fn make_native_sub_string(gas_params: SubStringGasParameters) -> NativeFunct
  *   gas cost: base_cost + unit_cost * bytes_searched
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct IndexOfGasParameters {
-    pub base: InternalGas,
-    pub per_byte_pattern: InternalGasPerByte,
-    pub per_byte_searched: InternalGasPerByte,
-}
-
 fn native_index_of(
-    gas_params: &IndexOfGasParameters,
-    _context: &mut NativeContext,
+    context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
     debug_assert!(args.len() == 2);
-    let r_arg = pop_arg!(args, VectorRef);
+
+    context.charge(STRING_INDEX_OF_BASE)?;
+
+    let r_arg = safely_pop_arg!(args, VectorRef);
     let r_ref = r_arg.as_bytes_ref();
     let r_str = unsafe { std::str::from_utf8_unchecked(r_ref.as_slice()) };
-    let s_arg = pop_arg!(args, VectorRef);
+
+    context.charge(STRING_INDEX_OF_PER_BYTE_PATTERN * NumBytes::new(r_str.len() as u64))?;
+
+    let s_arg = safely_pop_arg!(args, VectorRef);
     let s_ref = s_arg.as_bytes_ref();
     let s_str = unsafe { std::str::from_utf8_unchecked(s_ref.as_slice()) };
     let pos = match s_str.find(r_str) {
         Some(size) => size,
         None => s_str.len(),
     };
+
     // TODO(Gas): What is the algorithm used for the search?
     //            Ideally it should be something like KMP with O(n) time complexity...
-    let cost = gas_params.base
-        + gas_params.per_byte_pattern * NumBytes::new(r_str.len() as u64)
-        + gas_params.per_byte_searched * NumBytes::new(pos as u64);
-    NativeResult::map_partial_vm_result_one(cost, Ok(Value::u64(pos as u64)))
-}
+    context.charge(STRING_INDEX_OF_PER_BYTE_SEARCHED * NumBytes::new(pos as u64))?;
 
-pub fn make_native_index_of(gas_params: IndexOfGasParameters) -> NativeFunction {
-    Arc::new(
-        move |context, ty_args, args| -> PartialVMResult<NativeResult> {
-            native_index_of(&gas_params, context, ty_args, args)
-        },
-    )
+    Ok(smallvec![Value::u64(pos as u64)])
 }
 
 /***************************************************************************************************
  * module
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub check_utf8: CheckUtf8GasParameters,
-    pub is_char_boundary: IsCharBoundaryGasParameters,
-    pub sub_string: SubStringGasParameters,
-    pub index_of: IndexOfGasParameters,
-}
-
-pub fn make_all(gas_params: GasParameters) -> impl Iterator<Item = (String, NativeFunction)> {
+pub fn make_all(
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
     let natives = [
-        (
-            "internal_check_utf8",
-            make_native_check_utf8(gas_params.check_utf8),
-        ),
-        (
-            "internal_is_char_boundary",
-            make_native_is_char_boundary(gas_params.is_char_boundary),
-        ),
-        (
-            "internal_sub_string",
-            make_native_sub_string(gas_params.sub_string),
-        ),
-        (
-            "internal_index_of",
-            make_native_index_of(gas_params.index_of),
-        ),
+        ("internal_check_utf8", native_check_utf8 as RawSafeNative),
+        ("internal_is_char_boundary", native_is_char_boundary),
+        ("internal_sub_string", native_sub_string),
+        ("internal_index_of", native_index_of),
     ];
 
-    make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/move-stdlib/src/natives/unit_test.rs b/aptos-move/framework/move-stdlib/src/natives/unit_test.rs
index e783ceb38d148..44a97008415a8 100644
--- a/aptos-move/framework/move-stdlib/src/natives/unit_test.rs
+++ b/aptos-move/framework/move-stdlib/src/natives/unit_test.rs
@@ -4,18 +4,14 @@
 // Copyright (c) The Move Contributors
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::natives::helpers::make_module_natives;
-use move_binary_format::errors::PartialVMResult;
-use move_core_types::{
-    account_address::AccountAddress,
-    gas_algebra::{InternalGas, InternalGasPerArg, NumArgs},
+use aptos_native_interface::{
+    safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext, SafeNativeResult,
 };
-use move_vm_runtime::native_functions::{NativeContext, NativeFunction};
-use move_vm_types::{
-    loaded_data::runtime_types::Type, natives::function::NativeResult, pop_arg, values::Value,
-};
-use smallvec::smallvec;
-use std::{collections::VecDeque, sync::Arc};
+use move_core_types::account_address::AccountAddress;
+use move_vm_runtime::native_functions::NativeFunction;
+use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
+use smallvec::{smallvec, SmallVec};
+use std::collections::VecDeque;
 
 /***************************************************************************************************
  * native fun create_signers_for_testing
@@ -30,54 +26,33 @@ fn to_le_bytes(i: u64) -> [u8; AccountAddress::LENGTH] {
     result
 }
 
-#[derive(Debug, Clone)]
-pub struct CreateSignersForTestingGasParameters {
-    pub base_cost: InternalGas,
-    pub unit_cost: InternalGasPerArg,
-}
-
 fn native_create_signers_for_testing(
-    gas_params: &CreateSignersForTestingGasParameters,
-    _context: &mut NativeContext,
+    _context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
     debug_assert!(ty_args.is_empty());
     debug_assert!(args.len() == 1);
 
-    let num_signers = pop_arg!(args, u64);
+    let num_signers = safely_pop_arg!(args, u64);
+
     let signers = Value::vector_for_testing_only(
         (0..num_signers).map(|i| Value::signer(AccountAddress::new(to_le_bytes(i)))),
     );
 
-    let cost = gas_params.base_cost + gas_params.unit_cost * NumArgs::new(num_signers);
-
-    Ok(NativeResult::ok(cost, smallvec![signers]))
-}
-
-pub fn make_native_create_signers_for_testing(
-    gas_params: CreateSignersForTestingGasParameters,
-) -> NativeFunction {
-    Arc::new(
-        move |context, ty_args, args| -> PartialVMResult<NativeResult> {
-            native_create_signers_for_testing(&gas_params, context, ty_args, args)
-        },
-    )
+    Ok(smallvec![signers])
 }
 
 /***************************************************************************************************
  * module
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub create_signers_for_testing: CreateSignersForTestingGasParameters,
-}
-
-pub fn make_all(gas_params: GasParameters) -> impl Iterator<Item = (String, NativeFunction)> {
+pub fn make_all(
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
     let natives = [(
         "create_signers_for_testing",
-        make_native_create_signers_for_testing(gas_params.create_signers_for_testing),
+        native_create_signers_for_testing as RawSafeNative,
     )];
 
-    make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/move-stdlib/src/natives/vector.rs b/aptos-move/framework/move-stdlib/src/natives/vector.rs
deleted file mode 100644
index aebcf77bc19d2..0000000000000
--- a/aptos-move/framework/move-stdlib/src/natives/vector.rs
+++ /dev/null
@@ -1,321 +0,0 @@
-// Copyright © Aptos Foundation
-
-// Copyright (c) The Diem Core Contributors
-// Copyright (c) The Move Contributors
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::natives::helpers::make_module_natives;
-use move_binary_format::errors::{PartialVMError, PartialVMResult};
-use move_core_types::{
-    gas_algebra::{InternalGas, InternalGasPerAbstractMemoryUnit},
-    vm_status::StatusCode,
-};
-use move_vm_runtime::native_functions::{NativeContext, NativeFunction};
-use move_vm_types::{
-    loaded_data::runtime_types::Type,
-    natives::function::NativeResult,
-    pop_arg,
-    values::{Value, Vector, VectorRef},
-    views::ValueView,
-};
-use std::{collections::VecDeque, sync::Arc};
-
-/***************************************************************************************************
- * native fun empty
- *
- *   gas cost: base_cost
- *
- **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct EmptyGasParameters {
-    pub base: InternalGas,
-}
-
-pub fn native_empty(
-    gas_params: &EmptyGasParameters,
-    _context: &mut NativeContext,
-    ty_args: Vec<Type>,
-    args: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
-    debug_assert!(ty_args.len() == 1);
-    debug_assert!(args.is_empty());
-
-    NativeResult::map_partial_vm_result_one(gas_params.base, Vector::empty(&ty_args[0]))
-}
-
-pub fn make_native_empty(gas_params: EmptyGasParameters) -> NativeFunction {
-    Arc::new(
-        move |context, ty_args, args| -> PartialVMResult<NativeResult> {
-            native_empty(&gas_params, context, ty_args, args)
-        },
-    )
-}
-
-/***************************************************************************************************
- * native fun length
- *
- *   gas cost: base_cost
- *
- **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct LengthGasParameters {
-    pub base: InternalGas,
-}
-
-pub fn native_length(
-    gas_params: &LengthGasParameters,
-    _context: &mut NativeContext,
-    ty_args: Vec<Type>,
-    mut args: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
-    debug_assert!(ty_args.len() == 1);
-    debug_assert!(args.len() == 1);
-
-    let r = pop_arg!(args, VectorRef);
-    NativeResult::map_partial_vm_result_one(gas_params.base, r.len(&ty_args[0]))
-}
-
-pub fn make_native_length(gas_params: LengthGasParameters) -> NativeFunction {
-    Arc::new(
-        move |context, ty_args, args| -> PartialVMResult<NativeResult> {
-            native_length(&gas_params, context, ty_args, args)
-        },
-    )
-}
-
-/***************************************************************************************************
- * native fun push_back
- *
- *   gas cost: base_cost + legacy_unit_cost * max(1, size_of(val))
- *
- **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct PushBackGasParameters {
-    pub base: InternalGas,
-    pub legacy_per_abstract_memory_unit: InternalGasPerAbstractMemoryUnit,
-}
-
-pub fn native_push_back(
-    gas_params: &PushBackGasParameters,
-    _context: &mut NativeContext,
-    ty_args: Vec<Type>,
-    mut args: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
-    debug_assert!(ty_args.len() == 1);
-    debug_assert!(args.len() == 2);
-
-    let e = args.pop_back().unwrap();
-    let r = pop_arg!(args, VectorRef);
-
-    let mut cost = gas_params.base;
-    if gas_params.legacy_per_abstract_memory_unit != 0.into() {
-        cost += gas_params.legacy_per_abstract_memory_unit
-            * std::cmp::max(e.legacy_abstract_memory_size(), 1.into());
-    }
-
-    NativeResult::map_partial_vm_result_empty(cost, r.push_back(e, &ty_args[0]))
-}
-
-pub fn make_native_push_back(gas_params: PushBackGasParameters) -> NativeFunction {
-    Arc::new(
-        move |context, ty_args, args| -> PartialVMResult<NativeResult> {
-            native_push_back(&gas_params, context, ty_args, args)
-        },
-    )
-}
-
-/***************************************************************************************************
- * native fun borrow
- *
- *   gas cost: base_cost
- *
- **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct BorrowGasParameters {
-    pub base: InternalGas,
-}
-
-pub fn native_borrow(
-    gas_params: &BorrowGasParameters,
-    _context: &mut NativeContext,
-    ty_args: Vec<Type>,
-    mut args: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
-    debug_assert!(ty_args.len() == 1);
-    debug_assert!(args.len() == 2);
-
-    let idx = pop_arg!(args, u64) as usize;
-    let r = pop_arg!(args, VectorRef);
-    NativeResult::map_partial_vm_result_one(
-        gas_params.base,
-        r.borrow_elem(idx, &ty_args[0])
-            .map_err(native_error_to_abort),
-    )
-}
-
-pub fn make_native_borrow(gas_params: BorrowGasParameters) -> NativeFunction {
-    Arc::new(
-        move |context, ty_args, args| -> PartialVMResult<NativeResult> {
-            native_borrow(&gas_params, context, ty_args, args)
-        },
-    )
-}
-
-/***************************************************************************************************
- * native fun pop
- *
- *   gas cost: base_cost
- *
- **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct PopBackGasParameters {
-    pub base: InternalGas,
-}
-
-pub fn native_pop_back(
-    gas_params: &PopBackGasParameters,
-    _context: &mut NativeContext,
-    ty_args: Vec<Type>,
-    mut args: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
-    debug_assert!(ty_args.len() == 1);
-    debug_assert!(args.len() == 1);
-
-    let r = pop_arg!(args, VectorRef);
-    NativeResult::map_partial_vm_result_one(
-        gas_params.base,
-        r.pop(&ty_args[0]).map_err(native_error_to_abort),
-    )
-}
-
-pub fn make_native_pop_back(gas_params: PopBackGasParameters) -> NativeFunction {
-    Arc::new(
-        move |context, ty_args, args| -> PartialVMResult<NativeResult> {
-            native_pop_back(&gas_params, context, ty_args, args)
-        },
-    )
-}
-
-/***************************************************************************************************
- * native fun destroy_empty
- *
- *   gas cost: base_cost
- *
- **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct DestroyEmptyGasParameters {
-    pub base: InternalGas,
-}
-
-pub fn native_destroy_empty(
-    gas_params: &DestroyEmptyGasParameters,
-    _context: &mut NativeContext,
-    ty_args: Vec<Type>,
-    mut args: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
-    debug_assert!(ty_args.len() == 1);
-    debug_assert!(args.len() == 1);
-
-    let v = pop_arg!(args, Vector);
-    NativeResult::map_partial_vm_result_empty(
-        gas_params.base,
-        v.destroy_empty(&ty_args[0]).map_err(native_error_to_abort),
-    )
-}
-
-pub fn make_native_destroy_empty(gas_params: DestroyEmptyGasParameters) -> NativeFunction {
-    Arc::new(
-        move |context, ty_args, args| -> PartialVMResult<NativeResult> {
-            native_destroy_empty(&gas_params, context, ty_args, args)
-        },
-    )
-}
-
-/***************************************************************************************************
- * native fun swap
- **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct SwapGasParameters {
-    pub base: InternalGas,
-}
-
-pub fn native_swap(
-    gas_params: &SwapGasParameters,
-    _context: &mut NativeContext,
-    ty_args: Vec<Type>,
-    mut args: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
-    debug_assert!(ty_args.len() == 1);
-    debug_assert!(args.len() == 3);
-
-    let idx2 = pop_arg!(args, u64) as usize;
-    let idx1 = pop_arg!(args, u64) as usize;
-    let r = pop_arg!(args, VectorRef);
-    NativeResult::map_partial_vm_result_empty(
-        gas_params.base,
-        r.swap(idx1, idx2, &ty_args[0])
-            .map_err(native_error_to_abort),
-    )
-}
-
-pub fn make_native_swap(gas_params: SwapGasParameters) -> NativeFunction {
-    Arc::new(
-        move |context, ty_args, args| -> PartialVMResult<NativeResult> {
-            native_swap(&gas_params, context, ty_args, args)
-        },
-    )
-}
-
-fn native_error_to_abort(err: PartialVMError) -> PartialVMError {
-    let (major_status, sub_status_opt, message_opt, exec_state_opt, indices, offsets) =
-        err.all_data();
-    let new_err = match major_status {
-        StatusCode::VECTOR_OPERATION_ERROR => PartialVMError::new(StatusCode::ABORTED),
-        _ => PartialVMError::new(major_status),
-    };
-    let new_err = match sub_status_opt {
-        None => new_err,
-        Some(code) => new_err.with_sub_status(code),
-    };
-    let new_err = match message_opt {
-        None => new_err,
-        Some(message) => new_err.with_message(message),
-    };
-    let new_err = match exec_state_opt {
-        None => new_err,
-        Some(stacktrace) => new_err.with_exec_state(stacktrace),
-    };
-    new_err.at_indices(indices).at_code_offsets(offsets)
-}
-
-/***************************************************************************************************
- * module
- **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub empty: EmptyGasParameters,
-    pub length: LengthGasParameters,
-    pub push_back: PushBackGasParameters,
-    pub borrow: BorrowGasParameters,
-    pub pop_back: PopBackGasParameters,
-    pub destroy_empty: DestroyEmptyGasParameters,
-    pub swap: SwapGasParameters,
-}
-
-pub fn make_all(gas_params: GasParameters) -> impl Iterator<Item = (String, NativeFunction)> {
-    let natives = [
-        ("empty", make_native_empty(gas_params.empty)),
-        ("length", make_native_length(gas_params.length)),
-        ("push_back", make_native_push_back(gas_params.push_back)),
-        ("borrow", make_native_borrow(gas_params.borrow.clone())),
-        ("borrow_mut", make_native_borrow(gas_params.borrow)),
-        ("pop_back", make_native_pop_back(gas_params.pop_back)),
-        (
-            "destroy_empty",
-            make_native_destroy_empty(gas_params.destroy_empty),
-        ),
-        ("swap", make_native_swap(gas_params.swap)),
-    ];
-
-    make_module_natives(natives)
-}
diff --git a/aptos-move/framework/src/natives/account.rs b/aptos-move/framework/src/natives/account.rs
index 188c9d8866a8c..163ca71f00864 100644
--- a/aptos-move/framework/src/natives/account.rs
+++ b/aptos-move/framework/src/natives/account.rs
@@ -2,19 +2,17 @@
 // Parts of the project are originally copyright © Meta Platforms, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{
-    natives::{
-        create_signer,
-        helpers::{make_safe_native, SafeNativeContext, SafeNativeError, SafeNativeResult},
-    },
-    safely_pop_arg,
+use crate::natives::create_signer;
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext, SafeNativeError,
+    SafeNativeResult,
 };
-use aptos_types::on_chain_config::{Features, TimedFeatures};
 use move_core_types::{account_address::AccountAddress, gas_algebra::InternalGas};
 use move_vm_runtime::native_functions::NativeFunction;
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use smallvec::{smallvec, SmallVec};
-use std::{collections::VecDeque, sync::Arc};
+use std::collections::VecDeque;
 
 /***************************************************************************************************
  * native fun create_address
@@ -28,7 +26,6 @@ pub struct CreateAddressGasParameters {
 }
 
 fn native_create_address(
-    gas_params: &CreateAddressGasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -36,7 +33,7 @@ fn native_create_address(
     debug_assert!(ty_args.is_empty());
     debug_assert!(arguments.len() == 1);
 
-    context.charge(gas_params.base)?;
+    context.charge(ACCOUNT_CREATE_ADDRESS_BASE)?;
 
     let bytes = safely_pop_arg!(arguments, Vec<u8>);
     let address = AccountAddress::from_bytes(bytes);
@@ -53,39 +50,15 @@ fn native_create_address(
  * module
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub create_address: CreateAddressGasParameters,
-    pub create_signer: create_signer::CreateSignerGasParameters,
-}
-
 pub fn make_all(
-    gas_params: GasParameters,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
     let natives = [
-        (
-            "create_address",
-            make_safe_native(
-                gas_params.create_address,
-                timed_features.clone(),
-                features.clone(),
-                native_create_address,
-            ),
-        ),
+        ("create_address", native_create_address as RawSafeNative),
         // Despite that this is no longer present in account.move, we must keep this around for
         // replays.
-        (
-            "create_signer",
-            make_safe_native(
-                gas_params.create_signer,
-                timed_features,
-                features,
-                create_signer::native_create_signer,
-            ),
-        ),
+        ("create_signer", create_signer::native_create_signer),
     ];
 
-    crate::natives::helpers::make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/src/natives/aggregator_natives/aggregator.rs b/aptos-move/framework/src/natives/aggregator_natives/aggregator.rs
index 97c753f777272..63877b9bb48c0 100644
--- a/aptos-move/framework/src/natives/aggregator_natives/aggregator.rs
+++ b/aptos-move/framework/src/natives/aggregator_natives/aggregator.rs
@@ -1,26 +1,22 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{
-    natives::{
-        aggregator_natives::{
-            helpers::{aggregator_info, unpack_aggregator_struct},
-            NativeAggregatorContext,
-        },
-        helpers::{make_safe_native, SafeNativeContext, SafeNativeResult},
-    },
-    safely_pop_arg,
+use crate::natives::aggregator_natives::{
+    helpers::{aggregator_info, unpack_aggregator_struct},
+    NativeAggregatorContext,
 };
 use aptos_aggregator::aggregator_extension::AggregatorID;
-use aptos_types::on_chain_config::{Features, TimedFeatures};
-use move_core_types::gas_algebra::InternalGas;
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext, SafeNativeResult,
+};
 use move_vm_runtime::native_functions::NativeFunction;
 use move_vm_types::{
     loaded_data::runtime_types::Type,
     values::{Struct, StructRef, Value},
 };
 use smallvec::{smallvec, SmallVec};
-use std::{collections::VecDeque, sync::Arc};
+use std::collections::VecDeque;
 
 /***************************************************************************************************
  * native fun add(aggregator: &mut Aggregator, value: u128);
@@ -28,20 +24,14 @@ use std::{collections::VecDeque, sync::Arc};
  *   gas cost: base_cost
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct AddGasParameters {
-    pub base: InternalGas,
-}
-
 fn native_add(
-    gas_params: &AddGasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
 ) -> SafeNativeResult<SmallVec<[Value; 1]>> {
     debug_assert_eq!(args.len(), 2);
 
-    context.charge(gas_params.base)?;
+    context.charge(AGGREGATOR_ADD_BASE)?;
 
     // Get aggregator information and a value to add.
     let value = safely_pop_arg!(args, u128);
@@ -68,20 +58,14 @@ fn native_add(
  *   gas cost: base_cost
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct ReadGasParameters {
-    pub base: InternalGas,
-}
-
 fn native_read(
-    gas_params: &ReadGasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
 ) -> SafeNativeResult<SmallVec<[Value; 1]>> {
     debug_assert_eq!(args.len(), 1);
 
-    context.charge(gas_params.base)?;
+    context.charge(AGGREGATOR_READ_BASE)?;
 
     // Extract information from aggregator struct reference.
     let (id, limit) = aggregator_info(&safely_pop_arg!(args, StructRef))?;
@@ -107,20 +91,15 @@ fn native_read(
  *   gas cost: base_cost
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct SubGasParameters {
-    pub base: InternalGas,
-}
 
 fn native_sub(
-    gas_params: &SubGasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
 ) -> SafeNativeResult<SmallVec<[Value; 1]>> {
     debug_assert_eq!(args.len(), 2);
 
-    context.charge(gas_params.base)?;
+    context.charge(AGGREGATOR_SUB_BASE)?;
 
     // Get aggregator information and a value to subtract.
     let value = safely_pop_arg!(args, u128);
@@ -147,20 +126,14 @@ fn native_sub(
  *   gas cost: base_cost
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct DestroyGasParameters {
-    pub base: InternalGas,
-}
-
 fn native_destroy(
-    gas_params: &DestroyGasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
 ) -> SafeNativeResult<SmallVec<[Value; 1]>> {
     debug_assert_eq!(args.len(), 1);
 
-    context.charge(gas_params.base)?;
+    context.charge(AGGREGATOR_DESTROY_BASE)?;
 
     // First, unpack the struct.
     let aggregator_struct = safely_pop_arg!(args, Struct);
@@ -181,52 +154,15 @@ fn native_destroy(
  * module
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub add: AddGasParameters,
-    pub read: ReadGasParameters,
-    pub sub: SubGasParameters,
-    pub destroy: DestroyGasParameters,
-}
-
 pub fn make_all(
-    gas_params: GasParameters,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
     let natives = [
-        (
-            "add",
-            make_safe_native(
-                gas_params.add,
-                timed_features.clone(),
-                features.clone(),
-                native_add,
-            ),
-        ),
-        (
-            "read",
-            make_safe_native(
-                gas_params.read,
-                timed_features.clone(),
-                features.clone(),
-                native_read,
-            ),
-        ),
-        (
-            "sub",
-            make_safe_native(
-                gas_params.sub,
-                timed_features.clone(),
-                features.clone(),
-                native_sub,
-            ),
-        ),
-        (
-            "destroy",
-            make_safe_native(gas_params.destroy, timed_features, features, native_destroy),
-        ),
+        ("add", native_add as RawSafeNative),
+        ("read", native_read),
+        ("sub", native_sub),
+        ("destroy", native_destroy),
     ];
 
-    crate::natives::helpers::make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/src/natives/aggregator_natives/aggregator_factory.rs b/aptos-move/framework/src/natives/aggregator_natives/aggregator_factory.rs
index c539c679deeff..73efafc3aece2 100644
--- a/aptos-move/framework/src/natives/aggregator_natives/aggregator_factory.rs
+++ b/aptos-move/framework/src/natives/aggregator_natives/aggregator_factory.rs
@@ -1,27 +1,21 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{
-    natives::{
-        aggregator_natives::{helpers::get_handle, NativeAggregatorContext},
-        helpers::{make_safe_native, SafeNativeContext, SafeNativeResult},
-    },
-    safely_pop_arg,
-};
+use crate::natives::aggregator_natives::{helpers::get_handle, NativeAggregatorContext};
 use aptos_aggregator::aggregator_extension::{extension_error, AggregatorHandle, AggregatorID};
 use aptos_crypto::hash::DefaultHasher;
-use aptos_types::{
-    account_address::AccountAddress,
-    on_chain_config::{Features, TimedFeatures},
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext, SafeNativeResult,
 };
-use move_core_types::gas_algebra::InternalGas;
+use aptos_types::account_address::AccountAddress;
 use move_vm_runtime::native_functions::NativeFunction;
 use move_vm_types::{
     loaded_data::runtime_types::Type,
     values::{Struct, StructRef, Value},
 };
 use smallvec::{smallvec, SmallVec};
-use std::{collections::VecDeque, sync::Arc};
+use std::collections::VecDeque;
 
 /***************************************************************************************************
  * native fun new_aggregator(aggregator_factory: &mut AggregatorFactory, limit: u128): Aggregator;
@@ -29,20 +23,14 @@ use std::{collections::VecDeque, sync::Arc};
  *   gas cost: base_cost
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct NewAggregatorGasParameters {
-    pub base: InternalGas,
-}
-
 fn native_new_aggregator(
-    gas_params: &NewAggregatorGasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
 ) -> SafeNativeResult<SmallVec<[Value; 1]>> {
     debug_assert_eq!(args.len(), 2);
 
-    context.charge(gas_params.base)?;
+    context.charge(AGGREGATOR_FACTORY_NEW_AGGREGATOR_BASE)?;
 
     // Extract fields: `limit` of the new aggregator and a `phantom_handle` of
     // the parent factory.
@@ -81,25 +69,10 @@ fn native_new_aggregator(
  * module
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub new_aggregator: NewAggregatorGasParameters,
-}
-
 pub fn make_all(
-    gas_params: GasParameters,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
-    let natives = [(
-        "new_aggregator",
-        make_safe_native(
-            gas_params.new_aggregator,
-            timed_features,
-            features,
-            native_new_aggregator,
-        ),
-    )];
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
+    let natives = [("new_aggregator", native_new_aggregator as RawSafeNative)];
 
-    crate::natives::helpers::make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/src/natives/aggregator_natives/context.rs b/aptos-move/framework/src/natives/aggregator_natives/context.rs
index 3402c6c685a33..bb89c2389835e 100644
--- a/aptos-move/framework/src/natives/aggregator_natives/context.rs
+++ b/aptos-move/framework/src/natives/aggregator_natives/context.rs
@@ -5,10 +5,10 @@ use aptos_aggregator::{
     aggregator_extension::{AggregatorData, AggregatorID, AggregatorState},
     delta_change_set::{DeltaOp, DeltaUpdate},
 };
+use aptos_table_natives::TableResolver;
 use aptos_types::vm_status::VMStatus;
 use better_any::{Tid, TidAble};
 use move_binary_format::errors::Location;
-use move_table_extension::TableResolver;
 use std::{
     cell::RefCell,
     collections::{btree_map, BTreeMap},
diff --git a/aptos-move/framework/src/natives/aggregator_natives/helpers.rs b/aptos-move/framework/src/natives/aggregator_natives/helpers.rs
index 93b57ddbe36b7..3b7dc64dbeee2 100644
--- a/aptos-move/framework/src/natives/aggregator_natives/helpers.rs
+++ b/aptos-move/framework/src/natives/aggregator_natives/helpers.rs
@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use aptos_aggregator::aggregator_extension::{extension_error, AggregatorHandle, AggregatorID};
+use aptos_table_natives::TableHandle;
 use aptos_types::account_address::AccountAddress;
 use move_binary_format::errors::PartialVMResult;
-use move_table_extension::TableHandle;
 use move_vm_types::values::{Reference, Struct, StructRef, Value};
 
 /// The index of the `phantom_table` field in the `AggregatorFactory` Move
diff --git a/aptos-move/framework/src/natives/code.rs b/aptos-move/framework/src/natives/code.rs
index 823b4d5f6e979..aace1aac6baf1 100644
--- a/aptos-move/framework/src/natives/code.rs
+++ b/aptos-move/framework/src/natives/code.rs
@@ -1,25 +1,17 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{
-    natives::{
-        any::Any,
-        helpers::{make_safe_native, SafeNativeContext, SafeNativeError, SafeNativeResult},
-    },
-    safely_pop_arg,
-};
+use crate::natives::any::Any;
 use anyhow::bail;
-use aptos_types::{
-    on_chain_config::{Features, TimedFeatures},
-    transaction::ModuleBundle,
-    vm_status::StatusCode,
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext, SafeNativeError,
+    SafeNativeResult,
 };
+use aptos_types::{transaction::ModuleBundle, vm_status::StatusCode};
 use better_any::{Tid, TidAble};
 use move_binary_format::errors::{PartialVMError, PartialVMResult};
-use move_core_types::{
-    account_address::AccountAddress,
-    gas_algebra::{InternalGas, InternalGasPerByte, NumBytes},
-};
+use move_core_types::{account_address::AccountAddress, gas_algebra::NumBytes};
 use move_vm_runtime::native_functions::NativeFunction;
 use move_vm_types::{
     loaded_data::runtime_types::Type,
@@ -31,7 +23,6 @@ use std::{
     collections::{btree_map::Entry, BTreeMap, BTreeSet, VecDeque},
     fmt,
     str::FromStr,
-    sync::Arc,
 };
 
 /// A wrapper around the representation of a Move Option, which is a vector with 0 or 1 element.
@@ -215,14 +206,7 @@ fn unpack_allowed_dep(v: Value) -> PartialVMResult<(AccountAddress, String)> {
  *   gas cost: base_cost + unit_cost * bytes_len
  *
  **************************************************************************************************/
-#[derive(Clone, Debug)]
-pub struct RequestPublishGasParameters {
-    pub base: InternalGas,
-    pub per_byte: InternalGasPerByte,
-}
-
 fn native_request_publish(
-    gas_params: &RequestPublishGasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -230,14 +214,14 @@ fn native_request_publish(
     debug_assert!(matches!(args.len(), 4 | 5));
     let with_allowed_deps = args.len() == 5;
 
-    context.charge(gas_params.base)?;
+    context.charge(CODE_REQUEST_PUBLISH_BASE)?;
 
     let policy = safely_pop_arg!(args, u8);
     let mut code = vec![];
     for module in safely_pop_arg!(args, Vec<Value>) {
         let module_code = module.value_as::<Vec<u8>>()?;
 
-        context.charge(gas_params.per_byte * NumBytes::new(module_code.len() as u64))?;
+        context.charge(CODE_REQUEST_PUBLISH_PER_BYTE * NumBytes::new(module_code.len() as u64))?;
         code.push(module_code);
     }
 
@@ -251,10 +235,11 @@ fn native_request_publish(
 
             if let Entry::Vacant(_) = &entry {
                 // TODO: Is the 32 here supposed to indicate the length of an account address in bytes?
-                context.charge(gas_params.per_byte * NumBytes::new(32))?;
+                context.charge(CODE_REQUEST_PUBLISH_PER_BYTE * NumBytes::new(32))?;
             }
 
-            context.charge(gas_params.per_byte * NumBytes::new(module_name.len() as u64))?;
+            context
+                .charge(CODE_REQUEST_PUBLISH_PER_BYTE * NumBytes::new(module_name.len() as u64))?;
             entry.or_default().insert(module_name);
         }
 
@@ -268,7 +253,7 @@ fn native_request_publish(
         let str = get_move_string(name)?;
 
         // TODO(Gas): fine tune the gas formula
-        context.charge(gas_params.per_byte * NumBytes::new(str.len() as u64))?;
+        context.charge(CODE_REQUEST_PUBLISH_PER_BYTE * NumBytes::new(str.len() as u64))?;
         expected_modules.insert(str);
     }
 
@@ -305,36 +290,13 @@ fn native_request_publish(
  * module
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub request_publish: RequestPublishGasParameters,
-}
-
 pub fn make_all(
-    gas_params: GasParameters,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
     let natives = [
-        (
-            "request_publish",
-            make_safe_native(
-                gas_params.request_publish.clone(),
-                timed_features.clone(),
-                features.clone(),
-                native_request_publish,
-            ),
-        ),
-        (
-            "request_publish_with_allowed_deps",
-            make_safe_native(
-                gas_params.request_publish,
-                timed_features,
-                features,
-                native_request_publish,
-            ),
-        ),
+        ("request_publish", native_request_publish as RawSafeNative),
+        ("request_publish_with_allowed_deps", native_request_publish),
     ];
 
-    crate::natives::helpers::make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/src/natives/create_signer.rs b/aptos-move/framework/src/natives/create_signer.rs
index d59b1c36e63bc..c8605088113da 100644
--- a/aptos-move/framework/src/natives/create_signer.rs
+++ b/aptos-move/framework/src/natives/create_signer.rs
@@ -1,16 +1,15 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{
-    natives::helpers::{make_safe_native, SafeNativeContext, SafeNativeResult},
-    safely_pop_arg,
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext, SafeNativeResult,
 };
-use aptos_types::on_chain_config::{Features, TimedFeatures};
-use move_core_types::{account_address::AccountAddress, gas_algebra::InternalGas};
+use move_core_types::account_address::AccountAddress;
 use move_vm_runtime::native_functions::NativeFunction;
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use smallvec::{smallvec, SmallVec};
-use std::{collections::VecDeque, sync::Arc};
+use std::collections::VecDeque;
 
 /***************************************************************************************************
  * native fun create_signer
@@ -19,7 +18,6 @@ use std::{collections::VecDeque, sync::Arc};
  *
  **************************************************************************************************/
 pub(crate) fn native_create_signer(
-    gas_params: &CreateSignerGasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -27,7 +25,7 @@ pub(crate) fn native_create_signer(
     debug_assert!(ty_args.is_empty());
     debug_assert!(arguments.len() == 1);
 
-    context.charge(gas_params.base)?;
+    context.charge(ACCOUNT_CREATE_SIGNER_BASE)?;
 
     let address = safely_pop_arg!(arguments, AccountAddress);
     Ok(smallvec![Value::signer(address)])
@@ -37,20 +35,10 @@ pub(crate) fn native_create_signer(
  * module
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct CreateSignerGasParameters {
-    pub base: InternalGas,
-}
-
 pub fn make_all(
-    gas_param: CreateSignerGasParameters,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
-    let natives = [(
-        "create_signer",
-        make_safe_native(gas_param, timed_features, features, native_create_signer),
-    )];
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
+    let natives = [("create_signer", native_create_signer as RawSafeNative)];
 
-    crate::natives::helpers::make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/add.rs b/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/add.rs
index ecf15eb058480..fd17cab168dbd 100644
--- a/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/add.rs
+++ b/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/add.rs
@@ -3,17 +3,14 @@
 use crate::{
     abort_unless_arithmetics_enabled_for_structure, abort_unless_feature_flag_enabled,
     ark_binary_op_internal,
-    natives::{
-        cryptography::algebra::{
-            abort_invariant_violated, feature_flag_from_structure, gas::GasParameters,
-            AlgebraContext, Structure, E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES,
-            MOVE_ABORT_CODE_NOT_IMPLEMENTED,
-        },
-        helpers::{SafeNativeContext, SafeNativeError, SafeNativeResult},
+    natives::cryptography::algebra::{
+        abort_invariant_violated, feature_flag_from_structure, AlgebraContext, Structure,
+        E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES, MOVE_ABORT_CODE_NOT_IMPLEMENTED,
     },
-    safe_borrow_element, safely_pop_arg, store_element, structure_from_ty_arg,
+    safe_borrow_element, store_element, structure_from_ty_arg,
 };
-use move_core_types::gas_algebra::NumArgs;
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{SafeNativeContext, SafeNativeError, SafeNativeResult};
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use smallvec::{smallvec, SmallVec};
 use std::{
@@ -23,7 +20,6 @@ use std::{
 };
 
 pub fn add_internal(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -36,36 +32,36 @@ pub fn add_internal(
             context,
             args,
             ark_bls12_381::Fr,
-            add,
-            gas_params.ark_bls12_381_fr_add * NumArgs::one()
+            Add::add,
+            ALGEBRA_ARK_BLS12_381_FR_ADD
         ),
         Some(Structure::BLS12381Fq12) => ark_binary_op_internal!(
             context,
             args,
             ark_bls12_381::Fq12,
-            add,
-            gas_params.ark_bls12_381_fq12_add * NumArgs::one()
+            Add::add,
+            ALGEBRA_ARK_BLS12_381_FQ12_ADD
         ),
         Some(Structure::BLS12381G1) => ark_binary_op_internal!(
             context,
             args,
             ark_bls12_381::G1Projective,
-            add,
-            gas_params.ark_bls12_381_g1_proj_add * NumArgs::one()
+            Add::add,
+            ALGEBRA_ARK_BLS12_381_G1_PROJ_ADD
         ),
         Some(Structure::BLS12381G2) => ark_binary_op_internal!(
             context,
             args,
             ark_bls12_381::G2Projective,
-            add,
-            gas_params.ark_bls12_381_g2_proj_add * NumArgs::one()
+            Add::add,
+            ALGEBRA_ARK_BLS12_381_G2_PROJ_ADD
         ),
         Some(Structure::BLS12381Gt) => ark_binary_op_internal!(
             context,
             args,
             ark_bls12_381::Fq12,
-            mul,
-            gas_params.ark_bls12_381_fq12_mul * NumArgs::one()
+            Mul::mul,
+            ALGEBRA_ARK_BLS12_381_FQ12_MUL
         ),
         _ => Err(SafeNativeError::Abort {
             abort_code: MOVE_ABORT_CODE_NOT_IMPLEMENTED,
diff --git a/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/div.rs b/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/div.rs
index 52a46565b1b99..1b1f5a977a5b0 100644
--- a/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/div.rs
+++ b/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/div.rs
@@ -2,17 +2,16 @@
 
 use crate::{
     abort_unless_arithmetics_enabled_for_structure, abort_unless_feature_flag_enabled,
-    natives::{
-        cryptography::algebra::{
-            abort_invariant_violated, feature_flag_from_structure, gas::GasParameters,
-            AlgebraContext, Structure, E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES,
-            MOVE_ABORT_CODE_NOT_IMPLEMENTED,
-        },
-        helpers::{SafeNativeContext, SafeNativeError, SafeNativeResult},
+    natives::cryptography::algebra::{
+        abort_invariant_violated, feature_flag_from_structure, AlgebraContext, Structure,
+        E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES, MOVE_ABORT_CODE_NOT_IMPLEMENTED,
     },
-    safe_borrow_element, safely_pop_arg, store_element, structure_from_ty_arg,
+    safe_borrow_element, store_element, structure_from_ty_arg,
+};
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_pop_arg, SafeNativeContext, SafeNativeError, SafeNativeResult,
 };
-use move_core_types::gas_algebra::NumArgs;
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use num_traits::Zero;
 use smallvec::{smallvec, SmallVec};
@@ -36,7 +35,6 @@ macro_rules! ark_div_internal {
 }
 
 pub fn div_internal(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -50,16 +48,16 @@ pub fn div_internal(
             args,
             ark_bls12_381::Fr,
             div,
-            gas_params.ark_bls12_381_fr_eq * NumArgs::one(),
-            gas_params.ark_bls12_381_fr_div * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_FR_EQ,
+            ALGEBRA_ARK_BLS12_381_FR_DIV
         ),
         Some(Structure::BLS12381Fq12) => ark_div_internal!(
             context,
             args,
             ark_bls12_381::Fq12,
             div,
-            gas_params.ark_bls12_381_fq12_eq * NumArgs::one(),
-            gas_params.ark_bls12_381_fq12_div * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_FQ12_EQ,
+            ALGEBRA_ARK_BLS12_381_FQ12_DIV
         ),
         _ => Err(SafeNativeError::Abort {
             abort_code: MOVE_ABORT_CODE_NOT_IMPLEMENTED,
diff --git a/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/double.rs b/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/double.rs
index 178c742d254db..f6137121b01e9 100644
--- a/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/double.rs
+++ b/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/double.rs
@@ -3,25 +3,21 @@
 use crate::{
     abort_unless_arithmetics_enabled_for_structure, abort_unless_feature_flag_enabled,
     ark_unary_op_internal,
-    natives::{
-        cryptography::algebra::{
-            abort_invariant_violated, feature_flag_from_structure, gas::GasParameters,
-            AlgebraContext, Structure, E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES,
-            MOVE_ABORT_CODE_NOT_IMPLEMENTED,
-        },
-        helpers::{SafeNativeContext, SafeNativeError, SafeNativeResult},
+    natives::cryptography::algebra::{
+        abort_invariant_violated, feature_flag_from_structure, AlgebraContext, Structure,
+        E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES, MOVE_ABORT_CODE_NOT_IMPLEMENTED,
     },
-    safe_borrow_element, safely_pop_arg, store_element, structure_from_ty_arg,
+    safe_borrow_element, store_element, structure_from_ty_arg,
 };
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{SafeNativeContext, SafeNativeError, SafeNativeResult};
 use ark_ec::Group;
 use ark_ff::Field;
-use move_core_types::gas_algebra::NumArgs;
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use smallvec::{smallvec, SmallVec};
 use std::{collections::VecDeque, rc::Rc};
 
 pub fn double_internal(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -35,21 +31,21 @@ pub fn double_internal(
             args,
             ark_bls12_381::G1Projective,
             double,
-            gas_params.ark_bls12_381_g1_proj_double * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_G1_PROJ_DOUBLE
         ),
         Some(Structure::BLS12381G2) => ark_unary_op_internal!(
             context,
             args,
             ark_bls12_381::G2Projective,
             double,
-            gas_params.ark_bls12_381_g2_proj_double * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_G2_PROJ_DOUBLE
         ),
         Some(Structure::BLS12381Gt) => ark_unary_op_internal!(
             context,
             args,
             ark_bls12_381::Fq12,
             square,
-            gas_params.ark_bls12_381_fq12_square * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_FQ12_SQUARE
         ),
         _ => Err(SafeNativeError::Abort {
             abort_code: MOVE_ABORT_CODE_NOT_IMPLEMENTED,
diff --git a/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/inv.rs b/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/inv.rs
index 13e3c3cb13602..5500230abfe8d 100644
--- a/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/inv.rs
+++ b/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/inv.rs
@@ -2,18 +2,17 @@
 
 use crate::{
     abort_unless_arithmetics_enabled_for_structure, abort_unless_feature_flag_enabled,
-    natives::{
-        cryptography::algebra::{
-            abort_invariant_violated, feature_flag_from_structure, gas::GasParameters,
-            AlgebraContext, Structure, E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES,
-            MOVE_ABORT_CODE_NOT_IMPLEMENTED,
-        },
-        helpers::{SafeNativeContext, SafeNativeError, SafeNativeResult},
+    natives::cryptography::algebra::{
+        abort_invariant_violated, feature_flag_from_structure, AlgebraContext, Structure,
+        E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES, MOVE_ABORT_CODE_NOT_IMPLEMENTED,
     },
-    safe_borrow_element, safely_pop_arg, store_element, structure_from_ty_arg,
+    safe_borrow_element, store_element, structure_from_ty_arg,
+};
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_pop_arg, SafeNativeContext, SafeNativeError, SafeNativeResult,
 };
 use ark_ff::Field;
-use move_core_types::gas_algebra::NumArgs;
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use smallvec::{smallvec, SmallVec};
 use std::{collections::VecDeque, rc::Rc};
@@ -34,7 +33,6 @@ macro_rules! ark_inverse_internal {
 }
 
 pub fn inv_internal(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -46,13 +44,13 @@ pub fn inv_internal(
             context,
             args,
             ark_bls12_381::Fr,
-            gas_params.ark_bls12_381_fr_inv * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_FR_INV
         ),
         Some(Structure::BLS12381Fq12) => ark_inverse_internal!(
             context,
             args,
             ark_bls12_381::Fq12,
-            gas_params.ark_bls12_381_fq12_inv * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_FQ12_INV
         ),
         _ => Err(SafeNativeError::Abort {
             abort_code: MOVE_ABORT_CODE_NOT_IMPLEMENTED,
diff --git a/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/mod.rs b/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/mod.rs
index bb218a8a6946d..3bfa2f74a28ff 100644
--- a/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/mod.rs
+++ b/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/mod.rs
@@ -12,13 +12,13 @@ pub mod sub;
 
 #[macro_export]
 macro_rules! ark_binary_op_internal {
-    ($context:expr, $args:ident, $ark_typ:ty, $ark_func:ident, $gas:expr) => {{
-        let handle_2 = safely_pop_arg!($args, u64) as usize;
-        let handle_1 = safely_pop_arg!($args, u64) as usize;
+    ($context:expr, $args:ident, $ark_typ:ty, $ark_func:expr, $gas:expr) => {{
+        let handle_2 = aptos_native_interface::safely_pop_arg!($args, u64) as usize;
+        let handle_1 = aptos_native_interface::safely_pop_arg!($args, u64) as usize;
         safe_borrow_element!($context, handle_1, $ark_typ, element_1_ptr, element_1);
         safe_borrow_element!($context, handle_2, $ark_typ, element_2_ptr, element_2);
         $context.charge($gas)?;
-        let new_element = element_1.$ark_func(element_2);
+        let new_element = $ark_func(element_1, element_2);
         let new_handle = store_element!($context, new_element)?;
         Ok(smallvec![Value::u64(new_handle as u64)])
     }};
@@ -27,7 +27,7 @@ macro_rules! ark_binary_op_internal {
 #[macro_export]
 macro_rules! ark_unary_op_internal {
     ($context:expr, $args:ident, $ark_typ:ty, $ark_func:ident, $gas:expr) => {{
-        let handle = safely_pop_arg!($args, u64) as usize;
+        let handle = aptos_native_interface::safely_pop_arg!($args, u64) as usize;
         safe_borrow_element!($context, handle, $ark_typ, element_ptr, element);
         $context.charge($gas)?;
         let new_element = element.$ark_func();
diff --git a/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/mul.rs b/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/mul.rs
index 30859abd0cc85..c5dc740d89578 100644
--- a/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/mul.rs
+++ b/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/mul.rs
@@ -3,23 +3,19 @@
 use crate::{
     abort_unless_arithmetics_enabled_for_structure, abort_unless_feature_flag_enabled,
     ark_binary_op_internal,
-    natives::{
-        cryptography::algebra::{
-            abort_invariant_violated, feature_flag_from_structure, gas::GasParameters,
-            AlgebraContext, Structure, E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES,
-            MOVE_ABORT_CODE_NOT_IMPLEMENTED,
-        },
-        helpers::{SafeNativeContext, SafeNativeError, SafeNativeResult},
+    natives::cryptography::algebra::{
+        abort_invariant_violated, feature_flag_from_structure, AlgebraContext, Structure,
+        E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES, MOVE_ABORT_CODE_NOT_IMPLEMENTED,
     },
-    safe_borrow_element, safely_pop_arg, store_element, structure_from_ty_arg,
+    safe_borrow_element, store_element, structure_from_ty_arg,
 };
-use move_core_types::gas_algebra::NumArgs;
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{SafeNativeContext, SafeNativeError, SafeNativeResult};
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use smallvec::{smallvec, SmallVec};
 use std::{collections::VecDeque, ops::Mul, rc::Rc};
 
 pub fn mul_internal(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -32,15 +28,15 @@ pub fn mul_internal(
             context,
             args,
             ark_bls12_381::Fr,
-            mul,
-            gas_params.ark_bls12_381_fr_mul * NumArgs::one()
+            Mul::mul,
+            ALGEBRA_ARK_BLS12_381_FR_MUL
         ),
         Some(Structure::BLS12381Fq12) => ark_binary_op_internal!(
             context,
             args,
             ark_bls12_381::Fq12,
-            mul,
-            gas_params.ark_bls12_381_fq12_mul * NumArgs::one()
+            Mul::mul,
+            ALGEBRA_ARK_BLS12_381_FQ12_MUL
         ),
         _ => Err(SafeNativeError::Abort {
             abort_code: MOVE_ABORT_CODE_NOT_IMPLEMENTED,
diff --git a/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/neg.rs b/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/neg.rs
index 34bb697ab3736..e0dfdf0b2f339 100644
--- a/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/neg.rs
+++ b/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/neg.rs
@@ -3,24 +3,22 @@
 use crate::{
     abort_unless_arithmetics_enabled_for_structure, abort_unless_feature_flag_enabled,
     ark_unary_op_internal,
-    natives::{
-        cryptography::algebra::{
-            abort_invariant_violated, feature_flag_from_structure, gas::GasParameters,
-            AlgebraContext, Structure, E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES,
-            MOVE_ABORT_CODE_NOT_IMPLEMENTED,
-        },
-        helpers::{SafeNativeContext, SafeNativeError, SafeNativeResult},
+    natives::cryptography::algebra::{
+        abort_invariant_violated, feature_flag_from_structure, AlgebraContext, Structure,
+        E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES, MOVE_ABORT_CODE_NOT_IMPLEMENTED,
     },
-    safe_borrow_element, safely_pop_arg, store_element, structure_from_ty_arg,
+    safe_borrow_element, store_element, structure_from_ty_arg,
+};
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_pop_arg, SafeNativeContext, SafeNativeError, SafeNativeResult,
 };
 use ark_ff::Field;
-use move_core_types::gas_algebra::NumArgs;
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use smallvec::{smallvec, SmallVec};
 use std::{collections::VecDeque, ops::Neg, rc::Rc};
 
 pub fn neg_internal(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -34,33 +32,33 @@ pub fn neg_internal(
             args,
             ark_bls12_381::Fr,
             neg,
-            gas_params.ark_bls12_381_fr_neg * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_FR_NEG
         ),
         Some(Structure::BLS12381Fq12) => ark_unary_op_internal!(
             context,
             args,
             ark_bls12_381::Fq12,
             neg,
-            gas_params.ark_bls12_381_fq12_neg * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_FQ12_NEG
         ),
         Some(Structure::BLS12381G1) => ark_unary_op_internal!(
             context,
             args,
             ark_bls12_381::G1Projective,
             neg,
-            gas_params.ark_bls12_381_g1_proj_neg * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_G1_PROJ_NEG
         ),
         Some(Structure::BLS12381G2) => ark_unary_op_internal!(
             context,
             args,
             ark_bls12_381::G2Projective,
             neg,
-            gas_params.ark_bls12_381_g2_proj_neg * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_G2_PROJ_NEG
         ),
         Some(Structure::BLS12381Gt) => {
             let handle = safely_pop_arg!(args, u64) as usize;
             safe_borrow_element!(context, handle, ark_bls12_381::Fq12, element_ptr, element);
-            context.charge(gas_params.ark_bls12_381_fq12_inv * NumArgs::one())?;
+            context.charge(ALGEBRA_ARK_BLS12_381_FQ12_INV)?;
             let new_element = element.inverse().ok_or_else(abort_invariant_violated)?;
             let new_handle = store_element!(context, new_element)?;
             Ok(smallvec![Value::u64(new_handle as u64)])
diff --git a/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/scalar_mul.rs b/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/scalar_mul.rs
index 2319fc50b84b0..8e22f39166b9a 100644
--- a/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/scalar_mul.rs
+++ b/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/scalar_mul.rs
@@ -4,18 +4,23 @@ use crate::{
     abort_unless_feature_flag_enabled,
     natives::{
         cryptography::algebra::{
-            abort_invariant_violated, gas::GasParameters, AlgebraContext, Structure,
-            E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES,
-            MOVE_ABORT_CODE_INPUT_VECTOR_SIZES_NOT_MATCHING, MOVE_ABORT_CODE_NOT_IMPLEMENTED,
+            abort_invariant_violated, AlgebraContext, Structure, E_TOO_MUCH_MEMORY_USED,
+            MEMORY_LIMIT_IN_BYTES, MOVE_ABORT_CODE_INPUT_VECTOR_SIZES_NOT_MATCHING,
+            MOVE_ABORT_CODE_NOT_IMPLEMENTED,
         },
-        helpers::{log2_ceil, SafeNativeContext, SafeNativeError, SafeNativeResult},
+        helpers::log2_ceil,
     },
-    safe_borrow_element, safely_pop_arg, store_element, structure_from_ty_arg,
+    safe_borrow_element, store_element, structure_from_ty_arg,
+};
+use aptos_gas_algebra::{Arg, GasExpression};
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_pop_arg, SafeNativeContext, SafeNativeError, SafeNativeResult,
 };
 use aptos_types::on_chain_config::FeatureFlag;
 use ark_ec::{CurveGroup, Group};
 use ark_ff::Field;
-use move_core_types::gas_algebra::{InternalGas, InternalGasPerArg, NumArgs};
+use move_core_types::gas_algebra::NumArgs;
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use smallvec::{smallvec, SmallVec};
 use std::{collections::VecDeque, rc::Rc};
@@ -65,20 +70,18 @@ fn ark_msm_window_size(num_entries: usize) -> usize {
 }
 
 /// The approximate cost model of https://github.com/arkworks-rs/algebra/blob/v0.4.0/ec/src/scalar_mul/variable_base/mod.rs#L89.
-pub fn ark_msm_bigint_wnaf_cost(
-    cost_add: InternalGasPerArg,
-    cost_double: InternalGasPerArg,
-    num_entries: usize,
-) -> InternalGas {
-    let window_size = ark_msm_window_size(num_entries);
-    let num_windows = (255 + window_size - 1) / window_size;
-    let num_buckets = 1_usize << window_size;
-    cost_add * NumArgs::from(((num_entries + num_buckets + 1) * num_windows) as u64)
-        + cost_double * NumArgs::from((num_buckets * num_windows) as u64)
+macro_rules! ark_msm_bigint_wnaf_cost {
+    ($cost_add:expr, $cost_double:expr, $num_entries:expr $(,)?) => {{
+        let num_entries: usize = $num_entries;
+        let window_size = ark_msm_window_size(num_entries);
+        let num_windows = (255 + window_size - 1) / window_size;
+        let num_buckets = 1_usize << window_size;
+        $cost_add * NumArgs::from(((num_entries + num_buckets + 1) * num_windows) as u64)
+            + $cost_double * NumArgs::from((num_buckets * num_windows) as u64)
+    }};
 }
 
 pub fn scalar_mul_internal(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -95,7 +98,7 @@ pub fn scalar_mul_internal(
                 ark_bls12_381::G1Projective,
                 ark_bls12_381::Fr,
                 mul_bigint,
-                gas_params.ark_bls12_381_g1_proj_scalar_mul * NumArgs::one()
+                ALGEBRA_ARK_BLS12_381_G1_PROJ_SCALAR_MUL
             )
         },
         (Some(Structure::BLS12381G2), Some(Structure::BLS12381Fr)) => {
@@ -105,7 +108,7 @@ pub fn scalar_mul_internal(
                 ark_bls12_381::G2Projective,
                 ark_bls12_381::Fr,
                 mul_bigint,
-                gas_params.ark_bls12_381_g2_proj_scalar_mul * NumArgs::one()
+                ALGEBRA_ARK_BLS12_381_G2_PROJ_SCALAR_MUL
             )
         },
         (Some(Structure::BLS12381Gt), Some(Structure::BLS12381Fr)) => {
@@ -126,7 +129,7 @@ pub fn scalar_mul_internal(
                 scalar
             );
             let scalar_bigint: ark_ff::BigInteger256 = (*scalar).into();
-            context.charge(gas_params.ark_bls12_381_fq12_pow_u256 * NumArgs::one())?;
+            context.charge(ALGEBRA_ARK_BLS12_381_FQ12_POW_U256)?;
             let new_element = element.pow(scalar_bigint);
             let new_handle = store_element!(context, new_element)?;
             Ok(smallvec![Value::u64(new_handle as u64)])
@@ -173,7 +176,7 @@ macro_rules! ark_msm_internal {
             safe_borrow_element!($context, handle as usize, $scalar_typ, scalar_ptr, scalar);
             scalars.push(scalar.clone());
         }
-        $context.charge(ark_msm_bigint_wnaf_cost(
+        $context.charge(ark_msm_bigint_wnaf_cost!(
             $proj_add_cost,
             $proj_double_cost,
             num_elements,
@@ -186,7 +189,6 @@ macro_rules! ark_msm_internal {
 }
 
 pub fn multi_scalar_mul_internal(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -200,9 +202,9 @@ pub fn multi_scalar_mul_internal(
             ark_msm_internal!(
                 context,
                 args,
-                gas_params.ark_bls12_381_g1_proj_to_affine,
-                gas_params.ark_bls12_381_g1_proj_add,
-                gas_params.ark_bls12_381_g1_proj_double,
+                ALGEBRA_ARK_BLS12_381_G1_PROJ_TO_AFFINE.per::<Arg>(),
+                ALGEBRA_ARK_BLS12_381_G1_PROJ_ADD.per::<Arg>(),
+                ALGEBRA_ARK_BLS12_381_G1_PROJ_DOUBLE.per::<Arg>(),
                 ark_bls12_381::G1Projective,
                 ark_bls12_381::Fr
             )
@@ -211,9 +213,9 @@ pub fn multi_scalar_mul_internal(
             ark_msm_internal!(
                 context,
                 args,
-                gas_params.ark_bls12_381_g2_proj_to_affine,
-                gas_params.ark_bls12_381_g2_proj_add,
-                gas_params.ark_bls12_381_g2_proj_double,
+                ALGEBRA_ARK_BLS12_381_G2_PROJ_TO_AFFINE.per::<Arg>(),
+                ALGEBRA_ARK_BLS12_381_G2_PROJ_ADD.per::<Arg>(),
+                ALGEBRA_ARK_BLS12_381_G2_PROJ_DOUBLE.per::<Arg>(),
                 ark_bls12_381::G2Projective,
                 ark_bls12_381::Fr
             )
diff --git a/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/sqr.rs b/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/sqr.rs
index 2a94f8dcbeae6..34fe76f3f0b94 100644
--- a/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/sqr.rs
+++ b/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/sqr.rs
@@ -3,24 +3,20 @@
 use crate::{
     abort_unless_arithmetics_enabled_for_structure, abort_unless_feature_flag_enabled,
     ark_unary_op_internal,
-    natives::{
-        cryptography::algebra::{
-            abort_invariant_violated, feature_flag_from_structure, gas::GasParameters,
-            AlgebraContext, Structure, E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES,
-            MOVE_ABORT_CODE_NOT_IMPLEMENTED,
-        },
-        helpers::{SafeNativeContext, SafeNativeError, SafeNativeResult},
+    natives::cryptography::algebra::{
+        abort_invariant_violated, feature_flag_from_structure, AlgebraContext, Structure,
+        E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES, MOVE_ABORT_CODE_NOT_IMPLEMENTED,
     },
-    safe_borrow_element, safely_pop_arg, store_element, structure_from_ty_arg,
+    safe_borrow_element, store_element, structure_from_ty_arg,
 };
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{SafeNativeContext, SafeNativeError, SafeNativeResult};
 use ark_ff::Field;
-use move_core_types::gas_algebra::NumArgs;
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use smallvec::{smallvec, SmallVec};
 use std::{collections::VecDeque, rc::Rc};
 
 pub fn sqr_internal(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -33,14 +29,14 @@ pub fn sqr_internal(
             args,
             ark_bls12_381::Fr,
             square,
-            gas_params.ark_bls12_381_fr_square * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_FR_SQUARE
         ),
         Some(Structure::BLS12381Fq12) => ark_unary_op_internal!(
             context,
             args,
             ark_bls12_381::Fq12,
             square,
-            gas_params.ark_bls12_381_fq12_square * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_FQ12_SQUARE
         ),
         _ => Err(SafeNativeError::Abort {
             abort_code: MOVE_ABORT_CODE_NOT_IMPLEMENTED,
diff --git a/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/sub.rs b/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/sub.rs
index 3b3bbf167614d..e4ea266ed0f16 100644
--- a/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/sub.rs
+++ b/aptos-move/framework/src/natives/cryptography/algebra/arithmetics/sub.rs
@@ -3,17 +3,14 @@
 use crate::{
     abort_unless_arithmetics_enabled_for_structure, abort_unless_feature_flag_enabled,
     ark_binary_op_internal,
-    natives::{
-        cryptography::algebra::{
-            abort_invariant_violated, feature_flag_from_structure, gas::GasParameters,
-            AlgebraContext, Structure, E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES,
-            MOVE_ABORT_CODE_NOT_IMPLEMENTED,
-        },
-        helpers::{SafeNativeContext, SafeNativeError, SafeNativeResult},
+    natives::cryptography::algebra::{
+        abort_invariant_violated, feature_flag_from_structure, AlgebraContext, Structure,
+        E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES, MOVE_ABORT_CODE_NOT_IMPLEMENTED,
     },
-    safe_borrow_element, safely_pop_arg, store_element, structure_from_ty_arg,
+    safe_borrow_element, store_element, structure_from_ty_arg,
 };
-use move_core_types::gas_algebra::NumArgs;
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{SafeNativeContext, SafeNativeError, SafeNativeResult};
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use smallvec::{smallvec, SmallVec};
 use std::{
@@ -23,7 +20,6 @@ use std::{
 };
 
 pub fn sub_internal(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -36,36 +32,36 @@ pub fn sub_internal(
             context,
             args,
             ark_bls12_381::Fr,
-            sub,
-            gas_params.ark_bls12_381_fr_sub * NumArgs::one()
+            Sub::sub,
+            ALGEBRA_ARK_BLS12_381_FR_SUB
         ),
         Some(Structure::BLS12381Fq12) => ark_binary_op_internal!(
             context,
             args,
             ark_bls12_381::Fq12,
-            sub,
-            gas_params.ark_bls12_381_fq12_sub * NumArgs::one()
+            Sub::sub,
+            ALGEBRA_ARK_BLS12_381_FQ12_SUB
         ),
         Some(Structure::BLS12381G1) => ark_binary_op_internal!(
             context,
             args,
             ark_bls12_381::G1Projective,
-            sub,
-            gas_params.ark_bls12_381_g1_proj_sub * NumArgs::one()
+            Sub::sub,
+            ALGEBRA_ARK_BLS12_381_G1_PROJ_SUB
         ),
         Some(Structure::BLS12381G2) => ark_binary_op_internal!(
             context,
             args,
             ark_bls12_381::G2Projective,
-            sub,
-            gas_params.ark_bls12_381_g2_proj_sub * NumArgs::one()
+            Sub::sub,
+            ALGEBRA_ARK_BLS12_381_G2_PROJ_SUB
         ),
         Some(Structure::BLS12381Gt) => ark_binary_op_internal!(
             context,
             args,
             ark_bls12_381::Fq12,
-            div,
-            gas_params.ark_bls12_381_fq12_div * NumArgs::one()
+            Div::div,
+            ALGEBRA_ARK_BLS12_381_FQ12_DIV
         ),
         _ => Err(SafeNativeError::Abort {
             abort_code: MOVE_ABORT_CODE_NOT_IMPLEMENTED,
diff --git a/aptos-move/framework/src/natives/cryptography/algebra/casting.rs b/aptos-move/framework/src/natives/cryptography/algebra/casting.rs
index 58fd75e0cb02e..43bd4d09f840e 100644
--- a/aptos-move/framework/src/natives/cryptography/algebra/casting.rs
+++ b/aptos-move/framework/src/natives/cryptography/algebra/casting.rs
@@ -2,18 +2,18 @@
 
 use crate::{
     abort_unless_feature_flag_enabled,
-    natives::{
-        cryptography::algebra::{
-            abort_invariant_violated, gas::GasParameters, AlgebraContext, Structure,
-            BLS12381_R_SCALAR, MOVE_ABORT_CODE_NOT_IMPLEMENTED,
-        },
-        helpers::{SafeNativeContext, SafeNativeError, SafeNativeResult},
+    natives::cryptography::algebra::{
+        abort_invariant_violated, AlgebraContext, Structure, BLS12381_R_SCALAR,
+        MOVE_ABORT_CODE_NOT_IMPLEMENTED,
     },
-    safe_borrow_element, safely_pop_arg, structure_from_ty_arg,
+    safe_borrow_element, structure_from_ty_arg,
+};
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_pop_arg, SafeNativeContext, SafeNativeError, SafeNativeResult,
 };
 use aptos_types::on_chain_config::FeatureFlag;
 use ark_ff::Field;
-use move_core_types::gas_algebra::NumArgs;
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use num_traits::One;
 use smallvec::{smallvec, SmallVec};
@@ -39,7 +39,6 @@ macro_rules! abort_unless_casting_enabled {
 }
 
 pub fn downcast_internal(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -52,7 +51,7 @@ pub fn downcast_internal(
         (Some(Structure::BLS12381Fq12), Some(Structure::BLS12381Gt)) => {
             let handle = safely_pop_arg!(args, u64) as usize;
             safe_borrow_element!(context, handle, ark_bls12_381::Fq12, element_ptr, element);
-            context.charge(gas_params.ark_bls12_381_fq12_pow_u256 * NumArgs::one())?;
+            context.charge(ALGEBRA_ARK_BLS12_381_FQ12_POW_U256)?;
             if element.pow(BLS12381_R_SCALAR.0) == ark_bls12_381::Fq12::one() {
                 Ok(smallvec![Value::bool(true), Value::u64(handle as u64)])
             } else {
@@ -66,7 +65,6 @@ pub fn downcast_internal(
 }
 
 pub fn upcast_internal(
-    _gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
diff --git a/aptos-move/framework/src/natives/cryptography/algebra/constants.rs b/aptos-move/framework/src/natives/cryptography/algebra/constants.rs
index 0f73c36cfff56..73eadaf01d38d 100644
--- a/aptos-move/framework/src/natives/cryptography/algebra/constants.rs
+++ b/aptos-move/framework/src/natives/cryptography/algebra/constants.rs
@@ -2,18 +2,16 @@
 
 use crate::{
     abort_unless_arithmetics_enabled_for_structure, abort_unless_feature_flag_enabled,
-    natives::{
-        cryptography::algebra::{
-            feature_flag_from_structure, gas::GasParameters, AlgebraContext, Structure,
-            BLS12381_GT_GENERATOR, BLS12381_Q12_LENDIAN, BLS12381_R_LENDIAN,
-            E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES, MOVE_ABORT_CODE_NOT_IMPLEMENTED,
-        },
-        helpers::{SafeNativeContext, SafeNativeError, SafeNativeResult},
+    natives::cryptography::algebra::{
+        feature_flag_from_structure, AlgebraContext, Structure, BLS12381_GT_GENERATOR,
+        BLS12381_Q12_LENDIAN, BLS12381_R_LENDIAN, E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES,
+        MOVE_ABORT_CODE_NOT_IMPLEMENTED,
     },
     store_element, structure_from_ty_arg,
 };
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{SafeNativeContext, SafeNativeError, SafeNativeResult};
 use ark_ec::Group;
-use move_core_types::gas_algebra::NumArgs;
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use num_traits::{One, Zero};
 use once_cell::sync::Lazy;
@@ -30,7 +28,6 @@ macro_rules! ark_constant_op_internal {
 }
 
 pub fn zero_internal(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut _args: VecDeque<Value>,
@@ -42,31 +39,31 @@ pub fn zero_internal(
             context,
             ark_bls12_381::Fr,
             zero,
-            gas_params.ark_bls12_381_fr_zero * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_FR_ZERO
         ),
         Some(Structure::BLS12381Fq12) => ark_constant_op_internal!(
             context,
             ark_bls12_381::Fq12,
             zero,
-            gas_params.ark_bls12_381_fq12_zero * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_FQ12_ZERO
         ),
         Some(Structure::BLS12381G1) => ark_constant_op_internal!(
             context,
             ark_bls12_381::G1Projective,
             zero,
-            gas_params.ark_bls12_381_g1_proj_infinity * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_G1_PROJ_INFINITY
         ),
         Some(Structure::BLS12381G2) => ark_constant_op_internal!(
             context,
             ark_bls12_381::G2Projective,
             zero,
-            gas_params.ark_bls12_381_g2_proj_infinity * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_G2_PROJ_INFINITY
         ),
         Some(Structure::BLS12381Gt) => ark_constant_op_internal!(
             context,
             ark_bls12_381::Fq12,
             one,
-            gas_params.ark_bls12_381_fq12_one * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_FQ12_ONE
         ),
         _ => Err(SafeNativeError::Abort {
             abort_code: MOVE_ABORT_CODE_NOT_IMPLEMENTED,
@@ -75,7 +72,6 @@ pub fn zero_internal(
 }
 
 pub fn one_internal(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut _args: VecDeque<Value>,
@@ -87,28 +83,28 @@ pub fn one_internal(
             context,
             ark_bls12_381::Fr,
             one,
-            gas_params.ark_bls12_381_fr_one * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_FR_ONE
         ),
         Some(Structure::BLS12381Fq12) => ark_constant_op_internal!(
             context,
             ark_bls12_381::Fq12,
             one,
-            gas_params.ark_bls12_381_fq12_one * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_FQ12_ONE
         ),
         Some(Structure::BLS12381G1) => ark_constant_op_internal!(
             context,
             ark_bls12_381::G1Projective,
             generator,
-            gas_params.ark_bls12_381_g1_proj_generator * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_G1_PROJ_GENERATOR
         ),
         Some(Structure::BLS12381G2) => ark_constant_op_internal!(
             context,
             ark_bls12_381::G2Projective,
             generator,
-            gas_params.ark_bls12_381_g2_proj_generator * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_G2_PROJ_GENERATOR
         ),
         Some(Structure::BLS12381Gt) => {
-            context.charge(gas_params.ark_bls12_381_fq12_clone * NumArgs::one())?;
+            context.charge(ALGEBRA_ARK_BLS12_381_FQ12_CLONE)?;
             let element = *Lazy::force(&BLS12381_GT_GENERATOR);
             let handle = store_element!(context, element)?;
             Ok(smallvec![Value::u64(handle as u64)])
@@ -120,7 +116,6 @@ pub fn one_internal(
 }
 
 pub fn order_internal(
-    _gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut _args: VecDeque<Value>,
diff --git a/aptos-move/framework/src/natives/cryptography/algebra/eq.rs b/aptos-move/framework/src/natives/cryptography/algebra/eq.rs
index 8f93b7f0e10b8..8e94fb0a2efb1 100644
--- a/aptos-move/framework/src/natives/cryptography/algebra/eq.rs
+++ b/aptos-move/framework/src/natives/cryptography/algebra/eq.rs
@@ -2,16 +2,16 @@
 
 use crate::{
     abort_unless_arithmetics_enabled_for_structure, abort_unless_feature_flag_enabled,
-    natives::{
-        cryptography::algebra::{
-            abort_invariant_violated, feature_flag_from_structure, gas::GasParameters,
-            AlgebraContext, Structure, MOVE_ABORT_CODE_NOT_IMPLEMENTED,
-        },
-        helpers::{SafeNativeContext, SafeNativeError, SafeNativeResult},
+    natives::cryptography::algebra::{
+        abort_invariant_violated, feature_flag_from_structure, AlgebraContext, Structure,
+        MOVE_ABORT_CODE_NOT_IMPLEMENTED,
     },
-    safe_borrow_element, safely_pop_arg, structure_from_ty_arg,
+    safe_borrow_element, structure_from_ty_arg,
+};
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_pop_arg, SafeNativeContext, SafeNativeError, SafeNativeResult,
 };
-use move_core_types::gas_algebra::NumArgs;
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use smallvec::{smallvec, SmallVec};
 use std::collections::VecDeque;
@@ -29,7 +29,6 @@ macro_rules! ark_eq_internal {
 }
 
 pub fn eq_internal(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -42,31 +41,31 @@ pub fn eq_internal(
             context,
             args,
             ark_bls12_381::Fr,
-            gas_params.ark_bls12_381_fr_eq * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_FR_EQ
         ),
         Some(Structure::BLS12381Fq12) => ark_eq_internal!(
             context,
             args,
             ark_bls12_381::Fq12,
-            gas_params.ark_bls12_381_fq12_eq * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_FQ12_EQ
         ),
         Some(Structure::BLS12381G1) => ark_eq_internal!(
             context,
             args,
             ark_bls12_381::G1Projective,
-            gas_params.ark_bls12_381_g1_proj_eq * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_G1_PROJ_EQ
         ),
         Some(Structure::BLS12381G2) => ark_eq_internal!(
             context,
             args,
             ark_bls12_381::G2Projective,
-            gas_params.ark_bls12_381_g2_proj_eq * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_G2_PROJ_EQ
         ),
         Some(Structure::BLS12381Gt) => ark_eq_internal!(
             context,
             args,
             ark_bls12_381::Fq12,
-            gas_params.ark_bls12_381_fq12_eq * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_FQ12_EQ
         ),
         _ => Err(SafeNativeError::Abort {
             abort_code: MOVE_ABORT_CODE_NOT_IMPLEMENTED,
diff --git a/aptos-move/framework/src/natives/cryptography/algebra/gas.rs b/aptos-move/framework/src/natives/cryptography/algebra/gas.rs
deleted file mode 100644
index dabc1ac8c43a8..0000000000000
--- a/aptos-move/framework/src/natives/cryptography/algebra/gas.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-// Copyright © Aptos Foundation
-
-// Copyright (c) Aptos
-// SPDX-License-Identifier: Apache-2.0
-
-use move_core_types::gas_algebra::InternalGasPerArg;
-
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub ark_bls12_381_fr_add: InternalGasPerArg,
-    pub ark_bls12_381_fr_deser: InternalGasPerArg,
-    pub ark_bls12_381_fr_div: InternalGasPerArg,
-    pub ark_bls12_381_fr_eq: InternalGasPerArg,
-    pub ark_bls12_381_fr_from_u64: InternalGasPerArg,
-    pub ark_bls12_381_fr_inv: InternalGasPerArg,
-    pub ark_bls12_381_fr_mul: InternalGasPerArg,
-    pub ark_bls12_381_fr_neg: InternalGasPerArg,
-    pub ark_bls12_381_fr_one: InternalGasPerArg,
-    pub ark_bls12_381_fr_serialize: InternalGasPerArg,
-    pub ark_bls12_381_fr_square: InternalGasPerArg,
-    pub ark_bls12_381_fr_sub: InternalGasPerArg,
-    pub ark_bls12_381_fr_zero: InternalGasPerArg,
-    pub ark_bls12_381_fq12_add: InternalGasPerArg,
-    pub ark_bls12_381_fq12_clone: InternalGasPerArg,
-    pub ark_bls12_381_fq12_deser: InternalGasPerArg,
-    pub ark_bls12_381_fq12_div: InternalGasPerArg,
-    pub ark_bls12_381_fq12_eq: InternalGasPerArg,
-    pub ark_bls12_381_fq12_from_u64: InternalGasPerArg,
-    pub ark_bls12_381_fq12_inv: InternalGasPerArg,
-    pub ark_bls12_381_fq12_mul: InternalGasPerArg,
-    pub ark_bls12_381_fq12_neg: InternalGasPerArg,
-    pub ark_bls12_381_fq12_one: InternalGasPerArg,
-    pub ark_bls12_381_fq12_pow_u256: InternalGasPerArg,
-    pub ark_bls12_381_fq12_serialize: InternalGasPerArg,
-    pub ark_bls12_381_fq12_square: InternalGasPerArg,
-    pub ark_bls12_381_fq12_sub: InternalGasPerArg,
-    pub ark_bls12_381_fq12_zero: InternalGasPerArg,
-    pub ark_bls12_381_g1_affine_deser_comp: InternalGasPerArg,
-    pub ark_bls12_381_g1_affine_deser_uncomp: InternalGasPerArg,
-    pub ark_bls12_381_g1_affine_serialize_comp: InternalGasPerArg,
-    pub ark_bls12_381_g1_affine_serialize_uncomp: InternalGasPerArg,
-    pub ark_bls12_381_g1_proj_add: InternalGasPerArg,
-    pub ark_bls12_381_g1_proj_double: InternalGasPerArg,
-    pub ark_bls12_381_g1_proj_eq: InternalGasPerArg,
-    pub ark_bls12_381_g1_proj_generator: InternalGasPerArg,
-    pub ark_bls12_381_g1_proj_infinity: InternalGasPerArg,
-    pub ark_bls12_381_g1_proj_neg: InternalGasPerArg,
-    pub ark_bls12_381_g1_proj_scalar_mul: InternalGasPerArg,
-    pub ark_bls12_381_g1_proj_sub: InternalGasPerArg,
-    pub ark_bls12_381_g1_proj_to_affine: InternalGasPerArg,
-    pub ark_bls12_381_g2_affine_deser_comp: InternalGasPerArg,
-    pub ark_bls12_381_g2_affine_deser_uncomp: InternalGasPerArg,
-    pub ark_bls12_381_g2_affine_serialize_comp: InternalGasPerArg,
-    pub ark_bls12_381_g2_affine_serialize_uncomp: InternalGasPerArg,
-    pub ark_bls12_381_g2_proj_add: InternalGasPerArg,
-    pub ark_bls12_381_g2_proj_double: InternalGasPerArg,
-    pub ark_bls12_381_g2_proj_eq: InternalGasPerArg,
-    pub ark_bls12_381_g2_proj_generator: InternalGasPerArg,
-    pub ark_bls12_381_g2_proj_infinity: InternalGasPerArg,
-    pub ark_bls12_381_g2_proj_neg: InternalGasPerArg,
-    pub ark_bls12_381_g2_proj_scalar_mul: InternalGasPerArg,
-    pub ark_bls12_381_g2_proj_sub: InternalGasPerArg,
-    pub ark_bls12_381_g2_proj_to_affine: InternalGasPerArg,
-    pub ark_bls12_381_pairing: InternalGasPerArg,
-    pub ark_bls12_381_multi_pairing_base: InternalGasPerArg,
-    pub ark_bls12_381_multi_pairing_per_pair: InternalGasPerArg,
-    pub ark_h2c_bls12381g1_xmd_sha256_sswu_base: InternalGasPerArg,
-    pub ark_h2c_bls12381g1_xmd_sha256_sswu_per_msg_byte: InternalGasPerArg,
-    pub ark_h2c_bls12381g2_xmd_sha256_sswu_base: InternalGasPerArg,
-    pub ark_h2c_bls12381g2_xmd_sha256_sswu_per_msg_byte: InternalGasPerArg,
-}
-
-pub struct HashToGasParameters {
-    pub algebra: GasParameters,
-    pub sha2: aptos_move_stdlib::natives::hash::Sha2_256GasParameters,
-}
diff --git a/aptos-move/framework/src/natives/cryptography/algebra/hash_to_structure.rs b/aptos-move/framework/src/natives/cryptography/algebra/hash_to_structure.rs
index f08147b5af8f1..3e19ce97af711 100644
--- a/aptos-move/framework/src/natives/cryptography/algebra/hash_to_structure.rs
+++ b/aptos-move/framework/src/natives/cryptography/algebra/hash_to_structure.rs
@@ -2,20 +2,20 @@
 
 use crate::{
     abort_unless_feature_flag_enabled,
-    natives::{
-        cryptography::algebra::{
-            gas::HashToGasParameters, AlgebraContext, HashToStructureSuite, Structure,
-            E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES, MOVE_ABORT_CODE_NOT_IMPLEMENTED,
-        },
-        helpers::{SafeNativeContext, SafeNativeError, SafeNativeResult},
+    natives::cryptography::algebra::{
+        AlgebraContext, HashToStructureSuite, Structure, E_TOO_MUCH_MEMORY_USED,
+        MEMORY_LIMIT_IN_BYTES, MOVE_ABORT_CODE_NOT_IMPLEMENTED,
     },
-    safely_pop_arg, store_element, structure_from_ty_arg,
+    store_element, structure_from_ty_arg,
+};
+use aptos_gas_schedule::gas_params::natives::{aptos_framework::*, move_stdlib::*};
+use aptos_native_interface::{
+    safely_pop_arg, SafeNativeContext, SafeNativeError, SafeNativeResult,
 };
 use aptos_types::on_chain_config::FeatureFlag;
 use ark_ec::hashing::HashToCurve;
-use move_core_types::gas_algebra::{
-    InternalGas, InternalGasPerArg, InternalGasPerByte, NumArgs, NumBytes,
-};
+use either::Either;
+use move_core_types::gas_algebra::{InternalGas, NumBytes};
 use move_vm_types::{
     loaded_data::runtime_types::Type,
     values::{Value, VectorRef},
@@ -50,30 +50,34 @@ macro_rules! suite_from_ty_arg {
     }};
 }
 
-fn hash_to_bls12381gx_cost(
-    dst_len: usize,
-    msg_len: usize,
-    dst_shortening_base: InternalGas,
-    dst_shortening_per_byte: InternalGasPerByte,
-    mapping_base: InternalGasPerArg,
-    mapping_per_byte: InternalGasPerArg,
-) -> InternalGas {
-    // DST shortening as defined in https://www.ietf.org/archive/id/draft-irtf-cfrg-hash-to-curve-16.html#name-using-dsts-longer-than-255-.
-    let dst_shortening_cost = if dst_len <= 255 {
-        InternalGas::zero()
-    } else {
-        dst_shortening_base + dst_shortening_per_byte * NumBytes::from((17 + dst_len) as u64)
-    };
+macro_rules! hash_to_bls12381gx_cost {
+    (
+        $dst_len: expr,
+        $msg_len: expr,
+        $dst_shortening_base: expr,
+        $dst_shortening_per_byte: expr,
+        $mapping_base: expr,
+        $mapping_per_byte: expr
+        $(,)?
+    ) => {{
+        let dst_len: usize = $dst_len;
+
+        // DST shortening as defined in https://www.ietf.org/archive/id/draft-irtf-cfrg-hash-to-curve-16.html#name-using-dsts-longer-than-255-.
+        let dst_shortening_cost = if dst_len <= 255 {
+            Either::Left(InternalGas::zero())
+        } else {
+            Either::Right($dst_shortening_base + $dst_shortening_per_byte * NumBytes::from((17 + dst_len) as u64))
+        };
 
-    // Mapping cost. The gas formula is simplified by assuming the DST length is fixed at 256.
-    let mapping_cost =
-        mapping_base * NumArgs::one() + mapping_per_byte * NumArgs::from(msg_len as u64);
+        // Mapping cost. The gas formula is simplified by assuming the DST length is fixed at 256.
+        let mapping_cost =
+            $mapping_base + $mapping_per_byte * NumBytes::from($msg_len as u64);
 
-    dst_shortening_cost + mapping_cost
+        mapping_cost + dst_shortening_cost
+    }};
 }
 
 pub fn hash_to_internal(
-    gas_params: &HashToGasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -90,15 +94,13 @@ pub fn hash_to_internal(
     let dst = bytes_ref.as_slice();
     match (structure_opt, suite_opt) {
         (Some(Structure::BLS12381G1), Some(HashToStructureSuite::Bls12381g1XmdSha256SswuRo)) => {
-            context.charge(hash_to_bls12381gx_cost(
+            context.charge(hash_to_bls12381gx_cost!(
                 dst.len(),
                 msg.len(),
-                gas_params.sha2.base,
-                gas_params.sha2.per_byte,
-                gas_params.algebra.ark_h2c_bls12381g1_xmd_sha256_sswu_base,
-                gas_params
-                    .algebra
-                    .ark_h2c_bls12381g1_xmd_sha256_sswu_per_msg_byte,
+                HASH_SHA2_256_BASE,
+                HASH_SHA2_256_PER_BYTE,
+                ALGEBRA_ARK_H2C_BLS12381G1_XMD_SHA256_SSWU_BASE,
+                ALGEBRA_ARK_H2C_BLS12381G1_XMD_SHA256_SSWU_PER_MSG_BYTE,
             ))?;
             let mapper = ark_ec::hashing::map_to_curve_hasher::MapToCurveBasedHasher::<
                 ark_ec::models::short_weierstrass::Projective<ark_bls12_381::g1::Config>,
@@ -111,15 +113,13 @@ pub fn hash_to_internal(
             Ok(smallvec![Value::u64(new_handle as u64)])
         },
         (Some(Structure::BLS12381G2), Some(HashToStructureSuite::Bls12381g2XmdSha256SswuRo)) => {
-            context.charge(hash_to_bls12381gx_cost(
+            context.charge(hash_to_bls12381gx_cost!(
                 dst.len(),
                 msg.len(),
-                gas_params.sha2.base,
-                gas_params.sha2.per_byte,
-                gas_params.algebra.ark_h2c_bls12381g2_xmd_sha256_sswu_base,
-                gas_params
-                    .algebra
-                    .ark_h2c_bls12381g2_xmd_sha256_sswu_per_msg_byte,
+                HASH_SHA2_256_BASE,
+                HASH_SHA2_256_PER_BYTE,
+                ALGEBRA_ARK_H2C_BLS12381G2_XMD_SHA256_SSWU_BASE,
+                ALGEBRA_ARK_H2C_BLS12381G2_XMD_SHA256_SSWU_PER_MSG_BYTE,
             ))?;
             let mapper = ark_ec::hashing::map_to_curve_hasher::MapToCurveBasedHasher::<
                 ark_ec::models::short_weierstrass::Projective<ark_bls12_381::g2::Config>,
diff --git a/aptos-move/framework/src/natives/cryptography/algebra/mod.rs b/aptos-move/framework/src/natives/cryptography/algebra/mod.rs
index 0fec37b5cd40d..fd100020dd5e2 100644
--- a/aptos-move/framework/src/natives/cryptography/algebra/mod.rs
+++ b/aptos-move/framework/src/natives/cryptography/algebra/mod.rs
@@ -5,26 +5,21 @@
 
 #[cfg(feature = "testing")]
 use crate::natives::cryptography::algebra::rand::rand_insecure_internal;
-#[cfg(feature = "testing")]
-use crate::natives::helpers::make_test_only_native_from_func;
-use crate::natives::{
-    cryptography::algebra::{
-        arithmetics::{
-            add::add_internal, double::double_internal, mul::mul_internal, neg::neg_internal,
-            sqr::sqr_internal, sub::sub_internal,
-        },
-        casting::{downcast_internal, upcast_internal},
-        constants::{one_internal, order_internal, zero_internal},
-        eq::eq_internal,
-        gas::HashToGasParameters,
-        hash_to_structure::hash_to_internal,
-        new::from_u64_internal,
-        pairing::{multi_pairing_internal, pairing_internal},
-        serialization::{deserialize_internal, serialize_internal},
+use crate::natives::cryptography::algebra::{
+    arithmetics::{
+        add::add_internal, double::double_internal, mul::mul_internal, neg::neg_internal,
+        sqr::sqr_internal, sub::sub_internal,
     },
-    helpers::make_safe_native,
+    casting::{downcast_internal, upcast_internal},
+    constants::{one_internal, order_internal, zero_internal},
+    eq::eq_internal,
+    hash_to_structure::hash_to_internal,
+    new::from_u64_internal,
+    pairing::{multi_pairing_internal, pairing_internal},
+    serialization::{deserialize_internal, serialize_internal},
 };
-use aptos_types::on_chain_config::{FeatureFlag, Features, TimedFeatures};
+use aptos_native_interface::{RawSafeNative, SafeNativeBuilder};
+use aptos_types::on_chain_config::FeatureFlag;
 use arithmetics::{
     div::div_internal,
     inv::inv_internal,
@@ -36,13 +31,12 @@ use move_binary_format::errors::PartialVMError;
 use move_core_types::{language_storage::TypeTag, vm_status::StatusCode};
 use move_vm_runtime::native_functions::NativeFunction;
 use once_cell::sync::Lazy;
-use std::{any::Any, hash::Hash, rc::Rc, sync::Arc};
+use std::{any::Any, hash::Hash, rc::Rc};
 
 pub mod arithmetics;
 pub mod casting;
 pub mod constants;
 pub mod eq;
-pub mod gas;
 pub mod hash_to_structure;
 pub mod new;
 pub mod pairing;
@@ -266,219 +260,44 @@ static BLS12381_Q12_LENDIAN: Lazy<Vec<u8>> = Lazy::new(|| {
 });
 
 pub fn make_all(
-    move_gas_params: aptos_move_stdlib::natives::GasParameters,
-    gas_params: crate::natives::cryptography::algebra::gas::GasParameters,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
     let mut natives = vec![];
 
-    // Always-on natives.
-    natives.append(&mut vec![
+    natives.extend([
         (
             "deserialize_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                deserialize_internal,
-            ),
-        ),
-        (
-            "downcast_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                downcast_internal,
-            ),
-        ),
-        (
-            "eq_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                eq_internal,
-            ),
-        ),
-        (
-            "add_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                add_internal,
-            ),
-        ),
-        (
-            "div_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                div_internal,
-            ),
-        ),
-        (
-            "inv_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                inv_internal,
-            ),
-        ),
-        (
-            "mul_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                mul_internal,
-            ),
-        ),
-        (
-            "neg_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                neg_internal,
-            ),
-        ),
-        (
-            "one_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                one_internal,
-            ),
-        ),
-        (
-            "sqr_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                sqr_internal,
-            ),
-        ),
-        (
-            "sub_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                sub_internal,
-            ),
-        ),
-        (
-            "zero_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                zero_internal,
-            ),
-        ),
-        (
-            "from_u64_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                from_u64_internal,
-            ),
-        ),
-        (
-            "double_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                double_internal,
-            ),
-        ),
-        (
-            "multi_scalar_mul_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                multi_scalar_mul_internal,
-            ),
-        ),
-        (
-            "order_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                order_internal,
-            ),
-        ),
-        (
-            "scalar_mul_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                scalar_mul_internal,
-            ),
-        ),
-        (
-            "hash_to_internal",
-            make_safe_native(
-                HashToGasParameters {
-                    algebra: gas_params.clone(),
-                    sha2: move_gas_params.hash.sha2_256,
-                },
-                timed_features.clone(),
-                features.clone(),
-                hash_to_internal,
-            ),
-        ),
-        (
-            "multi_pairing_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                multi_pairing_internal,
-            ),
-        ),
-        (
-            "pairing_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                pairing_internal,
-            ),
-        ),
-        (
-            "serialize_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                serialize_internal,
-            ),
-        ),
-        (
-            "upcast_internal",
-            make_safe_native(gas_params, timed_features, features, upcast_internal),
+            deserialize_internal as RawSafeNative,
         ),
+        ("downcast_internal", downcast_internal),
+        ("eq_internal", eq_internal),
+        ("add_internal", add_internal),
+        ("div_internal", div_internal),
+        ("inv_internal", inv_internal),
+        ("mul_internal", mul_internal),
+        ("neg_internal", neg_internal),
+        ("one_internal", one_internal),
+        ("sqr_internal", sqr_internal),
+        ("sub_internal", sub_internal),
+        ("zero_internal", zero_internal),
+        ("from_u64_internal", from_u64_internal),
+        ("double_internal", double_internal),
+        ("multi_scalar_mul_internal", multi_scalar_mul_internal),
+        ("order_internal", order_internal),
+        ("scalar_mul_internal", scalar_mul_internal),
+        ("hash_to_internal", hash_to_internal),
+        ("multi_pairing_internal", multi_pairing_internal),
+        ("pairing_internal", pairing_internal),
+        ("serialize_internal", serialize_internal),
+        ("upcast_internal", upcast_internal),
     ]);
 
     // Test-only natives.
     #[cfg(feature = "testing")]
-    natives.append(&mut vec![(
+    natives.extend([(
         "rand_insecure_internal",
-        make_test_only_native_from_func(rand_insecure_internal),
+        rand_insecure_internal as RawSafeNative,
     )]);
 
-    crate::natives::helpers::make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/src/natives/cryptography/algebra/new.rs b/aptos-move/framework/src/natives/cryptography/algebra/new.rs
index 153f9e850dd26..7584cf14eaebb 100644
--- a/aptos-move/framework/src/natives/cryptography/algebra/new.rs
+++ b/aptos-move/framework/src/natives/cryptography/algebra/new.rs
@@ -2,16 +2,16 @@
 
 use crate::{
     abort_unless_arithmetics_enabled_for_structure, abort_unless_feature_flag_enabled,
-    natives::{
-        cryptography::algebra::{
-            feature_flag_from_structure, gas::GasParameters, AlgebraContext, Structure,
-            E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES, MOVE_ABORT_CODE_NOT_IMPLEMENTED,
-        },
-        helpers::{SafeNativeContext, SafeNativeError, SafeNativeResult},
+    natives::cryptography::algebra::{
+        feature_flag_from_structure, AlgebraContext, Structure, E_TOO_MUCH_MEMORY_USED,
+        MEMORY_LIMIT_IN_BYTES, MOVE_ABORT_CODE_NOT_IMPLEMENTED,
     },
-    safely_pop_arg, store_element, structure_from_ty_arg,
+    store_element, structure_from_ty_arg,
+};
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_pop_arg, SafeNativeContext, SafeNativeError, SafeNativeResult,
 };
-use move_core_types::gas_algebra::NumArgs;
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use smallvec::{smallvec, SmallVec};
 use std::{collections::VecDeque, rc::Rc};
@@ -27,7 +27,6 @@ macro_rules! from_u64_internal {
 }
 
 pub fn from_u64_internal(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -40,13 +39,13 @@ pub fn from_u64_internal(
             context,
             args,
             ark_bls12_381::Fr,
-            gas_params.ark_bls12_381_fr_from_u64 * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_FR_FROM_U64
         ),
         Some(Structure::BLS12381Fq12) => from_u64_internal!(
             context,
             args,
             ark_bls12_381::Fq12,
-            gas_params.ark_bls12_381_fq12_from_u64 * NumArgs::one()
+            ALGEBRA_ARK_BLS12_381_FQ12_FROM_U64
         ),
         _ => Err(SafeNativeError::Abort {
             abort_code: MOVE_ABORT_CODE_NOT_IMPLEMENTED,
diff --git a/aptos-move/framework/src/natives/cryptography/algebra/pairing.rs b/aptos-move/framework/src/natives/cryptography/algebra/pairing.rs
index 1df6b339b8a02..5af6f56addf38 100644
--- a/aptos-move/framework/src/natives/cryptography/algebra/pairing.rs
+++ b/aptos-move/framework/src/natives/cryptography/algebra/pairing.rs
@@ -2,15 +2,17 @@
 
 use crate::{
     abort_unless_feature_flag_enabled,
-    natives::{
-        cryptography::algebra::{
-            abort_invariant_violated, gas::GasParameters, AlgebraContext, Structure,
-            E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES,
-            MOVE_ABORT_CODE_INPUT_VECTOR_SIZES_NOT_MATCHING, MOVE_ABORT_CODE_NOT_IMPLEMENTED,
-        },
-        helpers::{SafeNativeContext, SafeNativeError, SafeNativeResult},
+    natives::cryptography::algebra::{
+        abort_invariant_violated, AlgebraContext, Structure, E_TOO_MUCH_MEMORY_USED,
+        MEMORY_LIMIT_IN_BYTES, MOVE_ABORT_CODE_INPUT_VECTOR_SIZES_NOT_MATCHING,
+        MOVE_ABORT_CODE_NOT_IMPLEMENTED,
     },
-    safe_borrow_element, safely_pop_arg, store_element, structure_from_ty_arg,
+    safe_borrow_element, store_element, structure_from_ty_arg,
+};
+use aptos_gas_algebra::{Arg, GasExpression};
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_pop_arg, SafeNativeContext, SafeNativeError, SafeNativeResult,
 };
 use aptos_types::on_chain_config::FeatureFlag;
 use ark_ec::{pairing::Pairing, CurveGroup};
@@ -40,7 +42,6 @@ macro_rules! abort_unless_pairing_enabled {
 }
 
 pub fn multi_pairing_internal(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -62,7 +63,8 @@ pub fn multi_pairing_internal(
             }
 
             context.charge(
-                gas_params.ark_bls12_381_g1_proj_to_affine * NumArgs::from(num_entries as u64),
+                ALGEBRA_ARK_BLS12_381_G1_PROJ_TO_AFFINE.per::<Arg>()
+                    * NumArgs::from(num_entries as u64),
             )?;
             let mut g1_elements_affine = Vec::with_capacity(num_entries);
             for handle in g1_element_handles {
@@ -77,7 +79,8 @@ pub fn multi_pairing_internal(
             }
 
             context.charge(
-                gas_params.ark_bls12_381_g2_proj_to_affine * NumArgs::from(num_entries as u64),
+                ALGEBRA_ARK_BLS12_381_G2_PROJ_TO_AFFINE.per::<Arg>()
+                    * NumArgs::from(num_entries as u64),
             )?;
             let mut g2_elements_affine = Vec::with_capacity(num_entries);
             for handle in g2_element_handles {
@@ -92,8 +95,8 @@ pub fn multi_pairing_internal(
             }
 
             context.charge(
-                gas_params.ark_bls12_381_multi_pairing_base * NumArgs::one()
-                    + gas_params.ark_bls12_381_multi_pairing_per_pair
+                ALGEBRA_ARK_BLS12_381_MULTI_PAIRING_BASE
+                    + ALGEBRA_ARK_BLS12_381_MULTI_PAIRING_PER_PAIR
                         * NumArgs::from(num_entries as u64),
             )?;
             let new_element =
@@ -108,7 +111,6 @@ pub fn multi_pairing_internal(
 }
 
 pub fn pairing_internal(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -129,7 +131,7 @@ pub fn pairing_internal(
                 g1_element_ptr,
                 g1_element
             );
-            context.charge(gas_params.ark_bls12_381_g1_proj_to_affine * NumArgs::one())?;
+            context.charge(ALGEBRA_ARK_BLS12_381_G1_PROJ_TO_AFFINE)?;
             let g1_element_affine = g1_element.into_affine();
             safe_borrow_element!(
                 context,
@@ -138,9 +140,9 @@ pub fn pairing_internal(
                 g2_element_ptr,
                 g2_element
             );
-            context.charge(gas_params.ark_bls12_381_g2_proj_to_affine * NumArgs::one())?;
+            context.charge(ALGEBRA_ARK_BLS12_381_G2_PROJ_TO_AFFINE)?;
             let g2_element_affine = g2_element.into_affine();
-            context.charge(gas_params.ark_bls12_381_pairing * NumArgs::one())?;
+            context.charge(ALGEBRA_ARK_BLS12_381_PAIRING)?;
             let new_element =
                 ark_bls12_381::Bls12_381::pairing(g1_element_affine, g2_element_affine).0;
             let new_handle = store_element!(context, new_element)?;
diff --git a/aptos-move/framework/src/natives/cryptography/algebra/rand.rs b/aptos-move/framework/src/natives/cryptography/algebra/rand.rs
index b1ce0df337bd0..52489a4a4123a 100644
--- a/aptos-move/framework/src/natives/cryptography/algebra/rand.rs
+++ b/aptos-move/framework/src/natives/cryptography/algebra/rand.rs
@@ -8,19 +8,15 @@ use crate::{
     },
     structure_from_ty_arg,
 };
+use aptos_native_interface::{SafeNativeContext, SafeNativeError, SafeNativeResult};
 #[cfg(feature = "testing")]
 use ark_ff::Field;
 #[cfg(feature = "testing")]
 use ark_std::{test_rng, UniformRand};
-use move_binary_format::errors::PartialVMResult;
-use move_core_types::gas_algebra::InternalGas;
-use move_vm_runtime::native_functions::NativeContext;
 #[cfg(feature = "testing")]
-use move_vm_types::{
-    loaded_data::runtime_types::Type, natives::function::NativeResult, values::Value,
-};
+use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 #[cfg(feature = "testing")]
-use smallvec::smallvec;
+use smallvec::{smallvec, SmallVec};
 #[cfg(feature = "testing")]
 use std::{collections::VecDeque, rc::Rc};
 
@@ -45,20 +41,18 @@ macro_rules! ark_rand_internal {
     ($context:expr, $typ:ty) => {{
         let element = <$typ>::rand(&mut test_rng());
         match store_element!($context, element) {
-            Ok(new_handle) => Ok(NativeResult::ok(InternalGas::zero(), smallvec![
-                Value::u64(new_handle as u64)
-            ])),
-            Err(abort_code) => Ok(NativeResult::err(InternalGas::zero(), abort_code)),
+            Ok(new_handle) => Ok(smallvec![Value::u64(new_handle as u64)]),
+            Err(abort_code) => Err(SafeNativeError::Abort { abort_code }),
         }
     }};
 }
 
 #[cfg(feature = "testing")]
 pub fn rand_insecure_internal(
-    context: &mut NativeContext,
+    context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut _args: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
     assert_eq!(1, ty_args.len());
     let structure_opt = structure_from_ty_arg!(context, &ty_args[0]);
     match structure_opt {
@@ -79,10 +73,8 @@ pub fn rand_insecure_internal(
             let k_bigint: ark_ff::BigInteger256 = k.into();
             let element = BLS12381_GT_GENERATOR.pow(k_bigint);
             match store_element!(context, element) {
-                Ok(handle) => Ok(NativeResult::ok(InternalGas::zero(), smallvec![
-                    Value::u64(handle as u64)
-                ])),
-                Err(abort_code) => Ok(NativeResult::err(InternalGas::zero(), abort_code)),
+                Ok(handle) => Ok(smallvec![Value::u64(handle as u64)]),
+                Err(abort_code) => Err(SafeNativeError::Abort { abort_code }),
             }
         },
         _ => unreachable!(),
diff --git a/aptos-move/framework/src/natives/cryptography/algebra/serialization.rs b/aptos-move/framework/src/natives/cryptography/algebra/serialization.rs
index 7b6870009883a..aff3819078bb8 100644
--- a/aptos-move/framework/src/natives/cryptography/algebra/serialization.rs
+++ b/aptos-move/framework/src/natives/cryptography/algebra/serialization.rs
@@ -2,21 +2,21 @@
 
 use crate::{
     abort_unless_feature_flag_enabled,
-    natives::{
-        cryptography::algebra::{
-            abort_invariant_violated, gas::GasParameters, AlgebraContext, SerializationFormat,
-            Structure, BLS12381_R_SCALAR, E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES,
-            MOVE_ABORT_CODE_NOT_IMPLEMENTED,
-        },
-        helpers::{SafeNativeContext, SafeNativeError, SafeNativeResult},
+    natives::cryptography::algebra::{
+        abort_invariant_violated, AlgebraContext, SerializationFormat, Structure,
+        BLS12381_R_SCALAR, E_TOO_MUCH_MEMORY_USED, MEMORY_LIMIT_IN_BYTES,
+        MOVE_ABORT_CODE_NOT_IMPLEMENTED,
     },
-    safe_borrow_element, safely_pop_arg, store_element, structure_from_ty_arg,
+    safe_borrow_element, store_element, structure_from_ty_arg,
+};
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_pop_arg, SafeNativeContext, SafeNativeError, SafeNativeResult,
 };
 use aptos_types::on_chain_config::FeatureFlag;
 use ark_ec::CurveGroup;
 use ark_ff::Field;
 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
-use move_core_types::gas_algebra::NumArgs;
 use move_vm_types::{
     loaded_data::runtime_types::Type,
     values::{Value, VectorRef},
@@ -56,7 +56,6 @@ macro_rules! format_from_ty_arg {
 }
 
 pub fn serialize_internal(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -70,7 +69,7 @@ pub fn serialize_internal(
             let handle = safely_pop_arg!(args, u64) as usize;
             safe_borrow_element!(context, handle, ark_bls12_381::Fr, element_ptr, element);
             let mut buf = vec![];
-            context.charge(gas_params.ark_bls12_381_fr_serialize * NumArgs::one())?;
+            context.charge(ALGEBRA_ARK_BLS12_381_FR_SERIALIZE)?;
             element
                 .serialize_uncompressed(&mut buf)
                 .map_err(|_e| abort_invariant_violated())?;
@@ -80,7 +79,7 @@ pub fn serialize_internal(
             let handle = safely_pop_arg!(args, u64) as usize;
             safe_borrow_element!(context, handle, ark_bls12_381::Fr, element_ptr, element);
             let mut buf = vec![];
-            context.charge(gas_params.ark_bls12_381_fr_serialize * NumArgs::one())?;
+            context.charge(ALGEBRA_ARK_BLS12_381_FR_SERIALIZE)?;
             element
                 .serialize_uncompressed(&mut buf)
                 .map_err(|_e| abort_invariant_violated())?;
@@ -91,7 +90,7 @@ pub fn serialize_internal(
             let handle = safely_pop_arg!(args, u64) as usize;
             safe_borrow_element!(context, handle, ark_bls12_381::Fq12, element_ptr, element);
             let mut buf = vec![];
-            context.charge(gas_params.ark_bls12_381_fq12_serialize * NumArgs::one())?;
+            context.charge(ALGEBRA_ARK_BLS12_381_FQ12_SERIALIZE)?;
             element
                 .serialize_uncompressed(&mut buf)
                 .map_err(|_e| abort_invariant_violated())?;
@@ -108,7 +107,7 @@ pub fn serialize_internal(
             );
             let element_affine = element.into_affine();
             let mut buf = Vec::new();
-            context.charge(gas_params.ark_bls12_381_g1_affine_serialize_uncomp * NumArgs::one())?;
+            context.charge(ALGEBRA_ARK_BLS12_381_G1_AFFINE_SERIALIZE_UNCOMP)?;
             element_affine
                 .serialize_uncompressed(&mut buf)
                 .map_err(|_e| abort_invariant_violated())?;
@@ -125,7 +124,7 @@ pub fn serialize_internal(
             );
             let element_affine = element.into_affine();
             let mut buf = Vec::new();
-            context.charge(gas_params.ark_bls12_381_g1_affine_serialize_comp * NumArgs::one())?;
+            context.charge(ALGEBRA_ARK_BLS12_381_G1_AFFINE_SERIALIZE_COMP)?;
             element_affine
                 .serialize_compressed(&mut buf)
                 .map_err(|_e| abort_invariant_violated())?;
@@ -142,7 +141,7 @@ pub fn serialize_internal(
             );
             let element_affine = element.into_affine();
             let mut buf = Vec::new();
-            context.charge(gas_params.ark_bls12_381_g2_affine_serialize_uncomp * NumArgs::one())?;
+            context.charge(ALGEBRA_ARK_BLS12_381_G2_AFFINE_SERIALIZE_UNCOMP)?;
             element_affine
                 .serialize_uncompressed(&mut buf)
                 .map_err(|_e| abort_invariant_violated())?;
@@ -159,7 +158,7 @@ pub fn serialize_internal(
             );
             let element_affine = element.into_affine();
             let mut buf = Vec::new();
-            context.charge(gas_params.ark_bls12_381_g2_affine_serialize_comp * NumArgs::one())?;
+            context.charge(ALGEBRA_ARK_BLS12_381_G2_AFFINE_SERIALIZE_COMP)?;
             element_affine
                 .serialize_compressed(&mut buf)
                 .map_err(|_e| abort_invariant_violated())?;
@@ -169,7 +168,7 @@ pub fn serialize_internal(
             let handle = safely_pop_arg!(args, u64) as usize;
             safe_borrow_element!(context, handle, ark_bls12_381::Fq12, element_ptr, element);
             let mut buf = vec![];
-            context.charge(gas_params.ark_bls12_381_fq12_serialize * NumArgs::one())?;
+            context.charge(ALGEBRA_ARK_BLS12_381_FQ12_SERIALIZE)?;
             element
                 .serialize_uncompressed(&mut buf)
                 .map_err(|_e| abort_invariant_violated())?;
@@ -222,7 +221,6 @@ macro_rules! ark_ec_point_deserialize_internal {
 }
 
 pub fn deserialize_internal(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -247,7 +245,7 @@ pub fn deserialize_internal(
                 bytes,
                 ark_bls12_381::Fr,
                 deserialize_uncompressed,
-                gas_params.ark_bls12_381_fr_deser * NumArgs::one()
+                ALGEBRA_ARK_BLS12_381_FR_DESER
             )
         },
         (Some(Structure::BLS12381Fr), Some(SerializationFormat::BLS12381FrMsb)) => {
@@ -263,7 +261,7 @@ pub fn deserialize_internal(
                 bytes,
                 ark_bls12_381::Fr,
                 deserialize_uncompressed,
-                gas_params.ark_bls12_381_fr_deser * NumArgs::one()
+                ALGEBRA_ARK_BLS12_381_FR_DESER
             )
         },
         (Some(Structure::BLS12381Fq12), Some(SerializationFormat::BLS12381Fq12LscLsb)) => {
@@ -276,7 +274,7 @@ pub fn deserialize_internal(
                 bytes,
                 ark_bls12_381::Fq12,
                 deserialize_uncompressed,
-                gas_params.ark_bls12_381_fq12_deser * NumArgs::one()
+                ALGEBRA_ARK_BLS12_381_FQ12_DESER
             )
         },
         (Some(Structure::BLS12381G1), Some(SerializationFormat::BLS12381G1Uncompressed)) => {
@@ -289,7 +287,7 @@ pub fn deserialize_internal(
                 bytes,
                 ark_bls12_381::G1Affine,
                 deserialize_uncompressed,
-                gas_params.ark_bls12_381_g1_affine_deser_uncomp * NumArgs::one()
+                ALGEBRA_ARK_BLS12_381_G1_AFFINE_DESER_UNCOMP
             )
         },
         (Some(Structure::BLS12381G1), Some(SerializationFormat::BLS12381G1Compressed)) => {
@@ -302,7 +300,7 @@ pub fn deserialize_internal(
                 bytes,
                 ark_bls12_381::G1Affine,
                 deserialize_compressed,
-                gas_params.ark_bls12_381_g1_affine_deser_comp * NumArgs::one()
+                ALGEBRA_ARK_BLS12_381_G1_AFFINE_DESER_COMP
             )
         },
         (Some(Structure::BLS12381G2), Some(SerializationFormat::BLS12381G2Uncompressed)) => {
@@ -315,7 +313,7 @@ pub fn deserialize_internal(
                 bytes,
                 ark_bls12_381::G2Affine,
                 deserialize_uncompressed,
-                gas_params.ark_bls12_381_g2_affine_deser_uncomp * NumArgs::one()
+                ALGEBRA_ARK_BLS12_381_G2_AFFINE_DESER_UNCOMP
             )
         },
         (Some(Structure::BLS12381G2), Some(SerializationFormat::BLS12381G2Compressed)) => {
@@ -328,7 +326,7 @@ pub fn deserialize_internal(
                 bytes,
                 ark_bls12_381::G2Affine,
                 deserialize_compressed,
-                gas_params.ark_bls12_381_g2_affine_deser_comp * NumArgs::one()
+                ALGEBRA_ARK_BLS12_381_G2_AFFINE_DESER_COMP
             )
         },
         (Some(Structure::BLS12381Gt), Some(SerializationFormat::BLS12381Gt)) => {
@@ -336,12 +334,11 @@ pub fn deserialize_internal(
             if bytes.len() != 576 {
                 return Ok(smallvec![Value::bool(false), Value::u64(0)]);
             }
-            context.charge(gas_params.ark_bls12_381_fq12_deser * NumArgs::one())?;
+            context.charge(ALGEBRA_ARK_BLS12_381_FQ12_DESER)?;
             match <ark_bls12_381::Fq12>::deserialize_uncompressed(bytes) {
                 Ok(element) => {
                     context.charge(
-                        (gas_params.ark_bls12_381_fq12_pow_u256 + gas_params.ark_bls12_381_fq12_eq)
-                            * NumArgs::one(),
+                        ALGEBRA_ARK_BLS12_381_FQ12_POW_U256 + ALGEBRA_ARK_BLS12_381_FQ12_EQ,
                     )?;
                     if element.pow(BLS12381_R_SCALAR.0) == ark_bls12_381::Fq12::one() {
                         let handle = store_element!(context, element)?;
diff --git a/aptos-move/framework/src/natives/cryptography/bls12381.rs b/aptos-move/framework/src/natives/cryptography/bls12381.rs
index d2bc5b91ac077..891b7a51991f8 100644
--- a/aptos-move/framework/src/natives/cryptography/bls12381.rs
+++ b/aptos-move/framework/src/natives/cryptography/bls12381.rs
@@ -1,12 +1,6 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-#[cfg(feature = "testing")]
-use crate::natives::helpers::make_test_only_native_from_func;
-use crate::{
-    natives::helpers::{make_safe_native, SafeNativeContext, SafeNativeResult},
-    safely_pop_arg, safely_pop_vec_arg,
-};
 use aptos_crypto::{bls12381, traits};
 #[cfg(feature = "testing")]
 use aptos_crypto::{
@@ -14,28 +8,25 @@ use aptos_crypto::{
     test_utils::KeyPair,
     SigningKey, Uniform,
 };
-use aptos_types::on_chain_config::{Features, TimedFeatures};
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_pop_arg, safely_pop_vec_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext,
+    SafeNativeResult,
+};
 use move_binary_format::errors::PartialVMError;
 use move_core_types::{
     gas_algebra::{InternalGas, InternalGasPerArg, InternalGasPerByte, NumArgs, NumBytes},
     vm_status::StatusCode,
 };
-#[cfg(feature = "testing")]
-use move_vm_runtime::native_functions::NativeContext;
 use move_vm_runtime::native_functions::NativeFunction;
 use move_vm_types::{
     loaded_data::runtime_types::Type,
     values::{Struct, Value},
 };
 #[cfg(feature = "testing")]
-use move_vm_types::{
-    natives::function::{NativeResult, PartialVMResult},
-    pop_arg,
-};
-#[cfg(feature = "testing")]
 use rand_core::OsRng;
 use smallvec::{smallvec, SmallVec};
-use std::{collections::VecDeque, convert::TryFrom, sync::Arc};
+use std::{collections::VecDeque, convert::TryFrom};
 
 /// Pops a `Vec<T>` off the argument stack and converts it to a `Vec<Vec<u8>>` by reading the first
 /// field of `T`, which is a `Vec<u8>` field named `bytes`.
@@ -76,186 +67,175 @@ pub struct GasParameters {
     pub per_byte_hashing: InternalGasPerByte, // signature verification involves signing |msg| bytes
 }
 
-impl GasParameters {
-    /// Deserializes a vector of PK bytes into bls12381::PublicKey structs.
-    fn bls12381_deserialize_pks(
-        &self,
-        pks_serialized: Vec<Vec<u8>>,
-        context: &mut SafeNativeContext,
-    ) -> SafeNativeResult<Vec<bls12381::PublicKey>> {
-        let mut pks = vec![];
-
-        for pk_bytes in pks_serialized {
-            let pk = match self.bls12381_deserialize_pk(pk_bytes, context)? {
-                Some(key) => key,
-                // If PK does not deserialize correctly, break early
-                None => break,
-            };
-
-            pks.push(pk);
-        }
-
-        Ok(pks)
-    }
+/// Deserializes a vector of PK bytes into bls12381::PublicKey structs.
+fn bls12381_deserialize_pks(
+    pks_serialized: Vec<Vec<u8>>,
+    context: &mut SafeNativeContext,
+) -> SafeNativeResult<Vec<bls12381::PublicKey>> {
+    let mut pks = vec![];
 
-    /// Deserializes a sequence of bytes into bls12381::PublicKey struct.
-    fn bls12381_deserialize_pk(
-        &self,
-        pk_bytes: Vec<u8>,
-        context: &mut SafeNativeContext,
-    ) -> SafeNativeResult<Option<bls12381::PublicKey>> {
-        context.charge(self.per_pubkey_deserialize * NumArgs::one())?;
-
-        match bls12381::PublicKey::try_from(&pk_bytes[..]) {
-            Ok(key) => Ok(Some(key)),
-            // If PK does not deserialize correctly, return None
-            Err(_) => Ok(None),
-        }
-    }
+    for pk_bytes in pks_serialized {
+        let pk = match bls12381_deserialize_pk(pk_bytes, context)? {
+            Some(key) => key,
+            // If PK does not deserialize correctly, break early
+            None => break,
+        };
 
-    /// Deserializes a vector of signature bytes into bls12381::Signature structs.
-    fn bls12381_deserialize_sigs(
-        &self,
-        sigs_serialized: Vec<Vec<u8>>,
-        context: &mut SafeNativeContext,
-    ) -> SafeNativeResult<Vec<bls12381::Signature>> {
-        let mut sigs = vec![];
-
-        for sig_bytes in sigs_serialized {
-            let sig = match self.bls12381_deserialize_sig(sig_bytes, context)? {
-                Some(sig) => sig,
-                // If sig does not deserialize correctly, break early
-                None => break,
-            };
-
-            sigs.push(sig);
-        }
-
-        Ok(sigs)
+        pks.push(pk);
     }
 
-    /// Deserializes a sequence of bytes into bls12381::Signature struct.
-    fn bls12381_deserialize_sig(
-        &self,
-        sig_bytes: Vec<u8>,
-        context: &mut SafeNativeContext,
-    ) -> SafeNativeResult<Option<bls12381::Signature>> {
-        context.charge(self.per_sig_deserialize * NumArgs::one())?;
-
-        match bls12381::Signature::try_from(&sig_bytes[..]) {
-            Ok(sig) => Ok(Some(sig)),
-            // If PK does not deserialize correctly, return None
-            Err(_) => Ok(None),
-        }
-    }
+    Ok(pks)
+}
 
-    /// Deserializes a sequence of bytes into bls12381::Signature struct.
-    fn bls12381_deserialize_pop(
-        &self,
-        pop_bytes: Vec<u8>,
-        context: &mut SafeNativeContext,
-    ) -> SafeNativeResult<Option<bls12381::ProofOfPossession>> {
-        context.charge(self.per_sig_deserialize * NumArgs::one())?;
+/// Deserializes a sequence of bytes into bls12381::PublicKey struct.
+fn bls12381_deserialize_pk(
+    pk_bytes: Vec<u8>,
+    context: &mut SafeNativeContext,
+) -> SafeNativeResult<Option<bls12381::PublicKey>> {
+    context.charge(BLS12381_PER_PUBKEY_DESERIALIZE * NumArgs::one())?;
 
-        match bls12381::ProofOfPossession::try_from(&pop_bytes[..]) {
-            Ok(pop) => Ok(Some(pop)),
-            // If PK does not deserialize correctly, break early
-            Err(_) => Ok(None),
-        }
+    match bls12381::PublicKey::try_from(&pk_bytes[..]) {
+        Ok(key) => Ok(Some(key)),
+        // If PK does not deserialize correctly, return None
+        Err(_) => Ok(None),
     }
+}
+
+/// Deserializes a vector of signature bytes into bls12381::Signature structs.
+fn bls12381_deserialize_sigs(
+    sigs_serialized: Vec<Vec<u8>>,
+    context: &mut SafeNativeContext,
+) -> SafeNativeResult<Vec<bls12381::Signature>> {
+    let mut sigs = vec![];
 
-    /// Checks prime-order subgroup membership on a bls12381::PublicKey struct.
-    fn bls12381_pk_subgroub_check(
-        &self,
-        pk: &bls12381::PublicKey,
-        context: &mut SafeNativeContext,
-    ) -> SafeNativeResult<bool> {
-        // NOTE(Gas): constant-time; around 39 microseconds on Apple M1
-        context.charge(self.per_pubkey_deserialize * NumArgs::one())?;
+    for sig_bytes in sigs_serialized {
+        let sig = match bls12381_deserialize_sig(sig_bytes, context)? {
+            Some(sig) => sig,
+            // If sig does not deserialize correctly, break early
+            None => break,
+        };
 
-        Ok(pk.subgroup_check().is_ok())
+        sigs.push(sig);
     }
 
-    /// Checks prime-order subgroup membership on a bls12381::Signature struct.
-    fn bls12381_sig_subgroub_check(
-        &self,
-        sig: &bls12381::Signature,
-        context: &mut SafeNativeContext,
-    ) -> SafeNativeResult<bool> {
-        context.charge(self.per_sig_subgroup_check * NumArgs::one())?;
+    Ok(sigs)
+}
+
+/// Deserializes a sequence of bytes into bls12381::Signature struct.
+fn bls12381_deserialize_sig(
+    sig_bytes: Vec<u8>,
+    context: &mut SafeNativeContext,
+) -> SafeNativeResult<Option<bls12381::Signature>> {
+    context.charge(BLS12381_PER_SIG_DESERIALIZE * NumArgs::one())?;
 
-        Ok(sig.subgroup_check().is_ok())
+    match bls12381::Signature::try_from(&sig_bytes[..]) {
+        Ok(sig) => Ok(Some(sig)),
+        // If PK does not deserialize correctly, return None
+        Err(_) => Ok(None),
     }
+}
+
+/// Deserializes a sequence of bytes into bls12381::Signature struct.
+fn bls12381_deserialize_pop(
+    pop_bytes: Vec<u8>,
+    context: &mut SafeNativeContext,
+) -> SafeNativeResult<Option<bls12381::ProofOfPossession>> {
+    context.charge(BLS12381_PER_SIG_DESERIALIZE * NumArgs::one())?;
 
-    /// Verifies a signature on an arbitrary message.
-    fn signature_verify<S: traits::Signature>(
-        &self,
-        sig: &S,
-        pk: &S::VerifyingKeyMaterial,
-        msg: Vec<u8>,
-        context: &mut SafeNativeContext,
-    ) -> SafeNativeResult<bool> {
-        // NOTE(Gas): 2 bilinear pairings and a hash-to-curve
-        context.charge(
-            self.per_sig_verify * NumArgs::one()
-                + self.per_msg_hashing * NumArgs::one()
-                + self.per_byte_hashing * NumBytes::new(msg.len() as u64),
-        )?;
-
-        Ok(sig.verify_arbitrary_msg(&msg[..], pk).is_ok())
+    match bls12381::ProofOfPossession::try_from(&pop_bytes[..]) {
+        Ok(pop) => Ok(Some(pop)),
+        // If PK does not deserialize correctly, break early
+        Err(_) => Ok(None),
     }
+}
 
-    /// This is a helper function called by our `bls12381_verify_*` functions for:
-    ///  * normal (non-aggregated) signatures,
-    ///  * signature shares (in the multisignature scheme & the aggregate signature scheme)
-    ///  * multisignatures
-    ///
-    /// Gas cost: base_cost + per_pubkey_deserialize_cost
-    ///                     +? ( per_pubkey_subgroup_check_cost * check_pk_subgroup
-    ///                          +? ( per_sig_deserialize_cost
-    ///                              +? ( per_sig_verify_cost + per_msg_hashing_cost
-    ///                                   + per_byte_hashing_cost * |msg| ) ) )
-    ///
-    /// where +? indicates that the expression stops evaluating there if the previous gas-charging step
-    /// failed.
-    pub fn bls12381_verify_signature_helper(
-        &self,
-        context: &mut SafeNativeContext,
-        _ty_args: Vec<Type>,
-        mut arguments: VecDeque<Value>,
-        check_pk_subgroup: bool,
-    ) -> SafeNativeResult<SmallVec<[Value; 1]>> {
-        debug_assert!(_ty_args.is_empty());
-        debug_assert!(arguments.len() == 3);
-
-        context.charge(self.base)?;
-
-        let msg_bytes = safely_pop_arg!(arguments, Vec<u8>);
-        let aggpk_bytes = safely_pop_arg!(arguments, Vec<u8>);
-        let multisig_bytes = safely_pop_arg!(arguments, Vec<u8>);
-
-        let pk = match self.bls12381_deserialize_pk(aggpk_bytes, context)? {
-            Some(pk) => pk,
-            None => {
-                return Ok(smallvec![Value::bool(false)]);
-            },
-        };
+/// Checks prime-order subgroup membership on a bls12381::PublicKey struct.
+fn bls12381_pk_subgroub_check(
+    pk: &bls12381::PublicKey,
+    context: &mut SafeNativeContext,
+) -> SafeNativeResult<bool> {
+    // NOTE(Gas): constant-time; around 39 microseconds on Apple M1
+    context.charge(BLS12381_PER_PUBKEY_DESERIALIZE * NumArgs::one())?;
 
-        if check_pk_subgroup && !self.bls12381_pk_subgroub_check(&pk, context)? {
-            return Ok(smallvec![Value::bool(false)]);
-        }
+    Ok(pk.subgroup_check().is_ok())
+}
 
-        let sig = match self.bls12381_deserialize_sig(multisig_bytes, context)? {
-            Some(sig) => sig,
-            None => {
-                return Ok(smallvec![Value::bool(false)]);
-            },
-        };
+/// Checks prime-order subgroup membership on a bls12381::Signature struct.
+fn bls12381_sig_subgroub_check(
+    sig: &bls12381::Signature,
+    context: &mut SafeNativeContext,
+) -> SafeNativeResult<bool> {
+    context.charge(BLS12381_PER_SIG_SUBGROUP_CHECK * NumArgs::one())?;
+
+    Ok(sig.subgroup_check().is_ok())
+}
+
+/// Verifies a signature on an arbitrary message.
+fn signature_verify<S: traits::Signature>(
+    sig: &S,
+    pk: &S::VerifyingKeyMaterial,
+    msg: Vec<u8>,
+    context: &mut SafeNativeContext,
+) -> SafeNativeResult<bool> {
+    // NOTE(Gas): 2 bilinear pairings and a hash-to-curve
+    context.charge(
+        BLS12381_PER_SIG_VERIFY * NumArgs::one()
+            + BLS12381_PER_MSG_HASHING * NumArgs::one()
+            + BLS12381_PER_BYTE_HASHING * NumBytes::new(msg.len() as u64),
+    )?;
 
-        let verify_result = self.signature_verify(&sig, &pk, msg_bytes, context)?;
+    Ok(sig.verify_arbitrary_msg(&msg[..], pk).is_ok())
+}
 
-        Ok(smallvec![Value::bool(verify_result)])
+/// This is a helper function called by our `bls12381_verify_*` functions for:
+///  * normal (non-aggregated) signatures,
+///  * signature shares (in the multisignature scheme & the aggregate signature scheme)
+///  * multisignatures
+///
+/// Gas cost: base_cost + per_pubkey_deserialize_cost
+///                     +? ( per_pubkey_subgroup_check_cost * check_pk_subgroup
+///                          +? ( per_sig_deserialize_cost
+///                              +? ( per_sig_verify_cost + per_msg_hashing_cost
+///                                   + per_byte_hashing_cost * |msg| ) ) )
+///
+/// where +? indicates that the expression stops evaluating there if the previous gas-charging step
+/// failed.
+pub fn bls12381_verify_signature_helper(
+    context: &mut SafeNativeContext,
+    _ty_args: Vec<Type>,
+    mut arguments: VecDeque<Value>,
+    check_pk_subgroup: bool,
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
+    debug_assert!(_ty_args.is_empty());
+    debug_assert!(arguments.len() == 3);
+
+    context.charge(BLS12381_BASE)?;
+
+    let msg_bytes = safely_pop_arg!(arguments, Vec<u8>);
+    let aggpk_bytes = safely_pop_arg!(arguments, Vec<u8>);
+    let multisig_bytes = safely_pop_arg!(arguments, Vec<u8>);
+
+    let pk = match bls12381_deserialize_pk(aggpk_bytes, context)? {
+        Some(pk) => pk,
+        None => {
+            return Ok(smallvec![Value::bool(false)]);
+        },
+    };
+
+    if check_pk_subgroup && !bls12381_pk_subgroub_check(&pk, context)? {
+        return Ok(smallvec![Value::bool(false)]);
     }
+
+    let sig = match bls12381_deserialize_sig(multisig_bytes, context)? {
+        Some(sig) => sig,
+        None => {
+            return Ok(smallvec![Value::bool(false)]);
+        },
+    };
+
+    let verify_result = signature_verify(&sig, &pk, msg_bytes, context)?;
+
+    Ok(smallvec![Value::bool(verify_result)])
 }
 
 /***************************************************************************************************
@@ -277,7 +257,6 @@ impl GasParameters {
  * must be charged for the failed deserialization.
  **************************************************************************************************/
 fn native_bls12381_aggregate_pubkeys(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -289,14 +268,14 @@ fn native_bls12381_aggregate_pubkeys(
     let pks_bytes = pop_as_vec_of_vec_u8(&mut arguments)?;
     let num_pks = pks_bytes.len();
 
-    context.charge(gas_params.base)?;
+    context.charge(BLS12381_BASE)?;
 
     // If zero PKs were given as input, return None.
     if pks_bytes.is_empty() {
         return Ok(smallvec![Value::vector_u8(vec![]), Value::bool(false)]);
     }
 
-    let pks = gas_params.bls12381_deserialize_pks(pks_bytes, context)?;
+    let pks = bls12381_deserialize_pks(pks_bytes, context)?;
     debug_assert!(pks.len() <= num_pks);
 
     // If not all PKs were successfully deserialized, return None and only charge for the actual work done
@@ -306,7 +285,7 @@ fn native_bls12381_aggregate_pubkeys(
 
     // Aggregate the public keys (this will NOT subgroup-check the individual PKs)
     // NOTE(Gas): |pks| elliptic curve additions
-    context.charge(gas_params.per_pubkey_aggregate * NumArgs::new(num_pks as u64))?;
+    context.charge(BLS12381_PER_PUBKEY_AGGREGATE * NumArgs::new(num_pks as u64))?;
     let aggpk =
         match bls12381::PublicKey::aggregate(pks.iter().collect::<Vec<&bls12381::PublicKey>>()) {
             Ok(aggpk) => aggpk,
@@ -334,7 +313,6 @@ fn native_bls12381_aggregate_pubkeys(
  * could lie in a small-order subgroup.
  **************************************************************************************************/
 pub fn native_bls12381_aggregate_signatures(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -346,14 +324,14 @@ pub fn native_bls12381_aggregate_signatures(
     let sigs_serialized = pop_as_vec_of_vec_u8(&mut arguments)?;
     let num_sigs = sigs_serialized.len();
 
-    context.charge(gas_params.base)?;
+    context.charge(BLS12381_BASE)?;
 
     // If zero signatures were given as input, return None.
     if sigs_serialized.is_empty() {
         return Ok(smallvec![Value::vector_u8(vec![]), Value::bool(false)]);
     }
 
-    let sigs = gas_params.bls12381_deserialize_sigs(sigs_serialized, context)?;
+    let sigs = bls12381_deserialize_sigs(sigs_serialized, context)?;
 
     if sigs.len() != num_sigs {
         return Ok(smallvec![Value::vector_u8(vec![]), Value::bool(false)]);
@@ -361,7 +339,7 @@ pub fn native_bls12381_aggregate_signatures(
 
     // Aggregate the signatures (this will NOT group-check the individual signatures)
     // NOTE(Gas): |sigs| elliptic curve additions
-    context.charge(gas_params.per_sig_aggregate * NumArgs::new(sigs.len() as u64))?;
+    context.charge(BLS12381_PER_SIG_AGGREGATE * NumArgs::new(sigs.len() as u64))?;
     let aggsig = match bls12381::Signature::aggregate(sigs) {
         Ok(aggsig) => aggsig,
         Err(_) => return Ok(smallvec![Value::vector_u8(vec![]), Value::bool(false)]),
@@ -382,7 +360,6 @@ pub fn native_bls12381_aggregate_signatures(
  * failed
  **************************************************************************************************/
 pub fn native_bls12381_signature_subgroup_check(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -390,16 +367,16 @@ pub fn native_bls12381_signature_subgroup_check(
     debug_assert!(_ty_args.is_empty());
     debug_assert!(arguments.len() == 1);
 
-    context.charge(gas_params.base)?;
+    context.charge(BLS12381_BASE)?;
 
     let sig_bytes = safely_pop_arg!(arguments, Vec<u8>);
 
-    let sig = match gas_params.bls12381_deserialize_sig(sig_bytes, context)? {
+    let sig = match bls12381_deserialize_sig(sig_bytes, context)? {
         Some(key) => key,
         None => return Ok(smallvec![Value::bool(false)]),
     };
 
-    let valid = gas_params.bls12381_sig_subgroub_check(&sig, context)?;
+    let valid = bls12381_sig_subgroub_check(&sig, context)?;
 
     Ok(smallvec![Value::bool(valid)])
 }
@@ -413,7 +390,6 @@ pub fn native_bls12381_signature_subgroup_check(
  * failed
  **************************************************************************************************/
 fn native_bls12381_validate_pubkey(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -421,16 +397,16 @@ fn native_bls12381_validate_pubkey(
     debug_assert!(_ty_args.is_empty());
     debug_assert!(arguments.len() == 1);
 
-    context.charge(gas_params.base)?;
+    context.charge(BLS12381_BASE)?;
 
     let pk_bytes = safely_pop_arg!(arguments, Vec<u8>);
 
-    let pk = match gas_params.bls12381_deserialize_pk(pk_bytes, context)? {
+    let pk = match bls12381_deserialize_pk(pk_bytes, context)? {
         Some(key) => key,
         None => return Ok(smallvec![Value::bool(false)]),
     };
 
-    let valid = gas_params.bls12381_pk_subgroub_check(&pk, context)?;
+    let valid = bls12381_pk_subgroub_check(&pk, context)?;
 
     Ok(smallvec![Value::bool(valid)])
 }
@@ -465,7 +441,6 @@ fn native_bls12381_validate_pubkey(
 * must be charged for the failed deserialization. We proceed similarly for per_sig_deserialize_cost.
 **************************************************************************************************/
 pub fn native_bls12381_verify_aggregate_signature(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -473,7 +448,7 @@ pub fn native_bls12381_verify_aggregate_signature(
     debug_assert!(_ty_args.is_empty());
     debug_assert!(arguments.len() == 3);
 
-    context.charge(gas_params.base)?;
+    context.charge(BLS12381_BASE)?;
 
     // Parses a Vec<Vec<u8>> of all messages
     let messages = safely_pop_vec_arg!(arguments, Vec<u8>);
@@ -489,7 +464,7 @@ pub fn native_bls12381_verify_aggregate_signature(
         return Ok(smallvec![Value::bool(false)]);
     }
 
-    let pks = gas_params.bls12381_deserialize_pks(pks_serialized, context)?;
+    let pks = bls12381_deserialize_pks(pks_serialized, context)?;
     debug_assert!(pks.len() <= num_pks);
 
     // If less PKs than expected were deserialized, return None.
@@ -497,7 +472,7 @@ pub fn native_bls12381_verify_aggregate_signature(
         return Ok(smallvec![Value::bool(false)]);
     }
 
-    let aggsig = match gas_params.bls12381_deserialize_sig(aggsig_bytes, context)? {
+    let aggsig = match bls12381_deserialize_sig(aggsig_bytes, context)? {
         Some(aggsig) => aggsig,
         None => return Ok(smallvec![Value::bool(false)]),
     };
@@ -511,9 +486,9 @@ pub fn native_bls12381_verify_aggregate_signature(
     // The cost of verifying a size-n aggregate signatures involves n+1 parings and hashing all
     // the messages to elliptic curve points (proportional to sum of all message lengths).
     context.charge(
-        gas_params.per_pairing * NumArgs::new((messages.len() + 1) as u64)
-            + gas_params.per_msg_hashing * NumArgs::new(messages.len() as u64)
-            + gas_params.per_byte_hashing
+        BLS12381_PER_PAIRING * NumArgs::new((messages.len() + 1) as u64)
+            + BLS12381_PER_MSG_HASHING * NumArgs::new(messages.len() as u64)
+            + BLS12381_PER_BYTE_HASHING
                 * messages.iter().fold(NumBytes::new(0), |sum, msg| {
                     sum + NumBytes::new(msg.len() as u64)
                 }),
@@ -538,13 +513,12 @@ pub fn native_bls12381_verify_aggregate_signature(
  * failed
  **************************************************************************************************/
 pub fn native_bls12381_verify_multisignature(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     arguments: VecDeque<Value>,
 ) -> SafeNativeResult<SmallVec<[Value; 1]>> {
     let check_pk_subgroup = false;
-    gas_params.bls12381_verify_signature_helper(context, _ty_args, arguments, check_pk_subgroup)
+    bls12381_verify_signature_helper(context, _ty_args, arguments, check_pk_subgroup)
 }
 
 /***************************************************************************************************
@@ -560,7 +534,6 @@ pub fn native_bls12381_verify_multisignature(
  * failed
  **************************************************************************************************/
 pub fn native_bls12381_verify_normal_signature(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     arguments: VecDeque<Value>,
@@ -569,7 +542,7 @@ pub fn native_bls12381_verify_normal_signature(
     // might forget to check prime-order subgroup membership of the PK. Therefore, we always enforce
     // it here.
     let check_pk_subgroup = true;
-    gas_params.bls12381_verify_signature_helper(context, _ty_args, arguments, check_pk_subgroup)
+    bls12381_verify_signature_helper(context, _ty_args, arguments, check_pk_subgroup)
 }
 
 /***************************************************************************************************
@@ -583,7 +556,6 @@ pub fn native_bls12381_verify_normal_signature(
  * failed
  **************************************************************************************************/
 fn native_bls12381_verify_proof_of_possession(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -591,23 +563,23 @@ fn native_bls12381_verify_proof_of_possession(
     debug_assert!(_ty_args.is_empty());
     debug_assert!(arguments.len() == 2);
 
-    context.charge(gas_params.base)?;
+    context.charge(BLS12381_BASE)?;
 
     let pop_bytes = safely_pop_arg!(arguments, Vec<u8>);
     let key_bytes = safely_pop_arg!(arguments, Vec<u8>);
 
-    let pk = match gas_params.bls12381_deserialize_pk(key_bytes, context)? {
+    let pk = match bls12381_deserialize_pk(key_bytes, context)? {
         Some(pk) => pk,
         None => return Ok(smallvec![Value::bool(false)]),
     };
 
-    let pop = match gas_params.bls12381_deserialize_pop(pop_bytes, context)? {
+    let pop = match bls12381_deserialize_pop(pop_bytes, context)? {
         Some(pop) => pop,
         None => return Ok(smallvec![Value::bool(false)]),
     };
 
     // NOTE(Gas): 2 bilinear pairings and a hash-to-curve
-    context.charge(gas_params.per_pop_verify * NumArgs::one())?;
+    context.charge(BLS12381_PER_POP_VERIFY * NumArgs::one())?;
     let valid = pop.verify(&pk).is_ok();
 
     Ok(smallvec![Value::bool(valid)])
@@ -625,7 +597,6 @@ fn native_bls12381_verify_proof_of_possession(
  * failed
  **************************************************************************************************/
 pub fn native_bls12381_verify_signature_share(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     arguments: VecDeque<Value>,
@@ -633,49 +604,45 @@ pub fn native_bls12381_verify_signature_share(
     // For signature shares, the caller is REQUIRED to check the PK's PoP, and thus the PK is in the
     // prime-order subgroup.
     let check_pk_subgroup = false;
-    gas_params.bls12381_verify_signature_helper(context, _ty_args, arguments, check_pk_subgroup)
+    bls12381_verify_signature_helper(context, _ty_args, arguments, check_pk_subgroup)
 }
 
 #[cfg(feature = "testing")]
 pub fn native_generate_keys(
-    _context: &mut NativeContext,
+    _context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut _arguments: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
     let key_pair = KeyPair::<PrivateKey, PublicKey>::generate(&mut OsRng);
-    Ok(NativeResult::ok(InternalGas::zero(), smallvec![
+    Ok(smallvec![
         Value::vector_u8(key_pair.private_key.to_bytes()),
         Value::vector_u8(key_pair.public_key.to_bytes()),
-    ]))
+    ])
 }
 
 #[cfg(feature = "testing")]
 pub fn native_sign(
-    _context: &mut NativeContext,
+    _context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
-    let msg = pop_arg!(arguments, Vec<u8>);
-    let sk_bytes = pop_arg!(arguments, Vec<u8>);
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
+    let msg = safely_pop_arg!(arguments, Vec<u8>);
+    let sk_bytes = safely_pop_arg!(arguments, Vec<u8>);
     let sk = PrivateKey::try_from(sk_bytes.as_slice()).unwrap();
     let sig = sk.sign_arbitrary_message(msg.as_slice());
-    Ok(NativeResult::ok(InternalGas::zero(), smallvec![
-        Value::vector_u8(sig.to_bytes()),
-    ]))
+    Ok(smallvec![Value::vector_u8(sig.to_bytes()),])
 }
 
 #[cfg(feature = "testing")]
 pub fn native_generate_proof_of_possession(
-    _context: &mut NativeContext,
+    _context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
-    let sk_bytes = pop_arg!(arguments, Vec<u8>);
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
+    let sk_bytes = safely_pop_arg!(arguments, Vec<u8>);
     let sk = PrivateKey::try_from(sk_bytes.as_slice()).unwrap();
     let pop = ProofOfPossession::create(&sk);
-    Ok(NativeResult::ok(InternalGas::zero(), smallvec![
-        Value::vector_u8(pop.to_bytes()),
-    ]))
+    Ok(smallvec![Value::vector_u8(pop.to_bytes()),])
 }
 
 /***************************************************************************************************
@@ -683,109 +650,59 @@ pub fn native_generate_proof_of_possession(
  *
  **************************************************************************************************/
 pub fn make_all(
-    gas_params: GasParameters,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
     let mut natives = vec![];
-    natives.append(&mut vec![
+
+    natives.extend([
         // BLS over BLS12-381
         (
             "aggregate_pubkeys_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                native_bls12381_aggregate_pubkeys,
-            ),
+            native_bls12381_aggregate_pubkeys as RawSafeNative,
         ),
         (
             "aggregate_signatures_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                native_bls12381_aggregate_signatures,
-            ),
+            native_bls12381_aggregate_signatures,
         ),
         (
             "signature_subgroup_check_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                native_bls12381_signature_subgroup_check,
-            ),
-        ),
-        (
-            "validate_pubkey_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                native_bls12381_validate_pubkey,
-            ),
+            native_bls12381_signature_subgroup_check,
         ),
+        ("validate_pubkey_internal", native_bls12381_validate_pubkey),
         (
             "verify_aggregate_signature_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                native_bls12381_verify_aggregate_signature,
-            ),
+            native_bls12381_verify_aggregate_signature,
         ),
         (
             "verify_multisignature_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                native_bls12381_verify_multisignature,
-            ),
+            native_bls12381_verify_multisignature,
         ),
         (
             "verify_normal_signature_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                native_bls12381_verify_normal_signature,
-            ),
+            native_bls12381_verify_normal_signature,
         ),
         (
             "verify_proof_of_possession_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                native_bls12381_verify_proof_of_possession,
-            ),
+            native_bls12381_verify_proof_of_possession,
         ),
         (
             "verify_signature_share_internal",
-            make_safe_native(
-                gas_params,
-                timed_features,
-                features,
-                native_bls12381_verify_signature_share,
-            ),
+            native_bls12381_verify_signature_share,
         ),
     ]);
+
     #[cfg(feature = "testing")]
     natives.append(&mut vec![
         (
             "generate_keys_internal",
-            make_test_only_native_from_func(native_generate_keys),
-        ),
-        (
-            "sign_internal",
-            make_test_only_native_from_func(native_sign),
+            native_generate_keys as RawSafeNative,
         ),
+        ("sign_internal", native_sign),
         (
             "generate_proof_of_possession_internal",
-            make_test_only_native_from_func(native_generate_proof_of_possession),
+            native_generate_proof_of_possession,
         ),
     ]);
-    crate::natives::helpers::make_module_natives(natives)
+
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/src/natives/cryptography/ed25519.rs b/aptos-move/framework/src/natives/cryptography/ed25519.rs
index ff67c4534f127..1f910b94b7ae1 100644
--- a/aptos-move/framework/src/natives/cryptography/ed25519.rs
+++ b/aptos-move/framework/src/natives/cryptography/ed25519.rs
@@ -1,34 +1,27 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-#[cfg(feature = "testing")]
-use crate::natives::helpers::make_test_only_native_from_func;
-use crate::{
-    natives::helpers::{make_safe_native, SafeNativeContext, SafeNativeError, SafeNativeResult},
-    safely_pop_arg,
-};
 #[cfg(feature = "testing")]
 use aptos_crypto::ed25519::{Ed25519PrivateKey, Ed25519PublicKey};
 #[cfg(feature = "testing")]
 use aptos_crypto::test_utils::KeyPair;
 use aptos_crypto::{ed25519, ed25519::ED25519_PUBLIC_KEY_LENGTH, traits::*};
-use aptos_types::on_chain_config::{FeatureFlag, Features, TimedFeatures};
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext, SafeNativeError,
+    SafeNativeResult,
+};
+use aptos_types::on_chain_config::FeatureFlag;
 use curve25519_dalek::edwards::CompressedEdwardsY;
-#[cfg(feature = "testing")]
-use move_binary_format::errors::PartialVMResult;
 use move_core_types::gas_algebra::{
     InternalGas, InternalGasPerArg, InternalGasPerByte, NumArgs, NumBytes,
 };
-#[cfg(feature = "testing")]
-use move_vm_runtime::native_functions::NativeContext;
 use move_vm_runtime::native_functions::NativeFunction;
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 #[cfg(feature = "testing")]
-use move_vm_types::{natives::function::NativeResult, pop_arg};
-#[cfg(feature = "testing")]
 use rand_core::OsRng;
 use smallvec::{smallvec, SmallVec};
-use std::{collections::VecDeque, convert::TryFrom, sync::Arc};
+use std::{collections::VecDeque, convert::TryFrom};
 
 pub mod abort_codes {
     pub const E_WRONG_PUBKEY_SIZE: u64 = 1;
@@ -44,7 +37,6 @@ pub mod abort_codes {
  * failed
  **************************************************************************************************/
 fn native_public_key_validate(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -54,7 +46,7 @@ fn native_public_key_validate(
 
     let key_bytes = safely_pop_arg!(arguments, Vec<u8>);
 
-    context.charge(gas_params.base + gas_params.per_pubkey_deserialize * NumArgs::one())?;
+    context.charge(ED25519_BASE + ED25519_PER_PUBKEY_DESERIALIZE * NumArgs::one())?;
 
     let key_bytes_slice = match <[u8; ED25519_PUBLIC_KEY_LENGTH]>::try_from(key_bytes) {
         Ok(slice) => slice,
@@ -84,7 +76,7 @@ fn native_public_key_validate(
     // Check if the point lies on a small subgroup. This is required when using curves with a
     // small cofactor (e.g., in Ed25519, cofactor = 8).
     // NOTE(Gas): O(1) cost: multiplies the point by the cofactor
-    context.charge(gas_params.per_pubkey_small_order_check * NumArgs::one())?;
+    context.charge(ED25519_PER_PUBKEY_SMALL_ORDER_CHECK * NumArgs::one())?;
     let valid = !point.is_small_order();
 
     Ok(smallvec![Value::bool(valid)])
@@ -102,7 +94,6 @@ fn native_public_key_validate(
  * failed
  **************************************************************************************************/
 fn native_signature_verify_strict(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -114,9 +105,9 @@ fn native_signature_verify_strict(
     let pubkey = safely_pop_arg!(arguments, Vec<u8>);
     let signature = safely_pop_arg!(arguments, Vec<u8>);
 
-    context.charge(gas_params.base)?;
+    context.charge(ED25519_BASE)?;
 
-    context.charge(gas_params.per_pubkey_deserialize * NumArgs::one())?;
+    context.charge(ED25519_PER_PUBKEY_DESERIALIZE * NumArgs::one())?;
 
     let pk = match ed25519::Ed25519PublicKey::try_from(pubkey.as_slice()) {
         Ok(pk) => pk,
@@ -125,7 +116,7 @@ fn native_signature_verify_strict(
         },
     };
 
-    context.charge(gas_params.per_sig_deserialize * NumArgs::one())?;
+    context.charge(ED25519_PER_SIG_DESERIALIZE * NumArgs::one())?;
 
     let sig = match ed25519::Ed25519Signature::try_from(signature.as_slice()) {
         Ok(sig) => sig,
@@ -135,9 +126,9 @@ fn native_signature_verify_strict(
     };
 
     // NOTE(Gas): hashing the message to the group and a size-2 multi-scalar multiplication
-    let hash_then_verify_cost = gas_params.per_sig_strict_verify * NumArgs::one()
-        + gas_params.per_msg_hashing_base * NumArgs::one()
-        + gas_params.per_msg_byte_hashing * NumBytes::new(msg.len() as u64);
+    let hash_then_verify_cost = ED25519_PER_SIG_STRICT_VERIFY * NumArgs::one()
+        + ED25519_PER_MSG_HASHING_BASE * NumArgs::one()
+        + ED25519_PER_MSG_BYTE_HASHING * NumBytes::new(msg.len() as u64);
     context.charge(hash_then_verify_cost)?;
 
     let verify_result = sig.verify_arbitrary_msg(msg.as_slice(), &pk).is_ok();
@@ -160,74 +151,56 @@ pub struct GasParameters {
 }
 
 pub fn make_all(
-    gas_params: GasParameters,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
     let mut natives = vec![];
 
-    // Always-on natives.
-    natives.append(&mut vec![
+    natives.extend([
         (
             "public_key_validate_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                native_public_key_validate,
-            ),
+            native_public_key_validate as RawSafeNative,
         ),
         (
             "signature_verify_strict_internal",
-            make_safe_native(
-                gas_params,
-                timed_features,
-                features,
-                native_signature_verify_strict,
-            ),
+            native_signature_verify_strict,
         ),
     ]);
 
     // Test-only natives.
     #[cfg(feature = "testing")]
-    natives.append(&mut vec![
+    natives.extend([
         (
             "generate_keys_internal",
-            make_test_only_native_from_func(native_test_only_generate_keys_internal),
-        ),
-        (
-            "sign_internal",
-            make_test_only_native_from_func(native_test_only_sign_internal),
+            native_test_only_generate_keys_internal as RawSafeNative,
         ),
+        ("sign_internal", native_test_only_sign_internal),
     ]);
 
-    crate::natives::helpers::make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
 
 #[cfg(feature = "testing")]
 fn native_test_only_generate_keys_internal(
-    _context: &mut NativeContext,
+    _context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut _args: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
     let key_pair = KeyPair::<Ed25519PrivateKey, Ed25519PublicKey>::generate(&mut OsRng);
-    Ok(NativeResult::ok(InternalGas::zero(), smallvec![
+    Ok(smallvec![
         Value::vector_u8(key_pair.private_key.to_bytes()),
         Value::vector_u8(key_pair.public_key.to_bytes())
-    ]))
+    ])
 }
 
 #[cfg(feature = "testing")]
 fn native_test_only_sign_internal(
-    _context: &mut NativeContext,
+    _context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
-    let msg_bytes = pop_arg!(args, Vec<u8>);
-    let sk_bytes = pop_arg!(args, Vec<u8>);
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
+    let msg_bytes = safely_pop_arg!(args, Vec<u8>);
+    let sk_bytes = safely_pop_arg!(args, Vec<u8>);
     let sk = Ed25519PrivateKey::try_from(sk_bytes.as_slice()).unwrap();
     let sig = sk.sign_arbitrary_message(msg_bytes.as_slice());
-    Ok(NativeResult::ok(InternalGas::zero(), smallvec![
-        Value::vector_u8(sig.to_bytes())
-    ]))
+    Ok(smallvec![Value::vector_u8(sig.to_bytes())])
 }
diff --git a/aptos-move/framework/src/natives/cryptography/multi_ed25519.rs b/aptos-move/framework/src/natives/cryptography/multi_ed25519.rs
index b96301e675c69..ad80f69e16ff4 100644
--- a/aptos-move/framework/src/natives/cryptography/multi_ed25519.rs
+++ b/aptos-move/framework/src/natives/cryptography/multi_ed25519.rs
@@ -1,15 +1,6 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-#[cfg(feature = "testing")]
-use crate::natives::helpers::make_test_only_native_from_func;
-use crate::{
-    natives::{
-        cryptography::ed25519::GasParameters,
-        helpers::{make_safe_native, SafeNativeContext, SafeNativeResult},
-    },
-    safely_assert_eq, safely_pop_arg,
-};
 #[cfg(feature = "testing")]
 use aptos_crypto::ed25519::{Ed25519PrivateKey, Ed25519PublicKey};
 #[cfg(feature = "testing")]
@@ -20,27 +11,23 @@ use aptos_crypto::{
     multi_ed25519,
     traits::*,
 };
-use aptos_types::on_chain_config::{Features, TimedFeatures};
+use aptos_gas_algebra::{Arg, GasExpression};
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_assert_eq, safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext,
+    SafeNativeResult,
+};
 use curve25519_dalek::edwards::CompressedEdwardsY;
-#[cfg(feature = "testing")]
-use move_binary_format::errors::PartialVMResult;
-#[cfg(feature = "testing")]
-use move_core_types::gas_algebra::InternalGas;
-use move_core_types::gas_algebra::{InternalGasPerArg, NumArgs, NumBytes};
-#[cfg(feature = "testing")]
-use move_vm_runtime::native_functions::NativeContext;
+use move_core_types::gas_algebra::{NumArgs, NumBytes};
 use move_vm_runtime::native_functions::NativeFunction;
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 #[cfg(feature = "testing")]
-use move_vm_types::{natives::function::NativeResult, pop_arg};
-#[cfg(feature = "testing")]
 use rand_core::OsRng;
 use smallvec::{smallvec, SmallVec};
-use std::{collections::VecDeque, convert::TryFrom, sync::Arc};
+use std::{collections::VecDeque, convert::TryFrom};
 
 /// See `public_key_validate_v2_internal` comments in `multi_ed25519.move`.
 fn native_public_key_validate_v2(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -50,7 +37,7 @@ fn native_public_key_validate_v2(
 
     let pks_bytes = safely_pop_arg!(arguments, Vec<u8>);
 
-    context.charge(gas_params.base)?;
+    context.charge(ED25519_BASE)?;
 
     // Checks that these bytes correctly-encode a t-out-of-n MultiEd25519 PK
     let (_, num_sub_pks) = match multi_ed25519::check_and_get_threshold(
@@ -63,14 +50,13 @@ fn native_public_key_validate_v2(
         },
     };
 
-    let num_valid = num_valid_subpks(gas_params, context, pks_bytes)?;
+    let num_valid = num_valid_subpks(context, pks_bytes)?;
     let all_valid = num_valid == num_sub_pks as usize;
 
     Ok(smallvec![Value::bool(all_valid)])
 }
 
 fn native_public_key_validate_with_gas_fix(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -82,20 +68,19 @@ fn native_public_key_validate_with_gas_fix(
 
     let num_sub_pks = pks_bytes.len() / ED25519_PUBLIC_KEY_LENGTH;
 
-    context.charge(gas_params.base)?;
+    context.charge(ED25519_BASE)?;
 
     if num_sub_pks > multi_ed25519::MAX_NUM_OF_KEYS {
         return Ok(smallvec![Value::bool(false)]);
     };
 
-    let num_valid = num_valid_subpks(gas_params, context, pks_bytes)?;
+    let num_valid = num_valid_subpks(context, pks_bytes)?;
     let all_valid = num_valid == num_sub_pks;
 
     Ok(smallvec![Value::bool(all_valid)])
 }
 
 fn num_valid_subpks(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     pks_bytes: Vec<u8>,
 ) -> SafeNativeResult<usize> {
@@ -105,7 +90,7 @@ fn num_valid_subpks(
     for chunk in pks_bytes.chunks_exact(ED25519_PUBLIC_KEY_LENGTH) {
         // First, we charge for the work.
         context.charge(
-            (gas_params.per_pubkey_deserialize + gas_params.per_pubkey_small_order_check)
+            (ED25519_PER_PUBKEY_DESERIALIZE + ED25519_PER_PUBKEY_SMALL_ORDER_CHECK)
                 * NumArgs::new(1),
         )?;
 
@@ -129,7 +114,6 @@ fn num_valid_subpks(
 }
 
 fn native_signature_verify_strict(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -141,12 +125,12 @@ fn native_signature_verify_strict(
     let pubkey = safely_pop_arg!(arguments, Vec<u8>);
     let signature = safely_pop_arg!(arguments, Vec<u8>);
 
-    context.charge(gas_params.base)?;
+    context.charge(ED25519_BASE)?;
 
     let num_sub_pks = NumArgs::new((pubkey.len() / ED25519_PUBLIC_KEY_LENGTH) as u64);
     let num_sub_sigs = NumArgs::new((signature.len() / ED25519_SIGNATURE_LENGTH) as u64);
 
-    context.charge(gas_params.per_pubkey_deserialize * num_sub_pks)?;
+    context.charge(ED25519_PER_PUBKEY_DESERIALIZE * num_sub_pks)?;
     let pk = match multi_ed25519::MultiEd25519PublicKey::try_from(pubkey.as_slice()) {
         Ok(pk) => pk,
         Err(_) => {
@@ -154,7 +138,7 @@ fn native_signature_verify_strict(
         },
     };
 
-    context.charge(gas_params.per_sig_deserialize * num_sub_sigs)?;
+    context.charge(ED25519_PER_SIG_DESERIALIZE * num_sub_sigs)?;
     let sig = match multi_ed25519::MultiEd25519Signature::try_from(signature.as_slice()) {
         Ok(sig) => sig,
         Err(_) => {
@@ -162,13 +146,11 @@ fn native_signature_verify_strict(
         },
     };
 
-    // TODO(Gas): Have Victor improve type safety here
     context.charge(
-        gas_params.per_sig_strict_verify * num_sub_sigs
-            + gas_params.per_msg_hashing_base * num_sub_sigs
-            + InternalGasPerArg::from(u64::from(
-                gas_params.per_msg_byte_hashing * NumBytes::new(msg.len() as u64),
-            )) * num_sub_sigs,
+        ED25519_PER_SIG_STRICT_VERIFY * num_sub_sigs
+            + ED25519_PER_MSG_HASHING_BASE * num_sub_sigs
+            + (ED25519_PER_MSG_BYTE_HASHING * NumBytes::new(msg.len() as u64)).per::<Arg>()
+                * num_sub_sigs,
     )?;
 
     let verify_result = sig.verify_arbitrary_msg(msg.as_slice(), &pk).is_ok();
@@ -177,12 +159,12 @@ fn native_signature_verify_strict(
 
 #[cfg(feature = "testing")]
 fn native_generate_keys(
-    _context: &mut NativeContext,
+    _context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
-    let n = pop_arg!(arguments, u8);
-    let threshold = pop_arg!(arguments, u8);
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
+    let n = safely_pop_arg!(arguments, u8);
+    let threshold = safely_pop_arg!(arguments, u8);
     let key_pairs: Vec<KeyPair<Ed25519PrivateKey, Ed25519PublicKey>> = (0..n)
         .map(|_i| KeyPair::<Ed25519PrivateKey, Ed25519PublicKey>::generate(&mut OsRng))
         .collect();
@@ -196,77 +178,56 @@ fn native_generate_keys(
         .collect();
     let group_sk = multi_ed25519::MultiEd25519PrivateKey::new(private_keys, threshold).unwrap();
     let group_pk = multi_ed25519::MultiEd25519PublicKey::new(public_keys, threshold).unwrap();
-    Ok(NativeResult::ok(InternalGas::zero(), smallvec![
+    Ok(smallvec![
         Value::vector_u8(group_sk.to_bytes()),
         Value::vector_u8(group_pk.to_bytes()),
-    ]))
+    ])
 }
 
 #[cfg(feature = "testing")]
 fn native_sign(
-    _context: &mut NativeContext,
+    _context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
-) -> PartialVMResult<NativeResult> {
-    let message = pop_arg!(arguments, Vec<u8>);
-    let sk_bytes = pop_arg!(arguments, Vec<u8>);
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
+    let message = safely_pop_arg!(arguments, Vec<u8>);
+    let sk_bytes = safely_pop_arg!(arguments, Vec<u8>);
     let group_sk = multi_ed25519::MultiEd25519PrivateKey::try_from(sk_bytes.as_slice()).unwrap();
     let sig = group_sk.sign_arbitrary_message(message.as_slice());
-    Ok(NativeResult::ok(InternalGas::zero(), smallvec![
-        Value::vector_u8(sig.to_bytes()),
-    ]))
+    Ok(smallvec![Value::vector_u8(sig.to_bytes()),])
 }
 /***************************************************************************************************
  * module
  *
  **************************************************************************************************/
-
 pub fn make_all(
-    gas_params: GasParameters,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
     let mut natives = vec![];
-    natives.append(&mut vec![
+
+    natives.extend([
         // MultiEd25519
         (
             "public_key_validate_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                native_public_key_validate_with_gas_fix,
-            ),
+            native_public_key_validate_with_gas_fix as RawSafeNative,
         ),
         (
             "public_key_validate_v2_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                native_public_key_validate_v2,
-            ),
+            native_public_key_validate_v2,
         ),
         (
             "signature_verify_strict_internal",
-            make_safe_native(
-                gas_params,
-                timed_features,
-                features,
-                native_signature_verify_strict,
-            ),
+            native_signature_verify_strict,
         ),
     ]);
     #[cfg(feature = "testing")]
-    natives.append(&mut vec![
+    natives.extend([
         (
             "generate_keys_internal",
-            make_test_only_native_from_func(native_generate_keys),
-        ),
-        (
-            "sign_internal",
-            make_test_only_native_from_func(native_sign),
+            native_generate_keys as RawSafeNative,
         ),
+        ("sign_internal", native_sign),
     ]);
-    crate::natives::helpers::make_module_natives(natives)
+
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/src/natives/cryptography/ristretto255.rs b/aptos-move/framework/src/natives/cryptography/ristretto255.rs
index 9c66e18994fa7..1daea625b5323 100644
--- a/aptos-move/framework/src/natives/cryptography/ristretto255.rs
+++ b/aptos-move/framework/src/natives/cryptography/ristretto255.rs
@@ -1,23 +1,17 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{
-    natives::{
-        cryptography::{ristretto255_point, ristretto255_scalar},
-        helpers::{make_safe_native, SafeNativeError, SafeNativeResult},
-    },
-    safely_assert_eq, safely_pop_arg,
-};
-use aptos_types::{
-    on_chain_config::{Features, TimedFeatures},
-    vm_status::StatusCode,
+use crate::natives::cryptography::{ristretto255_point, ristretto255_scalar};
+use aptos_native_interface::{
+    safely_assert_eq, safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeError,
+    SafeNativeResult,
 };
+use aptos_types::vm_status::StatusCode;
 use curve25519_dalek::scalar::Scalar;
 use move_binary_format::errors::PartialVMError;
-use move_core_types::gas_algebra::{InternalGasPerArg, InternalGasPerByte};
 use move_vm_runtime::native_functions::NativeFunction;
 use move_vm_types::values::{Reference, StructRef, Value};
-use std::{collections::VecDeque, sync::Arc};
+use std::collections::VecDeque;
 
 /// The size of a serialized scalar, in bytes.
 pub(crate) const SCALAR_NUM_BYTES: usize = 32;
@@ -25,272 +19,98 @@ pub(crate) const SCALAR_NUM_BYTES: usize = 32;
 /// The size of a serialized compressed Ristretto point, in bytes.
 pub(crate) const COMPRESSED_POINT_NUM_BYTES: usize = 32;
 
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub basepoint_mul: InternalGasPerArg,
-    pub basepoint_double_mul: InternalGasPerArg,
-
-    pub point_add: InternalGasPerArg,
-    pub point_compress: InternalGasPerArg,
-    pub point_decompress: InternalGasPerArg,
-    pub point_equals: InternalGasPerArg,
-    pub point_from_64_uniform_bytes: InternalGasPerArg,
-    pub point_identity: InternalGasPerArg,
-    pub point_mul: InternalGasPerArg,
-    pub point_neg: InternalGasPerArg,
-    pub point_sub: InternalGasPerArg,
-    pub point_parse_arg: InternalGasPerArg,
-
-    pub sha512_per_byte: InternalGasPerByte,
-    pub sha512_per_hash: InternalGasPerArg,
-
-    pub scalar_add: InternalGasPerArg,
-    pub scalar_reduced_from_32_bytes: InternalGasPerArg,
-    pub scalar_uniform_from_64_bytes: InternalGasPerArg,
-    pub scalar_from_u128: InternalGasPerArg,
-    pub scalar_from_u64: InternalGasPerArg,
-    pub scalar_invert: InternalGasPerArg,
-    pub scalar_is_canonical: InternalGasPerArg,
-    pub scalar_mul: InternalGasPerArg,
-    pub scalar_neg: InternalGasPerArg,
-    pub scalar_sub: InternalGasPerArg,
-    pub scalar_parse_arg: InternalGasPerArg,
-}
-
 pub fn make_all(
-    gas_params: GasParameters,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
     let natives = [
         (
             "point_is_canonical_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_point::native_point_is_canonical,
-            ),
+            ristretto255_point::native_point_is_canonical as RawSafeNative,
         ),
         (
             "point_identity_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_point::native_point_identity,
-            ),
+            ristretto255_point::native_point_identity,
         ),
         (
             "point_decompress_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_point::native_point_decompress,
-            ),
+            ristretto255_point::native_point_decompress,
         ),
         (
             "point_compress_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_point::native_point_compress,
-            ),
-        ),
-        (
-            "point_mul_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_point::native_point_mul,
-            ),
-        ),
-        (
-            "point_equals",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_point::native_point_equals,
-            ),
-        ),
-        (
-            "point_neg_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_point::native_point_neg,
-            ),
-        ),
-        (
-            "point_add_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_point::native_point_add,
-            ),
-        ),
-        (
-            "point_sub_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_point::native_point_sub,
-            ),
+            ristretto255_point::native_point_compress,
         ),
+        ("point_mul_internal", ristretto255_point::native_point_mul),
+        ("point_equals", ristretto255_point::native_point_equals),
+        ("point_neg_internal", ristretto255_point::native_point_neg),
+        ("point_add_internal", ristretto255_point::native_point_add),
+        ("point_sub_internal", ristretto255_point::native_point_sub),
         (
             "basepoint_mul_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_point::native_basepoint_mul,
-            ),
+            ristretto255_point::native_basepoint_mul,
         ),
         (
             "basepoint_double_mul_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_point::native_basepoint_double_mul,
-            ),
+            ristretto255_point::native_basepoint_double_mul,
         ),
         (
             "new_point_from_sha512_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_point::native_new_point_from_sha512,
-            ),
+            ristretto255_point::native_new_point_from_sha512,
         ),
         (
             "new_point_from_64_uniform_bytes_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_point::native_new_point_from_64_uniform_bytes,
-            ),
+            ristretto255_point::native_new_point_from_64_uniform_bytes,
         ),
         (
             "multi_scalar_mul_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_point::safe_native_multi_scalar_mul_no_floating_point,
-            ),
+            ristretto255_point::safe_native_multi_scalar_mul_no_floating_point,
         ),
         (
             "scalar_is_canonical_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_scalar::native_scalar_is_canonical,
-            ),
+            ristretto255_scalar::native_scalar_is_canonical,
         ),
         (
             "scalar_invert_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_scalar::native_scalar_invert,
-            ),
+            ristretto255_scalar::native_scalar_invert,
         ),
         (
             "scalar_from_sha512_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_scalar::native_scalar_from_sha512,
-            ),
+            ristretto255_scalar::native_scalar_from_sha512,
         ),
         (
             "scalar_mul_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_scalar::native_scalar_mul,
-            ),
+            ristretto255_scalar::native_scalar_mul,
         ),
         (
             "scalar_add_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_scalar::native_scalar_add,
-            ),
+            ristretto255_scalar::native_scalar_add,
         ),
         (
             "scalar_sub_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_scalar::native_scalar_sub,
-            ),
+            ristretto255_scalar::native_scalar_sub,
         ),
         (
             "scalar_neg_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_scalar::native_scalar_neg,
-            ),
+            ristretto255_scalar::native_scalar_neg,
         ),
         (
             "scalar_from_u64_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_scalar::native_scalar_from_u64,
-            ),
+            ristretto255_scalar::native_scalar_from_u64,
         ),
         (
             "scalar_from_u128_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_scalar::native_scalar_from_u128,
-            ),
+            ristretto255_scalar::native_scalar_from_u128,
         ),
         (
             "scalar_reduced_from_32_bytes_internal",
-            make_safe_native(
-                gas_params.clone(),
-                timed_features.clone(),
-                features.clone(),
-                ristretto255_scalar::native_scalar_reduced_from_32_bytes,
-            ),
+            ristretto255_scalar::native_scalar_reduced_from_32_bytes,
         ),
         (
             "scalar_uniform_from_64_bytes_internal",
-            make_safe_native(
-                gas_params,
-                timed_features,
-                features,
-                ristretto255_scalar::native_scalar_uniform_from_64_bytes,
-            ),
+            ristretto255_scalar::native_scalar_uniform_from_64_bytes,
         ),
     ];
 
-    crate::natives::helpers::make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
 
 /// Pops a 32 byte slice off the argument stack.
diff --git a/aptos-move/framework/src/natives/cryptography/ristretto255_point.rs b/aptos-move/framework/src/natives/cryptography/ristretto255_point.rs
index 1b89ce935800b..5ed33d1e897fa 100644
--- a/aptos-move/framework/src/natives/cryptography/ristretto255_point.rs
+++ b/aptos-move/framework/src/natives/cryptography/ristretto255_point.rs
@@ -4,15 +4,16 @@
 //! A crate which extends Move with a RistrettoPoint struct that points to a Rust-native
 //! curve25519_dalek::ristretto::RistrettoPoint.
 
-use crate::{
-    natives::{
-        cryptography::ristretto255::{
-            pop_64_byte_slice, pop_scalar_from_bytes, scalar_from_struct, GasParameters,
-            COMPRESSED_POINT_NUM_BYTES,
-        },
-        helpers::{log2_floor, SafeNativeContext, SafeNativeError, SafeNativeResult},
+use crate::natives::{
+    cryptography::ristretto255::{
+        pop_64_byte_slice, pop_scalar_from_bytes, scalar_from_struct, COMPRESSED_POINT_NUM_BYTES,
     },
-    safely_assert_eq, safely_pop_arg, safely_pop_type_arg,
+    helpers::log2_floor,
+};
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_assert_eq, safely_pop_arg, safely_pop_type_arg, SafeNativeContext, SafeNativeError,
+    SafeNativeResult,
 };
 use better_any::{Tid, TidAble};
 use curve25519_dalek::{
@@ -153,22 +154,19 @@ impl PointStore {
 // Partial implementation of GasParameters for point operations
 //
 
-impl GasParameters {
-    /// If 'bytes' canonically-encode a valid RistrettoPoint, returns the point.  Otherwise, returns None.
-    fn decompress_maybe_non_canonical_point_bytes(
-        &self,
-        context: &mut SafeNativeContext,
-        bytes: Vec<u8>,
-    ) -> SafeNativeResult<Option<RistrettoPoint>> {
-        context.charge(self.point_decompress * NumArgs::one())?;
-
-        let compressed = match compressed_point_from_bytes(bytes) {
-            Some(point) => point,
-            None => return Ok(None),
-        };
+/// If 'bytes' canonically-encode a valid RistrettoPoint, returns the point.  Otherwise, returns None.
+fn decompress_maybe_non_canonical_point_bytes(
+    context: &mut SafeNativeContext,
+    bytes: Vec<u8>,
+) -> SafeNativeResult<Option<RistrettoPoint>> {
+    context.charge(RISTRETTO255_POINT_DECOMPRESS * NumArgs::one())?;
 
-        Ok(compressed.decompress())
-    }
+    let compressed = match compressed_point_from_bytes(bytes) {
+        Some(point) => point,
+        None => return Ok(None),
+    };
+
+    Ok(compressed.decompress())
 }
 
 //
@@ -176,7 +174,6 @@ impl GasParameters {
 //
 
 pub(crate) fn native_point_identity(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     args: VecDeque<Value>,
@@ -184,7 +181,7 @@ pub(crate) fn native_point_identity(
     safely_assert_eq!(ty_args.len(), 0);
     safely_assert_eq!(args.len(), 0);
 
-    context.charge(gas_params.point_identity * NumArgs::one())?;
+    context.charge(RISTRETTO255_POINT_IDENTITY * NumArgs::one())?;
     let point_context = context.extensions().get::<NativeRistrettoPointContext>();
     let mut point_data = point_context.point_data.borrow_mut();
     let point = RistrettoPoint::identity();
@@ -194,7 +191,6 @@ pub(crate) fn native_point_identity(
 }
 
 pub(crate) fn native_point_is_canonical(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -204,13 +200,12 @@ pub(crate) fn native_point_is_canonical(
 
     let bytes = safely_pop_arg!(args, Vec<u8>);
 
-    let opt_point = gas_params.decompress_maybe_non_canonical_point_bytes(context, bytes)?;
+    let opt_point = decompress_maybe_non_canonical_point_bytes(context, bytes)?;
 
     Ok(smallvec![Value::bool(opt_point.is_some())])
 }
 
 pub(crate) fn native_point_decompress(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -220,7 +215,7 @@ pub(crate) fn native_point_decompress(
 
     let bytes = safely_pop_arg!(args, Vec<u8>);
 
-    let point = match gas_params.decompress_maybe_non_canonical_point_bytes(context, bytes)? {
+    let point = match decompress_maybe_non_canonical_point_bytes(context, bytes)? {
         Some(point) => point,
         None => {
             // NOTE: We return (u64::MAX, false) in this case.
@@ -240,7 +235,6 @@ pub(crate) fn native_point_decompress(
 }
 
 pub(crate) fn native_point_compress(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -248,7 +242,7 @@ pub(crate) fn native_point_compress(
     safely_assert_eq!(ty_args.len(), 0);
     safely_assert_eq!(args.len(), 1);
 
-    context.charge(gas_params.point_compress * NumArgs::one())?;
+    context.charge(RISTRETTO255_POINT_COMPRESS * NumArgs::one())?;
 
     let point_context = context.extensions().get::<NativeRistrettoPointContext>();
     let point_data = point_context.point_data.borrow();
@@ -260,7 +254,6 @@ pub(crate) fn native_point_compress(
 }
 
 pub(crate) fn native_point_mul(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -268,7 +261,7 @@ pub(crate) fn native_point_mul(
     safely_assert_eq!(ty_args.len(), 0);
     safely_assert_eq!(args.len(), 3);
 
-    context.charge(gas_params.point_mul * NumArgs::one())?;
+    context.charge(RISTRETTO255_POINT_MUL * NumArgs::one())?;
 
     let point_context = context.extensions().get::<NativeRistrettoPointContext>();
     let mut point_data = point_context.point_data.borrow_mut();
@@ -293,7 +286,6 @@ pub(crate) fn native_point_mul(
 }
 
 pub(crate) fn native_point_equals(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -301,7 +293,7 @@ pub(crate) fn native_point_equals(
     safely_assert_eq!(ty_args.len(), 0);
     safely_assert_eq!(args.len(), 2);
 
-    context.charge(gas_params.point_equals * NumArgs::one())?;
+    context.charge(RISTRETTO255_POINT_EQUALS * NumArgs::one())?;
 
     let point_context = context.extensions().get::<NativeRistrettoPointContext>();
     let point_data = point_context.point_data.borrow_mut();
@@ -317,7 +309,6 @@ pub(crate) fn native_point_equals(
 }
 
 pub(crate) fn native_point_neg(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -325,7 +316,7 @@ pub(crate) fn native_point_neg(
     safely_assert_eq!(ty_args.len(), 0);
     safely_assert_eq!(args.len(), 2);
 
-    context.charge(gas_params.point_neg * NumArgs::one())?;
+    context.charge(RISTRETTO255_POINT_NEG * NumArgs::one())?;
 
     let point_context = context.extensions().get::<NativeRistrettoPointContext>();
     let mut point_data = point_context.point_data.borrow_mut();
@@ -350,7 +341,6 @@ pub(crate) fn native_point_neg(
 }
 
 pub(crate) fn native_point_add(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -358,7 +348,7 @@ pub(crate) fn native_point_add(
     safely_assert_eq!(ty_args.len(), 0);
     safely_assert_eq!(args.len(), 3);
 
-    context.charge(gas_params.point_add * NumArgs::one())?;
+    context.charge(RISTRETTO255_POINT_ADD * NumArgs::one())?;
 
     let point_context = context.extensions().get::<NativeRistrettoPointContext>();
     let mut point_data = point_context.point_data.borrow_mut();
@@ -393,7 +383,6 @@ pub(crate) fn native_point_add(
 }
 
 pub(crate) fn native_point_sub(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -401,7 +390,7 @@ pub(crate) fn native_point_sub(
     safely_assert_eq!(ty_args.len(), 0);
     safely_assert_eq!(args.len(), 3);
 
-    context.charge(gas_params.point_sub * NumArgs::one())?;
+    context.charge(RISTRETTO255_POINT_SUB * NumArgs::one())?;
 
     let point_context = context.extensions().get::<NativeRistrettoPointContext>();
     let mut point_data = point_context.point_data.borrow_mut();
@@ -435,7 +424,6 @@ pub(crate) fn native_point_sub(
 }
 
 pub(crate) fn native_basepoint_mul(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -443,7 +431,7 @@ pub(crate) fn native_basepoint_mul(
     safely_assert_eq!(ty_args.len(), 0);
     safely_assert_eq!(args.len(), 1);
 
-    context.charge(gas_params.basepoint_mul * NumArgs::one())?;
+    context.charge(RISTRETTO255_BASEPOINT_MUL * NumArgs::one())?;
 
     let point_context = context.extensions().get::<NativeRistrettoPointContext>();
     let mut point_data = point_context.point_data.borrow_mut();
@@ -459,7 +447,6 @@ pub(crate) fn native_basepoint_mul(
 
 #[allow(non_snake_case)]
 pub(crate) fn native_basepoint_double_mul(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -467,7 +454,7 @@ pub(crate) fn native_basepoint_double_mul(
     safely_assert_eq!(ty_args.len(), 0);
     safely_assert_eq!(args.len(), 3);
 
-    context.charge(gas_params.basepoint_double_mul * NumArgs::one())?;
+    context.charge(RISTRETTO255_BASEPOINT_DOUBLE_MUL * NumArgs::one())?;
 
     let point_context = context.extensions().get::<NativeRistrettoPointContext>();
     let mut point_data = point_context.point_data.borrow_mut();
@@ -485,7 +472,6 @@ pub(crate) fn native_basepoint_double_mul(
 }
 
 pub(crate) fn native_new_point_from_sha512(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -496,9 +482,9 @@ pub(crate) fn native_new_point_from_sha512(
     let bytes = safely_pop_arg!(args, Vec<u8>);
 
     context.charge(
-        gas_params.point_from_64_uniform_bytes * NumArgs::one()
-            + gas_params.sha512_per_hash * NumArgs::one()
-            + gas_params.sha512_per_byte * NumBytes::new(bytes.len() as u64),
+        RISTRETTO255_POINT_FROM_64_UNIFORM_BYTES * NumArgs::one()
+            + RISTRETTO255_SHA512_PER_HASH * NumArgs::one()
+            + RISTRETTO255_SHA512_PER_BYTE * NumBytes::new(bytes.len() as u64),
     )?;
 
     let point_context = context.extensions().get::<NativeRistrettoPointContext>();
@@ -510,7 +496,6 @@ pub(crate) fn native_new_point_from_sha512(
 }
 
 pub(crate) fn native_new_point_from_64_uniform_bytes(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -518,7 +503,7 @@ pub(crate) fn native_new_point_from_64_uniform_bytes(
     safely_assert_eq!(ty_args.len(), 0);
     safely_assert_eq!(args.len(), 1);
 
-    context.charge(gas_params.point_from_64_uniform_bytes * NumArgs::one())?;
+    context.charge(RISTRETTO255_POINT_FROM_64_UNIFORM_BYTES * NumArgs::one())?;
 
     let point_context = context.extensions().get::<NativeRistrettoPointContext>();
     let mut point_data = point_context.point_data.borrow_mut();
@@ -538,7 +523,6 @@ pub(crate) fn native_new_point_from_64_uniform_bytes(
 /// Pre-conditions: The # of scalars & points are both > 0. This is ensured by the Move calling
 /// function.
 pub(crate) fn safe_native_multi_scalar_mul_no_floating_point(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     mut ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -559,9 +543,9 @@ pub(crate) fn safe_native_multi_scalar_mul_no_floating_point(
     // the caller of this native. Therefore, num + 1 >= 2, which implies log2_floor(num + 1) >= 1.
     // So we never divide by zero.
     context.charge(
-        gas_params.point_parse_arg * NumArgs::new(num as u64)
-            + gas_params.scalar_parse_arg * NumArgs::new(num as u64)
-            + gas_params.point_mul * NumArgs::new((num / log2_floor(num + 1).unwrap()) as u64),
+        RISTRETTO255_POINT_PARSE_ARG * NumArgs::new(num as u64)
+            + RISTRETTO255_SCALAR_PARSE_ARG * NumArgs::new(num as u64)
+            + RISTRETTO255_POINT_MUL * NumArgs::new((num / log2_floor(num + 1).unwrap()) as u64),
     )?;
 
     // parse scalars
diff --git a/aptos-move/framework/src/natives/cryptography/ristretto255_scalar.rs b/aptos-move/framework/src/natives/cryptography/ristretto255_scalar.rs
index 42112d9ca5130..6cb9658984ad2 100644
--- a/aptos-move/framework/src/natives/cryptography/ristretto255_scalar.rs
+++ b/aptos-move/framework/src/natives/cryptography/ristretto255_scalar.rs
@@ -1,15 +1,12 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{
-    natives::{
-        cryptography::ristretto255::{
-            pop_32_byte_slice, pop_64_byte_slice, pop_scalar_from_bytes, GasParameters,
-            SCALAR_NUM_BYTES,
-        },
-        helpers::{SafeNativeContext, SafeNativeResult},
-    },
-    safely_assert_eq, safely_pop_arg,
+use crate::natives::cryptography::ristretto255::{
+    pop_32_byte_slice, pop_64_byte_slice, pop_scalar_from_bytes, SCALAR_NUM_BYTES,
+};
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_assert_eq, safely_pop_arg, SafeNativeContext, SafeNativeResult,
 };
 use curve25519_dalek::scalar::Scalar;
 use move_core_types::gas_algebra::{NumArgs, NumBytes};
@@ -23,7 +20,6 @@ use std::{
 };
 
 pub(crate) fn native_scalar_is_canonical(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -31,7 +27,7 @@ pub(crate) fn native_scalar_is_canonical(
     safely_assert_eq!(_ty_args.len(), 0);
     safely_assert_eq!(arguments.len(), 1);
 
-    context.charge(gas_params.scalar_is_canonical * NumArgs::one())?;
+    context.charge(RISTRETTO255_SCALAR_IS_CANONICAL * NumArgs::one())?;
 
     let bytes = safely_pop_arg!(arguments, Vec<u8>);
     if bytes.len() != SCALAR_NUM_BYTES {
@@ -47,7 +43,6 @@ pub(crate) fn native_scalar_is_canonical(
 }
 
 pub(crate) fn native_scalar_invert(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -55,7 +50,7 @@ pub(crate) fn native_scalar_invert(
     safely_assert_eq!(_ty_args.len(), 0);
     safely_assert_eq!(arguments.len(), 1);
 
-    context.charge(gas_params.scalar_invert * NumArgs::one())?;
+    context.charge(RISTRETTO255_SCALAR_INVERT * NumArgs::one())?;
 
     let s = pop_scalar_from_bytes(&mut arguments)?;
 
@@ -64,7 +59,6 @@ pub(crate) fn native_scalar_invert(
 }
 
 pub(crate) fn native_scalar_from_sha512(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -75,9 +69,9 @@ pub(crate) fn native_scalar_from_sha512(
     let bytes = safely_pop_arg!(arguments, Vec<u8>);
 
     context.charge(
-        gas_params.scalar_uniform_from_64_bytes * NumArgs::one()
-            + gas_params.sha512_per_hash * NumArgs::one()
-            + gas_params.sha512_per_byte * NumBytes::new(bytes.len() as u64),
+        RISTRETTO255_SCALAR_UNIFORM_FROM_64_BYTES * NumArgs::one()
+            + RISTRETTO255_SHA512_PER_HASH * NumArgs::one()
+            + RISTRETTO255_SHA512_PER_BYTE * NumBytes::new(bytes.len() as u64),
     )?;
 
     let s = Scalar::hash_from_bytes::<Sha512>(bytes.as_slice());
@@ -86,7 +80,6 @@ pub(crate) fn native_scalar_from_sha512(
 }
 
 pub(crate) fn native_scalar_mul(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -94,7 +87,7 @@ pub(crate) fn native_scalar_mul(
     safely_assert_eq!(_ty_args.len(), 0);
     safely_assert_eq!(arguments.len(), 2);
 
-    context.charge(gas_params.scalar_mul * NumArgs::one())?;
+    context.charge(RISTRETTO255_SCALAR_MUL * NumArgs::one())?;
 
     let b = pop_scalar_from_bytes(&mut arguments)?;
     let a = pop_scalar_from_bytes(&mut arguments)?;
@@ -105,7 +98,6 @@ pub(crate) fn native_scalar_mul(
 }
 
 pub(crate) fn native_scalar_add(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -113,7 +105,7 @@ pub(crate) fn native_scalar_add(
     safely_assert_eq!(_ty_args.len(), 0);
     safely_assert_eq!(arguments.len(), 2);
 
-    context.charge(gas_params.scalar_add * NumArgs::one())?;
+    context.charge(RISTRETTO255_SCALAR_ADD * NumArgs::one())?;
 
     let b = pop_scalar_from_bytes(&mut arguments)?;
     let a = pop_scalar_from_bytes(&mut arguments)?;
@@ -124,7 +116,6 @@ pub(crate) fn native_scalar_add(
 }
 
 pub(crate) fn native_scalar_sub(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -132,7 +123,7 @@ pub(crate) fn native_scalar_sub(
     safely_assert_eq!(_ty_args.len(), 0);
     safely_assert_eq!(arguments.len(), 2);
 
-    context.charge(gas_params.scalar_sub * NumArgs::one())?;
+    context.charge(RISTRETTO255_SCALAR_SUB * NumArgs::one())?;
 
     let b = pop_scalar_from_bytes(&mut arguments)?;
     let a = pop_scalar_from_bytes(&mut arguments)?;
@@ -143,7 +134,6 @@ pub(crate) fn native_scalar_sub(
 }
 
 pub(crate) fn native_scalar_neg(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -153,7 +143,7 @@ pub(crate) fn native_scalar_neg(
 
     let a = pop_scalar_from_bytes(&mut arguments)?;
 
-    context.charge(gas_params.scalar_neg * NumArgs::one())?;
+    context.charge(RISTRETTO255_SCALAR_NEG * NumArgs::one())?;
 
     let s = a.neg();
 
@@ -161,7 +151,6 @@ pub(crate) fn native_scalar_neg(
 }
 
 pub(crate) fn native_scalar_from_u64(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -171,7 +160,7 @@ pub(crate) fn native_scalar_from_u64(
 
     let num = safely_pop_arg!(arguments, u64);
 
-    context.charge(gas_params.scalar_from_u64 * NumArgs::one())?;
+    context.charge(RISTRETTO255_SCALAR_FROM_U64 * NumArgs::one())?;
 
     let s = Scalar::from(num);
 
@@ -179,7 +168,6 @@ pub(crate) fn native_scalar_from_u64(
 }
 
 pub(crate) fn native_scalar_from_u128(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -189,7 +177,7 @@ pub(crate) fn native_scalar_from_u128(
 
     let num = safely_pop_arg!(arguments, u128);
 
-    context.charge(gas_params.scalar_from_u128 * NumArgs::one())?;
+    context.charge(RISTRETTO255_SCALAR_FROM_U128 * NumArgs::one())?;
 
     let s = Scalar::from(num);
 
@@ -197,7 +185,6 @@ pub(crate) fn native_scalar_from_u128(
 }
 
 pub(crate) fn native_scalar_reduced_from_32_bytes(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -207,7 +194,7 @@ pub(crate) fn native_scalar_reduced_from_32_bytes(
 
     let bytes_slice = pop_32_byte_slice(&mut arguments)?;
 
-    context.charge(gas_params.scalar_reduced_from_32_bytes * NumArgs::one())?;
+    context.charge(RISTRETTO255_SCALAR_REDUCED_FROM_32_BYTES * NumArgs::one())?;
 
     let s = Scalar::from_bytes_mod_order(bytes_slice);
 
@@ -215,7 +202,6 @@ pub(crate) fn native_scalar_reduced_from_32_bytes(
 }
 
 pub(crate) fn native_scalar_uniform_from_64_bytes(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -225,7 +211,7 @@ pub(crate) fn native_scalar_uniform_from_64_bytes(
 
     let bytes_slice = pop_64_byte_slice(&mut args)?;
 
-    context.charge(gas_params.scalar_uniform_from_64_bytes * NumArgs::one())?;
+    context.charge(RISTRETTO255_SCALAR_UNIFORM_FROM_64_BYTES * NumArgs::one())?;
 
     let s = Scalar::from_bytes_mod_order_wide(&bytes_slice);
 
diff --git a/aptos-move/framework/src/natives/cryptography/secp256k1.rs b/aptos-move/framework/src/natives/cryptography/secp256k1.rs
index b38ab2e1e75d8..d8c4b770d6b1c 100644
--- a/aptos-move/framework/src/natives/cryptography/secp256k1.rs
+++ b/aptos-move/framework/src/natives/cryptography/secp256k1.rs
@@ -7,16 +7,17 @@
  *   gas cost: base_cost +? ecdsa_recover
  *
  **************************************************************************************************/
-use crate::{
-    natives::helpers::{make_safe_native, SafeNativeContext, SafeNativeError, SafeNativeResult},
-    safely_pop_arg,
+
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext, SafeNativeError,
+    SafeNativeResult,
 };
-use aptos_types::on_chain_config::{Features, TimedFeatures};
-use move_core_types::gas_algebra::{InternalGas, InternalGasPerArg, NumArgs};
+use move_core_types::gas_algebra::NumArgs;
 use move_vm_runtime::native_functions::NativeFunction;
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use smallvec::{smallvec, SmallVec};
-use std::{collections::VecDeque, sync::Arc};
+use std::collections::VecDeque;
 
 /// Abort code when deserialization fails (0x01 == INVALID_ARGUMENT)
 /// NOTE: This must match the code in the Move implementation
@@ -25,7 +26,6 @@ pub mod abort_codes {
 }
 
 fn native_ecdsa_recover(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -37,7 +37,7 @@ fn native_ecdsa_recover(
     let recovery_id = safely_pop_arg!(arguments, u8);
     let msg = safely_pop_arg!(arguments, Vec<u8>);
 
-    context.charge(gas_params.base)?;
+    context.charge(SECP256K1_BASE)?;
 
     // NOTE(Gas): O(1) cost
     // (In reality, O(|msg|) deserialization cost, with |msg| < libsecp256k1_core::util::MESSAGE_SIZE
@@ -72,7 +72,7 @@ fn native_ecdsa_recover(
         },
     };
 
-    context.charge(gas_params.ecdsa_recover * NumArgs::one())?;
+    context.charge(SECP256K1_ECDSA_RECOVER * NumArgs::one())?;
 
     // NOTE(Gas): O(1) cost: a size-2 multi-scalar multiplication
     match libsecp256k1::recover(&msg, &sig, &rid) {
@@ -88,21 +88,13 @@ fn native_ecdsa_recover(
  * module
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub base: InternalGas,
-    pub ecdsa_recover: InternalGasPerArg,
-}
-
 pub fn make_all(
-    gas_params: GasParameters,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
     let natives = [(
         "ecdsa_recover_internal",
-        make_safe_native(gas_params, timed_features, features, native_ecdsa_recover),
+        native_ecdsa_recover as RawSafeNative,
     )];
 
-    crate::natives::helpers::make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/src/natives/debug.rs b/aptos-move/framework/src/natives/debug.rs
index a82a7d87aa731..8c049df38c775 100644
--- a/aptos-move/framework/src/natives/debug.rs
+++ b/aptos-move/framework/src/natives/debug.rs
@@ -4,17 +4,11 @@
 // Copyright (c) The Move Contributors
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{
-    natives::{
-        helpers::{
-            make_module_natives, make_safe_native, SafeNativeContext, SafeNativeError,
-            SafeNativeResult,
-        },
-        string_utils::native_format_debug,
-    },
-    safely_pop_arg,
+use crate::natives::string_utils::native_format_debug;
+use aptos_native_interface::{
+    safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext, SafeNativeError,
+    SafeNativeResult,
 };
-use aptos_types::on_chain_config::{Features, TimedFeatures};
 use move_vm_runtime::native_functions::NativeFunction;
 #[allow(unused_imports)]
 use move_vm_types::{
@@ -23,7 +17,7 @@ use move_vm_types::{
     values::{Reference, Struct, Value},
 };
 use smallvec::{smallvec, SmallVec};
-use std::{collections::VecDeque, sync::Arc};
+use std::collections::VecDeque;
 
 /***************************************************************************************************
  * native fun print
@@ -31,7 +25,6 @@ use std::{collections::VecDeque, sync::Arc};
  **************************************************************************************************/
 #[inline]
 fn native_print(
-    _: &(),
     _: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -59,7 +52,6 @@ fn native_print(
 #[allow(unused_variables)]
 #[inline]
 fn native_stack_trace(
-    _: &(),
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     args: VecDeque<Value>,
@@ -79,7 +71,6 @@ fn native_stack_trace(
 
 #[inline]
 fn native_old_debug_print(
-    _: &(),
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -98,7 +89,6 @@ fn native_old_debug_print(
 
 #[inline]
 fn native_old_print_stacktrace(
-    _: &(),
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     args: VecDeque<Value>,
@@ -118,38 +108,15 @@ fn native_old_print_stacktrace(
  * module
  **************************************************************************************************/
 pub fn make_all(
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
     let natives = [
-        (
-            "native_print",
-            make_safe_native((), timed_features.clone(), features.clone(), native_print),
-        ),
-        (
-            "native_stack_trace",
-            make_safe_native(
-                (),
-                timed_features.clone(),
-                features.clone(),
-                native_stack_trace,
-            ),
-        ),
+        ("native_print", native_print as RawSafeNative),
+        ("native_stack_trace", native_stack_trace),
         // For re-playability on-chain we still implement the old versions of these functions
-        (
-            "print",
-            make_safe_native(
-                (),
-                timed_features.clone(),
-                features.clone(),
-                native_old_debug_print,
-            ),
-        ),
-        (
-            "print_stack_trace",
-            make_safe_native((), timed_features, features, native_old_print_stacktrace),
-        ),
+        ("print", native_old_debug_print),
+        ("print_stack_trace", native_old_print_stacktrace),
     ];
 
-    make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/src/natives/event.rs b/aptos-move/framework/src/natives/event.rs
index f47ff9ff18ac6..12ae6a038c648 100644
--- a/aptos-move/framework/src/natives/event.rs
+++ b/aptos-move/framework/src/natives/event.rs
@@ -1,19 +1,15 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{
-    natives::helpers::{
-        make_module_natives, make_safe_native, SafeNativeContext, SafeNativeError, SafeNativeResult,
-    },
-    safely_pop_arg,
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext, SafeNativeError,
+    SafeNativeResult,
 };
-use aptos_gas_algebra::{AbstractValueSize, InternalGasPerAbstractValueUnit};
-use aptos_types::on_chain_config::{Features, TimedFeatures};
-use move_core_types::gas_algebra::InternalGas;
 use move_vm_runtime::native_functions::NativeFunction;
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use smallvec::{smallvec, SmallVec};
-use std::{collections::VecDeque, sync::Arc};
+use std::collections::VecDeque;
 
 /***************************************************************************************************
  * native fun write_to_event_store
@@ -21,16 +17,8 @@ use std::{collections::VecDeque, sync::Arc};
  *   gas cost: base_cost
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct WriteToEventStoreGasParameters {
-    pub base: InternalGas,
-    pub per_abstract_value_unit: InternalGasPerAbstractValueUnit,
-}
-
 #[inline]
 fn native_write_to_event_store(
-    gas_params: &WriteToEventStoreGasParameters,
-    calc_abstract_val_size: impl FnOnce(&Value) -> AbstractValueSize,
     context: &mut SafeNativeContext,
     mut ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -45,7 +33,8 @@ fn native_write_to_event_store(
 
     // TODO(Gas): Get rid of abstract memory size
     context.charge(
-        gas_params.base + gas_params.per_abstract_value_unit * calc_abstract_val_size(&msg),
+        EVENT_WRITE_TO_EVENT_STORE_BASE
+            + EVENT_WRITE_TO_EVENT_STORE_PER_ABSTRACT_VALUE_UNIT * context.abs_val_size(&msg),
     )?;
 
     if !context.save_event(guid, seq_num, ty, msg)? {
@@ -55,43 +44,17 @@ fn native_write_to_event_store(
     Ok(smallvec![])
 }
 
-pub fn make_native_write_to_event_store(
-    calc_abstract_val_size: impl Fn(&Value) -> AbstractValueSize + Send + Sync + 'static,
-) -> impl Fn(
-    &WriteToEventStoreGasParameters,
-    &mut SafeNativeContext,
-    Vec<Type>,
-    VecDeque<Value>,
-) -> SafeNativeResult<SmallVec<[Value; 1]>> {
-    move |gas_params, context, ty_args, args| -> SafeNativeResult<SmallVec<[Value; 1]>> {
-        native_write_to_event_store(gas_params, &calc_abstract_val_size, context, ty_args, args)
-    }
-}
-
 /***************************************************************************************************
  * module
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub write_to_event_store: WriteToEventStoreGasParameters,
-}
-
 pub fn make_all(
-    gas_params: GasParameters,
-    calc_abstract_val_size: impl Fn(&Value) -> AbstractValueSize + Send + Sync + 'static,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
     let natives = [(
         "write_to_event_store",
-        make_safe_native(
-            gas_params.write_to_event_store,
-            timed_features,
-            features,
-            make_native_write_to_event_store(calc_abstract_val_size),
-        ),
+        native_write_to_event_store as RawSafeNative,
     )];
 
-    make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/src/natives/hash.rs b/aptos-move/framework/src/natives/hash.rs
index 8f9ea77538cb8..da91b3d8b2011 100644
--- a/aptos-move/framework/src/natives/hash.rs
+++ b/aptos-move/framework/src/natives/hash.rs
@@ -1,18 +1,18 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{
-    natives::helpers::{make_safe_native, SafeNativeContext, SafeNativeResult},
-    safely_assert_eq, safely_pop_arg,
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_assert_eq, safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext,
+    SafeNativeResult,
 };
-use aptos_types::on_chain_config::{Features, TimedFeatures};
 use move_core_types::gas_algebra::{InternalGas, InternalGasPerByte, NumBytes};
 use move_vm_runtime::native_functions::NativeFunction;
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use ripemd::Digest as OtherDigest;
 use sha2::Digest;
 use smallvec::{smallvec, SmallVec};
-use std::{collections::VecDeque, hash::Hasher, sync::Arc};
+use std::{collections::VecDeque, hash::Hasher};
 use tiny_keccak::{Hasher as KeccakHasher, Keccak};
 
 /***************************************************************************************************
@@ -21,14 +21,7 @@ use tiny_keccak::{Hasher as KeccakHasher, Keccak};
  *   gas cost: base_cost + unit_cost * data_length
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct SipHashGasParameters {
-    pub base: InternalGas,
-    pub per_byte: InternalGasPerByte,
-}
-
 fn native_sip_hash(
-    gas_params: &SipHashGasParameters,
     context: &mut SafeNativeContext,
     mut _ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -38,7 +31,7 @@ fn native_sip_hash(
 
     let bytes = safely_pop_arg!(args, Vec<u8>);
 
-    let cost = gas_params.base + gas_params.per_byte * NumBytes::new(bytes.len() as u64);
+    let cost = HASH_SIP_HASH_BASE + HASH_SIP_HASH_PER_BYTE * NumBytes::new(bytes.len() as u64);
     context.charge(cost)?;
 
     // SipHash of the serialized bytes
@@ -49,14 +42,7 @@ fn native_sip_hash(
     Ok(smallvec![Value::u64(hash)])
 }
 
-#[derive(Debug, Clone)]
-pub struct Keccak256HashGasParameters {
-    pub base: InternalGas,
-    pub per_byte: InternalGasPerByte,
-}
-
 fn native_keccak256(
-    gas_params: &Keccak256HashGasParameters,
     context: &mut SafeNativeContext,
     mut _ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -66,7 +52,7 @@ fn native_keccak256(
 
     let bytes = safely_pop_arg!(args, Vec<u8>);
 
-    let cost = gas_params.base + gas_params.per_byte * NumBytes::new(bytes.len() as u64);
+    let cost = HASH_KECCAK256_BASE + HASH_KECCAK256_PER_BYTE * NumBytes::new(bytes.len() as u64);
     context.charge(cost)?;
 
     let mut hasher = Keccak::v256();
@@ -77,14 +63,7 @@ fn native_keccak256(
     Ok(smallvec![Value::vector_u8(output)])
 }
 
-#[derive(Debug, Clone)]
-pub struct Sha2_512HashGasParameters {
-    pub base: InternalGas,
-    pub per_byte: InternalGasPerByte,
-}
-
 fn native_sha2_512(
-    gas_params: &Sha2_512HashGasParameters,
     context: &mut SafeNativeContext,
     mut _ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -94,7 +73,7 @@ fn native_sha2_512(
 
     let bytes = safely_pop_arg!(args, Vec<u8>);
 
-    let cost = gas_params.base + gas_params.per_byte * NumBytes::new(bytes.len() as u64);
+    let cost = HASH_SHA2_512_BASE + HASH_SHA2_512_PER_BYTE * NumBytes::new(bytes.len() as u64);
     context.charge(cost)?;
 
     let mut hasher = sha2::Sha512::new();
@@ -104,14 +83,7 @@ fn native_sha2_512(
     Ok(smallvec![Value::vector_u8(output)])
 }
 
-#[derive(Debug, Clone)]
-pub struct Sha3_512HashGasParameters {
-    pub base: InternalGas,
-    pub per_byte: InternalGasPerByte,
-}
-
 fn native_sha3_512(
-    gas_params: &Sha3_512HashGasParameters,
     context: &mut SafeNativeContext,
     mut _ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -121,7 +93,7 @@ fn native_sha3_512(
 
     let bytes = safely_pop_arg!(args, Vec<u8>);
 
-    let cost = gas_params.base + gas_params.per_byte * NumBytes::new(bytes.len() as u64);
+    let cost = HASH_SHA3_512_BASE + HASH_SHA3_512_PER_BYTE * NumBytes::new(bytes.len() as u64);
     context.charge(cost)?;
 
     let mut hasher = sha3::Sha3_512::new();
@@ -138,7 +110,6 @@ pub struct Blake2B256HashGasParameters {
 }
 
 fn native_blake2b_256(
-    gas_params: &Blake2B256HashGasParameters,
     context: &mut SafeNativeContext,
     mut _ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -148,7 +119,9 @@ fn native_blake2b_256(
 
     let bytes = safely_pop_arg!(args, Vec<u8>);
 
-    context.charge(gas_params.base + gas_params.per_byte * NumBytes::new(bytes.len() as u64))?;
+    context.charge(
+        HASH_BLAKE2B_256_BASE + HASH_BLAKE2B_256_PER_BYTE * NumBytes::new(bytes.len() as u64),
+    )?;
 
     let output = blake2_rfc::blake2b::blake2b(32, &[], &bytes)
         .as_bytes()
@@ -164,7 +137,6 @@ pub struct Ripemd160HashGasParameters {
 }
 
 fn native_ripemd160(
-    gas_params: &Ripemd160HashGasParameters,
     context: &mut SafeNativeContext,
     mut _ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -174,7 +146,7 @@ fn native_ripemd160(
 
     let bytes = safely_pop_arg!(args, Vec<u8>);
 
-    let cost = gas_params.base + gas_params.per_byte * NumBytes::new(bytes.len() as u64);
+    let cost = HASH_RIPEMD160_BASE + HASH_RIPEMD160_PER_BYTE * NumBytes::new(bytes.len() as u64);
     context.charge(cost)?;
 
     let mut hasher = ripemd::Ripemd160::new();
@@ -188,77 +160,17 @@ fn native_ripemd160(
  * module
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub sip_hash: SipHashGasParameters,
-    pub keccak256: Keccak256HashGasParameters,
-    pub sha2_512: Sha2_512HashGasParameters,
-    pub sha3_512: Sha3_512HashGasParameters,
-    pub ripemd160: Ripemd160HashGasParameters,
-    pub blake2b_256: Blake2B256HashGasParameters,
-}
-
 pub fn make_all(
-    gas_params: GasParameters,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
     let natives = [
-        (
-            "sip_hash",
-            make_safe_native(
-                gas_params.sip_hash,
-                timed_features.clone(),
-                features.clone(),
-                native_sip_hash,
-            ),
-        ),
-        (
-            "keccak256",
-            make_safe_native(
-                gas_params.keccak256,
-                timed_features.clone(),
-                features.clone(),
-                native_keccak256,
-            ),
-        ),
-        (
-            "sha2_512_internal",
-            make_safe_native(
-                gas_params.sha2_512,
-                timed_features.clone(),
-                features.clone(),
-                native_sha2_512,
-            ),
-        ),
-        (
-            "sha3_512_internal",
-            make_safe_native(
-                gas_params.sha3_512,
-                timed_features.clone(),
-                features.clone(),
-                native_sha3_512,
-            ),
-        ),
-        (
-            "ripemd160_internal",
-            make_safe_native(
-                gas_params.ripemd160,
-                timed_features.clone(),
-                features.clone(),
-                native_ripemd160,
-            ),
-        ),
-        (
-            "blake2b_256_internal",
-            make_safe_native(
-                gas_params.blake2b_256,
-                timed_features,
-                features,
-                native_blake2b_256,
-            ),
-        ),
+        ("sip_hash", native_sip_hash as RawSafeNative),
+        ("keccak256", native_keccak256),
+        ("sha2_512_internal", native_sha2_512),
+        ("sha3_512_internal", native_sha3_512),
+        ("ripemd160_internal", native_ripemd160),
+        ("blake2b_256_internal", native_blake2b_256),
     ];
 
-    crate::natives::helpers::make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/src/natives/helpers.rs b/aptos-move/framework/src/natives/helpers.rs
index db7c896c62398..1f337033b0080 100644
--- a/aptos-move/framework/src/natives/helpers.rs
+++ b/aptos-move/framework/src/natives/helpers.rs
@@ -1,282 +1,6 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use aptos_types::on_chain_config::{Features, TimedFeatureFlag, TimedFeatures};
-use move_binary_format::errors::{PartialVMError, PartialVMResult};
-use move_core_types::gas_algebra::InternalGas;
-use move_vm_runtime::native_functions::{NativeContext, NativeFunction};
-use move_vm_types::{
-    loaded_data::runtime_types::Type, natives::function::NativeResult, values::Value,
-};
-use smallvec::SmallVec;
-use std::{
-    collections::VecDeque,
-    ops::{Deref, DerefMut},
-    sync::Arc,
-};
-
-/// Used to pop a `Vec<Vec<u8>>` or `Vec<Struct>` argument off the stack in unsafe natives that return `PartialVMResult<T>`.
-#[macro_export]
-macro_rules! pop_vec_arg {
-    ($arguments:ident, $t:ty) => {{
-        // Replicating the code from pop_arg! here
-        use move_vm_types::natives::function::{PartialVMError, StatusCode};
-        let value_vec = match $arguments.pop_back().map(|v| v.value_as::<Vec<Value>>()) {
-            None => {
-                return Err(PartialVMError::new(
-                    StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR,
-                ))
-            }
-            Some(Err(e)) => return Err(e),
-            Some(Ok(v)) => v,
-        };
-
-        // Pop each Value from the popped Vec<Value>, cast it as a Vec<u8>, and push it to a Vec<Vec<u8>>
-        let mut vec_vec = vec![];
-        for value in value_vec {
-            let vec = match value.value_as::<$t>() {
-                Err(e) => return Err(e),
-                Ok(v) => v,
-            };
-            vec_vec.push(vec);
-        }
-
-        vec_vec
-    }};
-}
-
-/// Like `pop_vec_arg` but for safe natives that return `SafeNativeResult<T>`.
-/// (Duplicates code from above, unfortunately.)
-#[macro_export]
-macro_rules! safely_pop_vec_arg {
-    ($arguments:ident, $t:ty) => {{
-        // Replicating the code from pop_arg! here
-        use move_vm_types::natives::function::{PartialVMError, StatusCode};
-        let value_vec = match $arguments.pop_back().map(|v| v.value_as::<Vec<Value>>()) {
-            None => {
-                return Err($crate::natives::helpers::SafeNativeError::InvariantViolation(
-                    PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR)
-                ))
-            }
-            Some(Err(e)) => return Err($crate::natives::helpers::SafeNativeError::InvariantViolation(e)),
-            Some(Ok(v)) => v,
-        };
-
-        // Pop each Value from the popped Vec<Value>, cast it as a Vec<u8>, and push it to a Vec<Vec<u8>>
-        let mut vec_vec = vec![];
-        for value in value_vec {
-            let vec = match value.value_as::<$t>() {
-                Err(e) => return Err($crate::natives::helpers::SafeNativeError::InvariantViolation(e)),
-                Ok(v) => v,
-            };
-            vec_vec.push(vec);
-        }
-
-        vec_vec
-    }};
-}
-
-pub fn make_module_natives(
-    natives: impl IntoIterator<Item = (impl Into<String>, NativeFunction)>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
-    natives
-        .into_iter()
-        .map(|(func_name, func)| (func_name.into(), func))
-}
-
-#[allow(unused)]
-/// Wraps a test-only native function inside an Arc<UnboxedNativeFunction>.
-pub fn make_test_only_native_from_func(
-    func: fn(&mut NativeContext, Vec<Type>, VecDeque<Value>) -> PartialVMResult<NativeResult>,
-) -> NativeFunction {
-    Arc::new(func)
-}
-
-/// Like `pop_arg!` but for safe natives that return `SafeNativeResult<T>`. Will return a
-/// `SafeNativeError::InvariantViolation(UNKNOWN_INVARIANT_VIOLATION_ERROR)` when there aren't
-/// enough arguments on the stack.
-#[macro_export]
-macro_rules! safely_pop_arg {
-    ($args:ident, $t:ty) => {{
-        use move_vm_types::natives::function::{PartialVMError, StatusCode};
-        match $args.pop_back() {
-            Some(val) => match val.value_as::<$t>() {
-                Ok(v) => v,
-                Err(e) => {
-                    return Err($crate::natives::helpers::SafeNativeError::InvariantViolation(e))
-                },
-            },
-            None => {
-                return Err(
-                    $crate::natives::helpers::SafeNativeError::InvariantViolation(
-                        PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR),
-                    ),
-                )
-            },
-        }
-    }};
-}
-
-/// Like `assert_eq!` but for safe natives that return `SafeNativeResult<T>`. Instead of panicking,
-/// will return a `SafeNativeError::InvariantViolation(UNKNOWN_INVARIANT_VIOLATION_ERROR)`.
-#[macro_export]
-macro_rules! safely_assert_eq {
-    ($left:expr, $right:expr $(,)?) => {{
-        use move_vm_types::natives::function::{PartialVMError, StatusCode};
-        match (&$left, &$right) {
-            (left_val, right_val) => {
-                if !(*left_val == *right_val) {
-                    return Err(
-                        $crate::natives::helpers::SafeNativeError::InvariantViolation(
-                            PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR),
-                        ),
-                    );
-                }
-            },
-        }
-    }};
-}
-
-/// Pops a `Type` argument off the type argument stack inside a safe native. Returns a
-/// `SafeNativeError::InvariantViolation(UNKNOWN_INVARIANT_VIOLATION_ERROR)` in case there are not
-/// enough arguments on the stack.
-///
-/// NOTE: Expects as its argument an object that has a `fn pop(&self) -> Option<_>` method (e.g., a `Vec<_>`)
-#[macro_export]
-macro_rules! safely_pop_type_arg {
-    ($ty_args:ident) => {{
-        use move_vm_types::natives::function::{PartialVMError, StatusCode};
-        match $ty_args.pop() {
-            Some(ty) => ty,
-            None => {
-                return Err(
-                    $crate::natives::helpers::SafeNativeError::InvariantViolation(
-                        PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR),
-                    ),
-                )
-            },
-        }
-    }};
-}
-
-#[allow(unused)]
-pub struct SafeNativeContext<'a, 'b, 'c, 'd> {
-    timed_features: &'c TimedFeatures,
-    features: &'c Features,
-    inner: &'c mut NativeContext<'a, 'b, 'd>,
-
-    gas_budget: InternalGas,
-    gas_used: InternalGas,
-}
-
-impl<'a, 'b, 'c, 'd> Deref for SafeNativeContext<'a, 'b, 'c, 'd> {
-    type Target = NativeContext<'a, 'b, 'd>;
-
-    fn deref(&self) -> &Self::Target {
-        self.inner
-    }
-}
-
-impl<'a, 'b, 'c, 'd> DerefMut for SafeNativeContext<'a, 'b, 'c, 'd> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        self.inner
-    }
-}
-
-impl<'a, 'b, 'c, 'd> SafeNativeContext<'a, 'b, 'c, 'd> {
-    /// Always remember: first charge gas, then execute!
-    ///
-    /// In other words, this function **MUST** always be called **BEFORE** executing **any**
-    /// gas-metered operation or library call within a native function.
-    #[must_use = "must always propagate the error returned by this function to the native function that called it using the ? operator"]
-    pub fn charge(&mut self, amount: InternalGas) -> SafeNativeResult<()> {
-        self.gas_used += amount;
-
-        if self.gas_used > self.gas_budget {
-            Err(SafeNativeError::OutOfGas)
-        } else {
-            Ok(())
-        }
-    }
-
-    //pub fn charge_abstract(
-    //    &mut self,
-    //    abstract_amount: impl GasExpression<Unit = InternalGasUnit>,
-    //) -> SafeNativeResult<()> {
-    //    unimplemented!()
-    //}
-
-    pub fn get_feature_flags(&self) -> &Features {
-        self.features.deref()
-    }
-
-    pub fn timed_feature_enabled(&self, flag: TimedFeatureFlag) -> bool {
-        self.timed_features.is_enabled(flag)
-    }
-}
-
-#[allow(unused)]
-pub enum SafeNativeError {
-    Abort { abort_code: u64 },
-    OutOfGas,
-    InvariantViolation(PartialVMError),
-}
-
-/// Allows us to keep using the `?` operator on function calls that return `PartialVMResult` inside safe natives.
-impl From<PartialVMError> for SafeNativeError {
-    fn from(e: PartialVMError) -> Self {
-        SafeNativeError::InvariantViolation(e)
-    }
-}
-
-pub type SafeNativeResult<T> = Result<T, SafeNativeError>;
-
-pub fn make_safe_native<G>(
-    gas_params: G,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-    func: impl Fn(
-            &G,
-            &mut SafeNativeContext,
-            Vec<Type>,
-            VecDeque<Value>,
-        ) -> SafeNativeResult<SmallVec<[Value; 1]>>
-        + Sync
-        + Send
-        + 'static,
-) -> NativeFunction
-where
-    G: Send + Sync + 'static,
-{
-    let closure = move |context: &mut NativeContext, ty_args, args| {
-        use SafeNativeError::*;
-
-        let gas_budget = context.gas_balance();
-
-        let mut context = SafeNativeContext {
-            timed_features: &timed_features,
-            features: &features,
-            inner: context,
-
-            gas_budget,
-            gas_used: 0.into(),
-        };
-
-        let res = func(&gas_params, &mut context, ty_args, args);
-
-        match res {
-            Ok(ret_vals) => Ok(NativeResult::ok(context.gas_used, ret_vals)),
-            Err(err) => match err {
-                Abort { abort_code } => Ok(NativeResult::err(context.gas_used, abort_code)),
-                OutOfGas => Ok(NativeResult::out_of_gas(context.gas_used)),
-                InvariantViolation(err) => Err(err),
-            },
-        }
-    };
-
-    Arc::new(closure)
-}
-
 /// For all $n > 0$, returns $\floor{\log_2{n}}$, contained within a `Some`.
 /// For $n = 0$, returns `None`.
 pub fn log2_floor(n: usize) -> Option<usize> {
diff --git a/aptos-move/framework/src/natives/mod.rs b/aptos-move/framework/src/natives/mod.rs
index f4b96f9379791..3cecf2a795831 100644
--- a/aptos-move/framework/src/natives/mod.rs
+++ b/aptos-move/framework/src/natives/mod.rs
@@ -21,13 +21,10 @@ pub mod util;
 
 use crate::natives::cryptography::multi_ed25519;
 use aggregator_natives::{aggregator, aggregator_factory};
-use aptos_gas_algebra::AbstractValueSize;
-use aptos_types::on_chain_config::{Features, TimedFeatures};
+use aptos_native_interface::SafeNativeBuilder;
 use cryptography::ed25519;
 use move_core_types::{account_address::AccountAddress, identifier::Identifier};
 use move_vm_runtime::native_functions::{make_table_from_iter, NativeFunctionTable};
-use move_vm_types::values::Value;
-use std::sync::Arc;
 
 pub mod status {
     // Failure in parsing a struct type tag
@@ -36,250 +33,9 @@ pub mod status {
     pub const NFE_UNABLE_TO_PARSE_ADDRESS: u64 = 0x2;
 }
 
-/// All the gas parameters required by the aptos-framework natives.
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub account: account::GasParameters,
-    pub algebra: cryptography::algebra::gas::GasParameters,
-    pub ed25519: ed25519::GasParameters,
-    pub bls12381: cryptography::bls12381::GasParameters,
-    pub secp256k1: cryptography::secp256k1::GasParameters,
-    pub ristretto255: cryptography::ristretto255::GasParameters,
-    pub hash: hash::GasParameters,
-    pub type_info: type_info::GasParameters,
-    pub util: util::GasParameters,
-    pub transaction_context: transaction_context::GasParameters,
-    pub code: code::GasParameters,
-    pub event: event::GasParameters,
-    pub state_storage: state_storage::GasParameters,
-    pub aggregator: aggregator::GasParameters,
-    pub aggregator_factory: aggregator_factory::GasParameters,
-    pub object: object::GasParameters,
-    pub string_utils: string_utils::GasParameters,
-}
-
-impl GasParameters {
-    pub fn zeros() -> Self {
-        Self {
-            account: account::GasParameters {
-                create_address: account::CreateAddressGasParameters { base: 0.into() },
-                create_signer: create_signer::CreateSignerGasParameters { base: 0.into() },
-            },
-            bls12381: cryptography::bls12381::GasParameters {
-                base: 0.into(),
-                per_pubkey_deserialize: 0.into(),
-                per_pubkey_aggregate: 0.into(),
-                per_pubkey_subgroup_check: 0.into(),
-                per_sig_deserialize: 0.into(),
-                per_sig_aggregate: 0.into(),
-                per_sig_subgroup_check: 0.into(),
-                per_sig_verify: 0.into(),
-                per_pop_verify: 0.into(),
-                per_pairing: 0.into(),
-                per_msg_hashing: 0.into(),
-                per_byte_hashing: 0.into(),
-            },
-            algebra: cryptography::algebra::gas::GasParameters {
-                ark_bls12_381_fr_serialize: 0.into(),
-                ark_bls12_381_fr_deser: 0.into(),
-                ark_bls12_381_fr_from_u64: 0.into(),
-                ark_bls12_381_fr_neg: 0.into(),
-                ark_bls12_381_fr_add: 0.into(),
-                ark_bls12_381_fr_sub: 0.into(),
-                ark_bls12_381_fr_mul: 0.into(),
-                ark_bls12_381_fr_inv: 0.into(),
-                ark_bls12_381_fr_div: 0.into(),
-                ark_bls12_381_fr_eq: 0.into(),
-                ark_bls12_381_g1_proj_infinity: 0.into(),
-                ark_bls12_381_g1_proj_generator: 0.into(),
-                ark_bls12_381_g1_affine_serialize_uncomp: 0.into(),
-                ark_bls12_381_g1_affine_deser_uncomp: 0.into(),
-                ark_bls12_381_g1_affine_serialize_comp: 0.into(),
-                ark_bls12_381_g1_affine_deser_comp: 0.into(),
-                ark_bls12_381_g1_proj_to_affine: 0.into(),
-                ark_bls12_381_g1_proj_neg: 0.into(),
-                ark_bls12_381_g1_proj_add: 0.into(),
-                ark_bls12_381_g1_proj_sub: 0.into(),
-                ark_bls12_381_g1_proj_scalar_mul: 0.into(),
-                ark_bls12_381_g1_proj_eq: 0.into(),
-                ark_bls12_381_g2_proj_infinity: 0.into(),
-                ark_bls12_381_g2_proj_generator: 0.into(),
-                ark_bls12_381_g2_affine_serialize_uncomp: 0.into(),
-                ark_bls12_381_g2_affine_deser_uncomp: 0.into(),
-                ark_bls12_381_g2_affine_serialize_comp: 0.into(),
-                ark_bls12_381_g2_affine_deser_comp: 0.into(),
-                ark_bls12_381_g2_proj_to_affine: 0.into(),
-                ark_bls12_381_g2_proj_neg: 0.into(),
-                ark_bls12_381_g2_proj_add: 0.into(),
-                ark_bls12_381_g2_proj_sub: 0.into(),
-                ark_bls12_381_g2_proj_scalar_mul: 0.into(),
-                ark_bls12_381_g2_proj_eq: 0.into(),
-                ark_bls12_381_fq12_serialize: 0.into(),
-                ark_bls12_381_fq12_eq: 0.into(),
-                ark_bls12_381_fq12_one: 0.into(),
-                ark_bls12_381_fq12_pow_u256: 0.into(),
-                ark_bls12_381_fq12_clone: 0.into(),
-                ark_bls12_381_fq12_deser: 0.into(),
-                ark_bls12_381_fq12_mul: 0.into(),
-                ark_bls12_381_fq12_sub: 0.into(),
-                ark_bls12_381_fq12_inv: 0.into(),
-                ark_bls12_381_fq12_square: 0.into(),
-                ark_bls12_381_g1_proj_double: 0.into(),
-                ark_bls12_381_g2_proj_double: 0.into(),
-                ark_bls12_381_fq12_div: 0.into(),
-                ark_bls12_381_fq12_add: 0.into(),
-                ark_bls12_381_fq12_from_u64: 0.into(),
-                ark_bls12_381_fq12_neg: 0.into(),
-                ark_bls12_381_fr_square: 0.into(),
-                ark_bls12_381_fr_one: 0.into(),
-                ark_bls12_381_fr_zero: 0.into(),
-                ark_bls12_381_fq12_zero: 0.into(),
-                ark_bls12_381_pairing: 0.into(),
-                ark_bls12_381_multi_pairing_base: 0.into(),
-                ark_bls12_381_multi_pairing_per_pair: 0.into(),
-                ark_h2c_bls12381g1_xmd_sha256_sswu_base: 0.into(),
-                ark_h2c_bls12381g1_xmd_sha256_sswu_per_msg_byte: 0.into(),
-                ark_h2c_bls12381g2_xmd_sha256_sswu_base: 0.into(),
-                ark_h2c_bls12381g2_xmd_sha256_sswu_per_msg_byte: 0.into(),
-            },
-            ed25519: ed25519::GasParameters {
-                base: 0.into(),
-                per_pubkey_deserialize: 0.into(),
-                per_pubkey_small_order_check: 0.into(),
-                per_sig_deserialize: 0.into(),
-                per_sig_strict_verify: 0.into(),
-                per_msg_hashing_base: 0.into(),
-                per_msg_byte_hashing: 0.into(),
-            },
-            secp256k1: cryptography::secp256k1::GasParameters {
-                base: 0.into(),
-                ecdsa_recover: 0.into(),
-            },
-            ristretto255: cryptography::ristretto255::GasParameters {
-                basepoint_mul: 0.into(),
-                basepoint_double_mul: 0.into(),
-                point_add: 0.into(),
-                point_compress: 0.into(),
-                point_decompress: 0.into(),
-                point_equals: 0.into(),
-                point_from_64_uniform_bytes: 0.into(),
-                point_identity: 0.into(),
-                point_mul: 0.into(),
-                point_neg: 0.into(),
-                point_sub: 0.into(),
-                scalar_add: 0.into(),
-                scalar_reduced_from_32_bytes: 0.into(),
-                scalar_uniform_from_64_bytes: 0.into(),
-                scalar_from_u128: 0.into(),
-                scalar_from_u64: 0.into(),
-                scalar_invert: 0.into(),
-                scalar_is_canonical: 0.into(),
-                scalar_mul: 0.into(),
-                scalar_neg: 0.into(),
-                sha512_per_byte: 0.into(),
-                sha512_per_hash: 0.into(),
-                scalar_sub: 0.into(),
-                point_parse_arg: 0.into(),
-                scalar_parse_arg: 0.into(),
-            },
-            hash: hash::GasParameters {
-                sip_hash: hash::SipHashGasParameters {
-                    base: 0.into(),
-                    per_byte: 0.into(),
-                },
-                keccak256: hash::Keccak256HashGasParameters {
-                    base: 0.into(),
-                    per_byte: 0.into(),
-                },
-                sha2_512: hash::Sha2_512HashGasParameters {
-                    base: 0.into(),
-                    per_byte: 0.into(),
-                },
-                sha3_512: hash::Sha3_512HashGasParameters {
-                    base: 0.into(),
-                    per_byte: 0.into(),
-                },
-                ripemd160: hash::Ripemd160HashGasParameters {
-                    base: 0.into(),
-                    per_byte: 0.into(),
-                },
-                blake2b_256: hash::Blake2B256HashGasParameters {
-                    base: 0.into(),
-                    per_byte: 0.into(),
-                },
-            },
-            type_info: type_info::GasParameters {
-                type_of: type_info::TypeOfGasParameters {
-                    base: 0.into(),
-                    per_byte_in_str: 0.into(),
-                },
-                type_name: type_info::TypeNameGasParameters {
-                    base: 0.into(),
-                    per_byte_in_str: 0.into(),
-                },
-                chain_id: type_info::ChainIdGasParameters { base: 0.into() },
-            },
-            util: util::GasParameters {
-                from_bytes: util::FromBytesGasParameters {
-                    base: 0.into(),
-                    per_byte: 0.into(),
-                },
-            },
-            transaction_context: transaction_context::GasParameters {
-                get_txn_hash: transaction_context::GetTxnHashGasParameters { base: 0.into() },
-                get_script_hash: transaction_context::GetScriptHashGasParameters { base: 0.into() },
-                generate_unique_address: transaction_context::GenerateUniqueAddressGasParameters {
-                    base: 0.into(),
-                },
-            },
-            code: code::GasParameters {
-                request_publish: code::RequestPublishGasParameters {
-                    base: 0.into(),
-                    per_byte: 0.into(),
-                },
-            },
-            event: event::GasParameters {
-                write_to_event_store: event::WriteToEventStoreGasParameters {
-                    base: 0.into(),
-                    per_abstract_value_unit: 0.into(),
-                },
-            },
-            state_storage: state_storage::GasParameters {
-                get_usage: state_storage::GetUsageGasParameters {
-                    base_cost: 0.into(),
-                },
-            },
-            aggregator: aggregator::GasParameters {
-                add: aggregator::AddGasParameters { base: 0.into() },
-                read: aggregator::ReadGasParameters { base: 0.into() },
-                sub: aggregator::SubGasParameters { base: 0.into() },
-                destroy: aggregator::DestroyGasParameters { base: 0.into() },
-            },
-            aggregator_factory: aggregator_factory::GasParameters {
-                new_aggregator: aggregator_factory::NewAggregatorGasParameters { base: 0.into() },
-            },
-            object: object::GasParameters {
-                exists_at: object::ExistsAtGasParameters {
-                    base: 0.into(),
-                    per_byte_loaded: 0.into(),
-                    per_item_loaded: 0.into(),
-                },
-            },
-            string_utils: string_utils::GasParameters {
-                base: 0.into(),
-                per_byte: 0.into(),
-            },
-        }
-    }
-}
-
 pub fn all_natives(
     framework_addr: AccountAddress,
-    move_gas_params: aptos_move_stdlib::natives::GasParameters,
-    gas_params: GasParameters,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-    calc_abstract_val_size: impl Fn(&Value) -> AbstractValueSize + Send + Sync + 'static,
+    builder: &SafeNativeBuilder,
 ) -> NativeFunctionTable {
     let mut natives = vec![];
 
@@ -291,156 +47,34 @@ pub fn all_natives(
         };
     }
 
-    add_natives_from_module!(
-        "account",
-        account::make_all(
-            gas_params.account.clone(),
-            timed_features.clone(),
-            features.clone()
-        )
-    );
-    add_natives_from_module!(
-        "create_signer",
-        create_signer::make_all(
-            gas_params.account.create_signer.clone(),
-            timed_features.clone(),
-            features.clone()
-        )
-    );
-    add_natives_from_module!(
-        "ed25519",
-        ed25519::make_all(
-            gas_params.ed25519.clone(),
-            timed_features.clone(),
-            features.clone()
-        )
-    );
-    add_natives_from_module!(
-        "crypto_algebra",
-        cryptography::algebra::make_all(
-            move_gas_params,
-            gas_params.algebra,
-            timed_features.clone(),
-            features.clone()
-        )
-    );
-    add_natives_from_module!(
-        "genesis",
-        create_signer::make_all(
-            gas_params.account.create_signer,
-            timed_features.clone(),
-            features.clone()
-        )
-    );
-    add_natives_from_module!(
-        "multi_ed25519",
-        multi_ed25519::make_all(gas_params.ed25519, timed_features.clone(), features.clone())
-    );
-    add_natives_from_module!(
-        "bls12381",
-        cryptography::bls12381::make_all(
-            gas_params.bls12381,
-            timed_features.clone(),
-            features.clone()
-        )
-    );
-    add_natives_from_module!(
-        "secp256k1",
-        cryptography::secp256k1::make_all(
-            gas_params.secp256k1,
-            timed_features.clone(),
-            features.clone()
-        )
-    );
-    add_natives_from_module!(
-        "aptos_hash",
-        hash::make_all(gas_params.hash, timed_features.clone(), features.clone())
-    );
+    add_natives_from_module!("account", account::make_all(builder));
+    add_natives_from_module!("create_signer", create_signer::make_all(builder));
+    add_natives_from_module!("ed25519", ed25519::make_all(builder));
+    add_natives_from_module!("crypto_algebra", cryptography::algebra::make_all(builder));
+    add_natives_from_module!("genesis", create_signer::make_all(builder));
+    add_natives_from_module!("multi_ed25519", multi_ed25519::make_all(builder));
+    add_natives_from_module!("bls12381", cryptography::bls12381::make_all(builder));
+    add_natives_from_module!("secp256k1", cryptography::secp256k1::make_all(builder));
+    add_natives_from_module!("aptos_hash", hash::make_all(builder));
     add_natives_from_module!(
         "ristretto255",
-        cryptography::ristretto255::make_all(
-            gas_params.ristretto255,
-            timed_features.clone(),
-            features.clone()
-        )
-    );
-    add_natives_from_module!(
-        "type_info",
-        type_info::make_all(
-            gas_params.type_info,
-            timed_features.clone(),
-            features.clone()
-        )
-    );
-    add_natives_from_module!(
-        "util",
-        util::make_all(
-            gas_params.util.clone(),
-            timed_features.clone(),
-            features.clone()
-        )
-    );
-    add_natives_from_module!(
-        "from_bcs",
-        util::make_all(gas_params.util, timed_features.clone(), features.clone())
+        cryptography::ristretto255::make_all(builder)
     );
+    add_natives_from_module!("type_info", type_info::make_all(builder));
+    add_natives_from_module!("util", util::make_all(builder));
+    add_natives_from_module!("from_bcs", util::make_all(builder));
     add_natives_from_module!(
         "transaction_context",
-        transaction_context::make_all(
-            gas_params.transaction_context,
-            timed_features.clone(),
-            features.clone()
-        )
-    );
-    add_natives_from_module!(
-        "code",
-        code::make_all(gas_params.code, timed_features.clone(), features.clone())
-    );
-    add_natives_from_module!(
-        "event",
-        event::make_all(
-            gas_params.event,
-            calc_abstract_val_size,
-            timed_features.clone(),
-            features.clone()
-        )
-    );
-    add_natives_from_module!(
-        "state_storage",
-        state_storage::make_all(
-            gas_params.state_storage,
-            timed_features.clone(),
-            features.clone()
-        )
-    );
-    add_natives_from_module!(
-        "aggregator",
-        aggregator::make_all(
-            gas_params.aggregator,
-            timed_features.clone(),
-            features.clone()
-        )
-    );
-    add_natives_from_module!(
-        "aggregator_factory",
-        aggregator_factory::make_all(
-            gas_params.aggregator_factory,
-            timed_features.clone(),
-            features.clone()
-        )
-    );
-    add_natives_from_module!(
-        "object",
-        object::make_all(gas_params.object, timed_features.clone(), features.clone())
-    );
-    add_natives_from_module!(
-        "debug",
-        debug::make_all(timed_features.clone(), features.clone())
-    );
-    add_natives_from_module!(
-        "string_utils",
-        string_utils::make_all(gas_params.string_utils, timed_features, features)
-    );
+        transaction_context::make_all(builder)
+    );
+    add_natives_from_module!("code", code::make_all(builder));
+    add_natives_from_module!("event", event::make_all(builder));
+    add_natives_from_module!("state_storage", state_storage::make_all(builder));
+    add_natives_from_module!("aggregator", aggregator::make_all(builder));
+    add_natives_from_module!("aggregator_factory", aggregator_factory::make_all(builder));
+    add_natives_from_module!("object", object::make_all(builder));
+    add_natives_from_module!("debug", debug::make_all(builder));
+    add_natives_from_module!("string_utils", string_utils::make_all(builder));
 
     make_table_from_iter(framework_addr, natives)
 }
diff --git a/aptos-move/framework/src/natives/object.rs b/aptos-move/framework/src/natives/object.rs
index 169e25ec52b2b..4e251d475c827 100644
--- a/aptos-move/framework/src/natives/object.rs
+++ b/aptos-move/framework/src/natives/object.rs
@@ -1,11 +1,11 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{
-    natives::helpers::{make_safe_native, SafeNativeContext, SafeNativeResult},
-    safely_assert_eq, safely_pop_arg,
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_assert_eq, safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext,
+    SafeNativeResult,
 };
-use aptos_types::on_chain_config::{Features, TimedFeatures};
 use move_core_types::{
     account_address::AccountAddress,
     gas_algebra::{InternalGas, InternalGasPerByte},
@@ -16,7 +16,7 @@ use move_vm_types::{
     loaded_data::runtime_types::Type, natives::function::PartialVMError, values::Value,
 };
 use smallvec::{smallvec, SmallVec};
-use std::{collections::VecDeque, sync::Arc};
+use std::collections::VecDeque;
 
 /***************************************************************************************************
  * native exists_at<T>
@@ -32,7 +32,6 @@ pub struct ExistsAtGasParameters {
 }
 
 fn native_exists_at(
-    gas_params: &ExistsAtGasParameters,
     context: &mut SafeNativeContext,
     mut ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -43,7 +42,7 @@ fn native_exists_at(
     let type_ = ty_args.pop().unwrap();
     let address = safely_pop_arg!(args, AccountAddress);
 
-    context.charge(gas_params.base)?;
+    context.charge(OBJECT_EXISTS_AT_BASE)?;
 
     let (exists, num_bytes) = context.exists_at(address, &type_).map_err(|err| {
         PartialVMError::new(StatusCode::VM_EXTENSION_ERROR).with_message(format!(
@@ -53,7 +52,9 @@ fn native_exists_at(
     })?;
 
     if let Some(num_bytes) = num_bytes {
-        context.charge(gas_params.per_item_loaded + num_bytes * gas_params.per_byte_loaded)?;
+        context.charge(
+            OBJECT_EXISTS_AT_PER_ITEM_LOADED + OBJECT_EXISTS_AT_PER_BYTE_LOADED * num_bytes,
+        )?;
     }
 
     Ok(smallvec![Value::bool(exists)])
@@ -63,25 +64,10 @@ fn native_exists_at(
  * module
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub exists_at: ExistsAtGasParameters,
-}
-
 pub fn make_all(
-    gas_params: GasParameters,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
-    let natives = [(
-        "exists_at",
-        make_safe_native(
-            gas_params.exists_at,
-            timed_features,
-            features,
-            native_exists_at,
-        ),
-    )];
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
+    let natives = [("exists_at", native_exists_at as RawSafeNative)];
 
-    crate::natives::helpers::make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/src/natives/state_storage.rs b/aptos-move/framework/src/natives/state_storage.rs
index 49bf77131b564..dd7c267843a10 100644
--- a/aptos-move/framework/src/natives/state_storage.rs
+++ b/aptos-move/framework/src/natives/state_storage.rs
@@ -1,22 +1,20 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::natives::helpers::{make_safe_native, SafeNativeContext, SafeNativeResult};
-use aptos_types::{
-    on_chain_config::{Features, TimedFeatures},
-    state_store::state_storage_usage::StateStorageUsage,
-    vm_status::StatusCode,
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    RawSafeNative, SafeNativeBuilder, SafeNativeContext, SafeNativeResult,
 };
+use aptos_types::{state_store::state_storage_usage::StateStorageUsage, vm_status::StatusCode};
 use better_any::{Tid, TidAble};
 use move_binary_format::errors::PartialVMError;
-use move_core_types::gas_algebra::InternalGas;
 use move_vm_runtime::native_functions::NativeFunction;
 use move_vm_types::{
     loaded_data::runtime_types::Type,
     values::{Struct, Value},
 };
 use smallvec::{smallvec, SmallVec};
-use std::{collections::VecDeque, sync::Arc};
+use std::collections::VecDeque;
 
 /// Ability to reveal the state storage utilization info.
 pub trait StateStorageUsageResolver {
@@ -41,17 +39,11 @@ impl<'a> NativeStateStorageContext<'a> {
  *   gas cost: base_cost
  *
  **************************************************************************************************/
-#[derive(Clone, Debug)]
-pub struct GetUsageGasParameters {
-    pub base_cost: InternalGas,
-}
-
 /// Warning: the result returned is based on the base state view held by the
 /// VM for the entire block or chunk of transactions, it's only deterministic
 /// if called from the first transaction of the block because the execution layer
 /// guarantees a fresh state view then.
 fn native_get_usage(
-    gas_params: &GetUsageGasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     _args: VecDeque<Value>,
@@ -59,7 +51,7 @@ fn native_get_usage(
     assert!(_ty_args.is_empty());
     assert!(_args.is_empty());
 
-    context.charge(gas_params.base_cost)?;
+    context.charge(STATE_STORAGE_GET_USAGE_BASE_COST)?;
 
     let ctx = context.extensions().get::<NativeStateStorageContext>();
     let usage = ctx.resolver.get_state_storage_usage().map_err(|err| {
@@ -77,25 +69,13 @@ fn native_get_usage(
  * module
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub get_usage: GetUsageGasParameters,
-}
-
 pub fn make_all(
-    gas_params: GasParameters,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
     let natives = [(
         "get_state_storage_usage_only_at_epoch_beginning",
-        make_safe_native(
-            gas_params.get_usage,
-            timed_features,
-            features,
-            native_get_usage,
-        ),
+        native_get_usage as RawSafeNative,
     )];
 
-    crate::natives::helpers::make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/src/natives/string_utils.rs b/aptos-move/framework/src/natives/string_utils.rs
index 1c2cf0b8aa06c..d5609a8b32564 100644
--- a/aptos-move/framework/src/natives/string_utils.rs
+++ b/aptos-move/framework/src/natives/string_utils.rs
@@ -1,15 +1,15 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{
-    natives::helpers::{make_safe_native, SafeNativeContext, SafeNativeError, SafeNativeResult},
-    safely_pop_arg,
+use aptos_gas_algebra::NumBytes;
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext, SafeNativeError,
+    SafeNativeResult,
 };
-use aptos_types::on_chain_config::{Features, TimedFeatures};
 use ark_std::iterable::Iterable;
 use move_core_types::{
     account_address::AccountAddress,
-    gas_algebra::{GasQuantity, InternalGas},
     language_storage::TypeTag,
     u256,
     value::{MoveFieldLayout, MoveStructLayout, MoveTypeLayout},
@@ -20,12 +20,11 @@ use move_vm_types::{
     values::{Reference, Struct, Value, Vector, VectorRef},
 };
 use smallvec::{smallvec, SmallVec};
-use std::{collections::VecDeque, fmt::Write, ops::Deref, sync::Arc};
+use std::{collections::VecDeque, fmt::Write, ops::Deref};
 
 struct FormatContext<'a, 'b, 'c, 'd, 'e> {
     context: &'d mut SafeNativeContext<'a, 'b, 'c, 'e>,
-    base_gas: InternalGas,
-    per_byte_gas: InternalGas,
+    should_charge_gas: bool,
     max_depth: usize,
     max_len: usize,
     type_tag: bool,
@@ -127,7 +126,9 @@ fn native_format_impl(
     depth: usize,
     out: &mut String,
 ) -> SafeNativeResult<()> {
-    context.context.charge(context.base_gas)?;
+    if context.should_charge_gas {
+        context.context.charge(STRING_UTILS_BASE)?;
+    }
     let mut suffix = "";
     match layout {
         MoveTypeLayout::Bool => {
@@ -207,9 +208,11 @@ fn native_format_impl(
                 && type_.address == AccountAddress::ONE
             {
                 let v = strct.unpack()?.next().unwrap().value_as::<Vec<u8>>()?;
-                context
-                    .context
-                    .charge(GasQuantity::from(v.len() as u64) * context.per_byte_gas)?;
+                if context.should_charge_gas {
+                    context
+                        .context
+                        .charge(STRING_UTILS_PER_BYTE * NumBytes::new(v.len() as u64))?;
+                }
                 write!(
                     out,
                     "\"{}\"",
@@ -299,8 +302,7 @@ pub(crate) fn native_format_debug(
     let layout = context.deref().type_to_fully_annotated_layout(ty)?.unwrap();
     let mut format_context = FormatContext {
         context,
-        base_gas: 0.into(),
-        per_byte_gas: 0.into(),
+        should_charge_gas: false,
         max_depth: usize::MAX,
         max_len: usize::MAX,
         type_tag: true,
@@ -314,7 +316,6 @@ pub(crate) fn native_format_debug(
 }
 
 fn native_format(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -333,8 +334,7 @@ fn native_format(
     let mut out = String::new();
     let mut format_context = FormatContext {
         context,
-        base_gas: gas_params.base,
-        per_byte_gas: gas_params.per_byte,
+        should_charge_gas: true,
         max_depth: usize::MAX,
         max_len: usize::MAX,
         type_tag,
@@ -348,7 +348,6 @@ fn native_format(
 }
 
 fn native_format_list(
-    gas_params: &GasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut arguments: VecDeque<Value>,
@@ -371,7 +370,7 @@ fn native_format_list(
         abort_code: invalid_fmt,
     })?;
 
-    context.charge(gas_params.per_byte * GasQuantity::from(fmt.len() as u64))?;
+    context.charge(STRING_UTILS_PER_BYTE * NumBytes::new(fmt.len() as u64))?;
 
     let match_list_ty = |context: &mut SafeNativeContext, list_ty, name| {
         if let TypeTag::Struct(struct_tag) = context
@@ -419,8 +418,7 @@ fn native_format_list(
                     .unwrap();
                 let mut format_context = FormatContext {
                     context,
-                    base_gas: gas_params.base,
-                    per_byte_gas: gas_params.per_byte,
+                    should_charge_gas: true,
                     max_depth: usize::MAX,
                     max_len: usize::MAX,
                     type_tag: true,
@@ -462,32 +460,13 @@ fn native_format_list(
     Ok(smallvec![move_str])
 }
 
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub base: InternalGas,
-    pub per_byte: InternalGas,
-}
-
 pub fn make_all(
-    gas_param: GasParameters,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
     let natives = [
-        (
-            "native_format",
-            make_safe_native(
-                gas_param.clone(),
-                timed_features.clone(),
-                features.clone(),
-                native_format,
-            ),
-        ),
-        (
-            "native_format_list",
-            make_safe_native(gas_param, timed_features, features, native_format_list),
-        ),
+        ("native_format", native_format as RawSafeNative),
+        ("native_format_list", native_format_list),
     ];
 
-    crate::natives::helpers::make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/src/natives/transaction_context.rs b/aptos-move/framework/src/natives/transaction_context.rs
index 44afefa15e33d..05fcc84d6503b 100644
--- a/aptos-move/framework/src/natives/transaction_context.rs
+++ b/aptos-move/framework/src/natives/transaction_context.rs
@@ -1,17 +1,17 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::natives::helpers::{make_safe_native, SafeNativeContext, SafeNativeResult};
-use aptos_types::{
-    on_chain_config::{Features, TimedFeatures},
-    transaction::authenticator::{AuthenticationKey, AuthenticationKeyPreimage},
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    RawSafeNative, SafeNativeBuilder, SafeNativeContext, SafeNativeResult,
 };
+use aptos_types::transaction::authenticator::{AuthenticationKey, AuthenticationKeyPreimage};
 use better_any::{Tid, TidAble};
-use move_core_types::{account_address::AccountAddress, gas_algebra::InternalGas};
+use move_core_types::account_address::AccountAddress;
 use move_vm_runtime::native_functions::NativeFunction;
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use smallvec::{smallvec, SmallVec};
-use std::{collections::VecDeque, fmt::Debug, sync::Arc};
+use std::collections::VecDeque;
 
 /// The native transaction context extension. This needs to be attached to the
 /// NativeContextExtensions value which is passed into session functions, so its accessible from
@@ -48,19 +48,12 @@ impl NativeTransactionContext {
  *   gas cost: base_cost
  *
  **************************************************************************************************/
-#[derive(Clone, Debug)]
-pub struct GetTxnHashGasParameters {
-    pub base: InternalGas,
-}
-
 fn native_get_txn_hash(
-    gas_params: &GetTxnHashGasParameters,
     context: &mut SafeNativeContext,
     mut _ty_args: Vec<Type>,
     _args: VecDeque<Value>,
 ) -> SafeNativeResult<SmallVec<[Value; 1]>> {
-    context.charge(gas_params.base)?;
-
+    context.charge(TRANSACTION_CONTEXT_GET_TXN_HASH_BASE)?;
     let transaction_context = context.extensions().get::<NativeTransactionContext>();
 
     Ok(smallvec![Value::vector_u8(
@@ -74,18 +67,12 @@ fn native_get_txn_hash(
  *   gas cost: base_cost
  *
  **************************************************************************************************/
-#[derive(Clone, Debug)]
-pub struct GenerateUniqueAddressGasParameters {
-    pub base: InternalGas,
-}
-
 fn native_generate_unique_address(
-    gas_params: &GenerateUniqueAddressGasParameters,
     context: &mut SafeNativeContext,
     mut _ty_args: Vec<Type>,
     _args: VecDeque<Value>,
 ) -> SafeNativeResult<SmallVec<[Value; 1]>> {
-    context.charge(gas_params.base)?;
+    context.charge(TRANSACTION_CONTEXT_GENERATE_UNIQUE_ADDRESS_BASE)?;
 
     let mut transaction_context = context
         .extensions_mut()
@@ -110,18 +97,12 @@ fn native_generate_unique_address(
  *   gas cost: base_cost
  *
  **************************************************************************************************/
-#[derive(Clone, Debug)]
-pub struct GetScriptHashGasParameters {
-    pub base: InternalGas,
-}
-
 fn native_get_script_hash(
-    gas_params: &GetScriptHashGasParameters,
     context: &mut SafeNativeContext,
     mut _ty_args: Vec<Type>,
     _args: VecDeque<Value>,
 ) -> SafeNativeResult<SmallVec<[Value; 1]>> {
-    context.charge(gas_params.base)?;
+    context.charge(TRANSACTION_CONTEXT_GET_SCRIPT_HASH_BASE)?;
 
     let transaction_context = context.extensions().get::<NativeTransactionContext>();
 
@@ -134,47 +115,14 @@ fn native_get_script_hash(
  * module
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub get_txn_hash: GetTxnHashGasParameters,
-    pub get_script_hash: GetScriptHashGasParameters,
-    pub generate_unique_address: GenerateUniqueAddressGasParameters,
-}
-
 pub fn make_all(
-    gas_params: GasParameters,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
     let natives = [
-        (
-            "get_script_hash",
-            make_safe_native(
-                gas_params.get_script_hash,
-                timed_features.clone(),
-                features.clone(),
-                native_get_script_hash,
-            ),
-        ),
-        (
-            "generate_unique_address",
-            make_safe_native(
-                gas_params.generate_unique_address,
-                timed_features.clone(),
-                features.clone(),
-                native_generate_unique_address,
-            ),
-        ),
-        (
-            "get_txn_hash",
-            make_safe_native(
-                gas_params.get_txn_hash,
-                timed_features,
-                features,
-                native_get_txn_hash,
-            ),
-        ),
+        ("get_script_hash", native_get_script_hash as RawSafeNative),
+        ("generate_unique_address", native_generate_unique_address),
+        ("get_txn_hash", native_get_txn_hash),
     ];
 
-    crate::natives::helpers::make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/src/natives/type_info.rs b/aptos-move/framework/src/natives/type_info.rs
index ba46579663557..077df134bb5ce 100644
--- a/aptos-move/framework/src/natives/type_info.rs
+++ b/aptos-move/framework/src/natives/type_info.rs
@@ -1,13 +1,12 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
-
-use crate::natives::{
-    helpers::{make_safe_native, SafeNativeContext, SafeNativeError, SafeNativeResult},
-    transaction_context::NativeTransactionContext,
+use crate::natives::transaction_context::NativeTransactionContext;
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    RawSafeNative, SafeNativeBuilder, SafeNativeContext, SafeNativeError, SafeNativeResult,
 };
-use aptos_types::on_chain_config::{Features, TimedFeatures};
 use move_core_types::{
-    gas_algebra::{InternalGas, InternalGasPerByte, NumBytes},
+    gas_algebra::NumBytes,
     language_storage::{StructTag, TypeTag},
 };
 use move_vm_runtime::native_functions::NativeFunction;
@@ -16,7 +15,7 @@ use move_vm_types::{
     values::{Struct, Value},
 };
 use smallvec::{smallvec, SmallVec};
-use std::{collections::VecDeque, fmt::Write, sync::Arc};
+use std::{collections::VecDeque, fmt::Write};
 
 fn type_of_internal(struct_tag: &StructTag) -> Result<SmallVec<[Value; 1]>, std::fmt::Error> {
     let mut name = struct_tag.name.to_string();
@@ -45,14 +44,7 @@ fn type_of_internal(struct_tag: &StructTag) -> Result<SmallVec<[Value; 1]>, std:
  *   gas cost: base_cost + unit_cost * type_size
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct TypeOfGasParameters {
-    pub base: InternalGas,
-    pub per_byte_in_str: InternalGasPerByte,
-}
-
 fn native_type_of(
-    gas_params: &TypeOfGasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     arguments: VecDeque<Value>,
@@ -60,15 +52,16 @@ fn native_type_of(
     debug_assert!(ty_args.len() == 1);
     debug_assert!(arguments.is_empty());
 
-    context.charge(gas_params.base)?;
+    context.charge(TYPE_INFO_TYPE_OF_BASE)?;
 
     let type_tag = context.type_to_type_tag(&ty_args[0])?;
 
-    if gas_params.per_byte_in_str > 0.into() {
+    if context.eval_gas(TYPE_INFO_TYPE_OF_PER_BYTE_IN_STR) > 0.into() {
         let type_tag_str = type_tag.to_string();
         // Ideally, we would charge *before* the `type_to_type_tag()` and `type_tag.to_string()` calls above.
         // But there are other limits in place that prevent this native from being called with too much work.
-        context.charge(gas_params.per_byte_in_str * NumBytes::new(type_tag_str.len() as u64))?;
+        context
+            .charge(TYPE_INFO_TYPE_OF_PER_BYTE_IN_STR * NumBytes::new(type_tag_str.len() as u64))?;
     }
 
     if let TypeTag::Struct(struct_tag) = type_tag {
@@ -88,14 +81,7 @@ fn native_type_of(
  *   gas cost: base_cost + unit_cost * type_size
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct TypeNameGasParameters {
-    pub base: InternalGas,
-    pub per_byte_in_str: InternalGasPerByte,
-}
-
 fn native_type_name(
-    gas_params: &TypeNameGasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     arguments: VecDeque<Value>,
@@ -103,13 +89,13 @@ fn native_type_name(
     debug_assert!(ty_args.len() == 1);
     debug_assert!(arguments.is_empty());
 
-    context.charge(gas_params.base)?;
+    context.charge(TYPE_INFO_TYPE_NAME_BASE)?;
 
     let type_tag = context.type_to_type_tag(&ty_args[0])?;
     let type_name = type_tag.to_string();
 
     // TODO: Ideally, we would charge *before* the `type_to_type_tag()` and `type_tag.to_string()` calls above.
-    context.charge(gas_params.per_byte_in_str * NumBytes::new(type_name.len() as u64))?;
+    context.charge(TYPE_INFO_TYPE_NAME_PER_BYTE_IN_STR * NumBytes::new(type_name.len() as u64))?;
 
     Ok(smallvec![Value::struct_(Struct::pack(vec![
         Value::vector_u8(type_name.as_bytes().to_vec())
@@ -124,13 +110,7 @@ fn native_type_name(
  *   gas cost: base_cost
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct ChainIdGasParameters {
-    pub base: InternalGas,
-}
-
 fn native_chain_id(
-    gas_params: &ChainIdGasParameters,
     context: &mut SafeNativeContext,
     _ty_args: Vec<Type>,
     arguments: VecDeque<Value>,
@@ -138,7 +118,7 @@ fn native_chain_id(
     debug_assert!(_ty_args.is_empty());
     debug_assert!(arguments.is_empty());
 
-    context.charge(gas_params.base)?;
+    context.charge(TYPE_INFO_CHAIN_ID_BASE)?;
 
     let chain_id = context
         .extensions()
@@ -152,49 +132,16 @@ fn native_chain_id(
  * module
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub type_of: TypeOfGasParameters,
-    pub type_name: TypeNameGasParameters,
-    pub chain_id: ChainIdGasParameters,
-}
-
 pub fn make_all(
-    gas_params: GasParameters,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
     let natives = [
-        (
-            "type_of",
-            make_safe_native(
-                gas_params.type_of,
-                timed_features.clone(),
-                features.clone(),
-                native_type_of,
-            ),
-        ),
-        (
-            "type_name",
-            make_safe_native(
-                gas_params.type_name,
-                timed_features.clone(),
-                features.clone(),
-                native_type_name,
-            ),
-        ),
-        (
-            "chain_id_internal",
-            make_safe_native(
-                gas_params.chain_id,
-                timed_features,
-                features,
-                native_chain_id,
-            ),
-        ),
+        ("type_of", native_type_of as RawSafeNative),
+        ("type_name", native_type_name),
+        ("chain_id_internal", native_chain_id),
     ];
 
-    crate::natives::helpers::make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
 
 #[cfg(test)]
diff --git a/aptos-move/framework/src/natives/util.rs b/aptos-move/framework/src/natives/util.rs
index 2a3979a5b695d..21bb4a4f5ec5a 100644
--- a/aptos-move/framework/src/natives/util.rs
+++ b/aptos-move/framework/src/natives/util.rs
@@ -1,20 +1,17 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{
-    natives::helpers::{make_safe_native, SafeNativeContext, SafeNativeError, SafeNativeResult},
-    safely_pop_arg,
+use aptos_gas_schedule::gas_params::natives::aptos_framework::*;
+use aptos_native_interface::{
+    safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext, SafeNativeError,
+    SafeNativeResult,
 };
-use aptos_types::on_chain_config::{Features, TimedFeatures};
 use move_binary_format::errors::PartialVMError;
-use move_core_types::{
-    gas_algebra::{InternalGas, InternalGasPerByte, NumBytes},
-    vm_status::StatusCode,
-};
+use move_core_types::{gas_algebra::NumBytes, vm_status::StatusCode};
 use move_vm_runtime::native_functions::NativeFunction;
 use move_vm_types::{loaded_data::runtime_types::Type, values::Value};
 use smallvec::{smallvec, SmallVec};
-use std::{collections::VecDeque, sync::Arc};
+use std::collections::VecDeque;
 
 // !!!! NOTE !!!!
 // This file is intended for natives from the util module in the framework.
@@ -29,14 +26,7 @@ const EFROM_BYTES: u64 = 0x01_0001;
  *   gas cost: base_cost + unit_cost * bytes_len
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct FromBytesGasParameters {
-    pub base: InternalGas,
-    pub per_byte: InternalGasPerByte,
-}
-
 fn native_from_bytes(
-    gas_params: &FromBytesGasParameters,
     context: &mut SafeNativeContext,
     ty_args: Vec<Type>,
     mut args: VecDeque<Value>,
@@ -53,7 +43,9 @@ fn native_from_bytes(
     })?;
 
     let bytes = safely_pop_arg!(args, Vec<u8>);
-    context.charge(gas_params.base + gas_params.per_byte * NumBytes::new(bytes.len() as u64))?;
+    context.charge(
+        UTIL_FROM_BYTES_BASE + UTIL_FROM_BYTES_PER_BYTE * NumBytes::new(bytes.len() as u64),
+    )?;
     let val = match Value::simple_deserialize(&bytes, &layout) {
         Some(val) => val,
         None => {
@@ -70,25 +62,10 @@ fn native_from_bytes(
  * module
  *
  **************************************************************************************************/
-#[derive(Debug, Clone)]
-pub struct GasParameters {
-    pub from_bytes: FromBytesGasParameters,
-}
-
 pub fn make_all(
-    gas_params: GasParameters,
-    timed_features: TimedFeatures,
-    features: Arc<Features>,
-) -> impl Iterator<Item = (String, NativeFunction)> {
-    let natives = [(
-        "from_bytes",
-        make_safe_native(
-            gas_params.from_bytes,
-            timed_features,
-            features,
-            native_from_bytes,
-        ),
-    )];
+    builder: &SafeNativeBuilder,
+) -> impl Iterator<Item = (String, NativeFunction)> + '_ {
+    let natives = [("from_bytes", native_from_bytes as RawSafeNative)];
 
-    crate::natives::helpers::make_module_natives(natives)
+    builder.make_named_natives(natives)
 }
diff --git a/aptos-move/framework/table-natives/Cargo.toml b/aptos-move/framework/table-natives/Cargo.toml
new file mode 100644
index 0000000000000..fe5973c69975c
--- /dev/null
+++ b/aptos-move/framework/table-natives/Cargo.toml
@@ -0,0 +1,28 @@
+[package]
+name = "aptos-table-natives"
+version = "0.1.0"
+
+# Workspace inherited keys
+authors = { workspace = true }
+edition = { workspace = true }
+homepage = { workspace = true }
+license = { workspace = true }
+publish = { workspace = true }
+repository = { workspace = true }
+rust-version = { workspace = true }
+
+[dependencies]
+anyhow = { workspace = true }
+aptos-gas-schedule = { workspace = true }
+aptos-native-interface = { workspace = true }
+better_any = { workspace = true }
+sha3 = { workspace = true }
+smallvec = { workspace = true }
+
+move-binary-format = { workspace = true }
+move-core-types = { workspace = true }
+move-vm-runtime = { workspace = true }
+move-vm-test-utils = { workspace = true }
+move-vm-types = { workspace = true }
+
+aptos-types = { workspace = true }
diff --git a/aptos-move/framework/table-natives/src/lib.rs b/aptos-move/framework/table-natives/src/lib.rs
new file mode 100644
index 0000000000000..633bff93266a1
--- /dev/null
+++ b/aptos-move/framework/table-natives/src/lib.rs
@@ -0,0 +1,568 @@
+// Copyright © Aptos Foundation
+
+// Copyright (c) The Diem Core Contributors
+// Copyright (c) The Move Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+//! A crate which extends Move by tables.
+//!
+//! See [`Table.move`](../sources/Table.move) for language use.
+//! See [`README.md`](../README.md) for integration into an adapter.
+
+use aptos_gas_schedule::gas_params::natives::table::*;
+use aptos_native_interface::{
+    safely_pop_arg, RawSafeNative, SafeNativeBuilder, SafeNativeContext, SafeNativeError,
+    SafeNativeResult,
+};
+use better_any::{Tid, TidAble};
+use move_binary_format::errors::{PartialVMError, PartialVMResult};
+use move_core_types::{
+    account_address::AccountAddress, effects::Op, gas_algebra::NumBytes, identifier::Identifier,
+    language_storage::TypeTag, value::MoveTypeLayout, vm_status::StatusCode,
+};
+use move_vm_runtime::native_functions::NativeFunctionTable;
+use move_vm_types::{
+    loaded_data::runtime_types::Type,
+    values::{GlobalValue, Reference, StructRef, Value},
+};
+use sha3::{Digest, Sha3_256};
+use smallvec::{smallvec, SmallVec};
+use std::{
+    cell::RefCell,
+    collections::{btree_map::Entry, BTreeMap, BTreeSet, VecDeque},
+    fmt::Display,
+    mem::drop,
+};
+
+// ===========================================================================================
+// Public Data Structures and Constants
+
+/// The representation of a table handle. This is created from truncating a sha3-256 based
+/// hash over a transaction hash provided by the environment and a table creation counter
+/// local to the transaction.
+#[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
+pub struct TableHandle(pub AccountAddress);
+
+impl From<TableHandle> for aptos_types::state_store::table::TableHandle {
+    fn from(hdl: TableHandle) -> Self {
+        Self(hdl.0)
+    }
+}
+
+impl Display for TableHandle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "T-{:X}", self.0)
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct TableInfo {
+    pub key_type: TypeTag,
+    pub value_type: TypeTag,
+}
+
+impl TableInfo {
+    pub fn new(key_type: TypeTag, value_type: TypeTag) -> Self {
+        Self {
+            key_type,
+            value_type,
+        }
+    }
+}
+
+impl Display for TableInfo {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "Table<{}, {}>", self.key_type, self.value_type)
+    }
+}
+
+/// A table change set.
+#[derive(Default)]
+pub struct TableChangeSet {
+    pub new_tables: BTreeMap<TableHandle, TableInfo>,
+    pub removed_tables: BTreeSet<TableHandle>,
+    pub changes: BTreeMap<TableHandle, TableChange>,
+}
+
+/// A change of a single table.
+pub struct TableChange {
+    pub entries: BTreeMap<Vec<u8>, Op<Vec<u8>>>,
+}
+
+/// A table resolver which needs to be provided by the environment. This allows to lookup
+/// data in remote storage, as well as retrieve cost of table operations.
+pub trait TableResolver {
+    fn resolve_table_entry(
+        &self,
+        handle: &TableHandle,
+        key: &[u8],
+    ) -> Result<Option<Vec<u8>>, anyhow::Error>;
+}
+
+impl TableResolver for move_vm_test_utils::BlankStorage {
+    fn resolve_table_entry(
+        &self,
+        _handle: &TableHandle,
+        _key: &[u8],
+    ) -> Result<Option<Vec<u8>>, anyhow::Error> {
+        Ok(None)
+    }
+}
+
+/// The native table context extension. This needs to be attached to the NativeContextExtensions
+/// value which is passed into session functions, so its accessible from natives of this
+/// extension.
+#[derive(Tid)]
+pub struct NativeTableContext<'a> {
+    resolver: &'a dyn TableResolver,
+    txn_hash: [u8; 32],
+    table_data: RefCell<TableData>,
+}
+
+// See stdlib/Error.move
+const _ECATEGORY_INVALID_STATE: u8 = 0;
+const ECATEGORY_INVALID_ARGUMENT: u8 = 7;
+
+const ALREADY_EXISTS: u64 = (100 << 8) + ECATEGORY_INVALID_ARGUMENT as u64;
+const NOT_FOUND: u64 = (101 << 8) + ECATEGORY_INVALID_ARGUMENT as u64;
+// Move side raises this
+const _NOT_EMPTY: u64 = (102 << 8) + _ECATEGORY_INVALID_STATE as u64;
+
+// ===========================================================================================
+// Private Data Structures and Constants
+
+/// A structure representing mutable data of the NativeTableContext. This is in a RefCell
+/// of the overall context so we can mutate while still accessing the overall context.
+#[derive(Default)]
+struct TableData {
+    new_tables: BTreeMap<TableHandle, TableInfo>,
+    removed_tables: BTreeSet<TableHandle>,
+    tables: BTreeMap<TableHandle, Table>,
+}
+
+/// A structure representing a single table.
+struct Table {
+    handle: TableHandle,
+    key_layout: MoveTypeLayout,
+    value_layout: MoveTypeLayout,
+    content: BTreeMap<Vec<u8>, GlobalValue>,
+}
+
+/// The field index of the `handle` field in the `Table` Move struct.
+const HANDLE_FIELD_INDEX: usize = 0;
+
+// =========================================================================================
+// Implementation of Native Table Context
+
+impl<'a> NativeTableContext<'a> {
+    /// Create a new instance of a native table context. This must be passed in via an
+    /// extension into VM session functions.
+    pub fn new(txn_hash: [u8; 32], resolver: &'a dyn TableResolver) -> Self {
+        Self {
+            resolver,
+            txn_hash,
+            table_data: Default::default(),
+        }
+    }
+
+    /// Computes the change set from a NativeTableContext.
+    pub fn into_change_set(self) -> PartialVMResult<TableChangeSet> {
+        let NativeTableContext { table_data, .. } = self;
+        let TableData {
+            new_tables,
+            removed_tables,
+            tables,
+        } = table_data.into_inner();
+        let mut changes = BTreeMap::new();
+        for (handle, table) in tables {
+            let Table {
+                value_layout,
+                content,
+                ..
+            } = table;
+            let mut entries = BTreeMap::new();
+            for (key, gv) in content {
+                let op = match gv.into_effect() {
+                    Some(op) => op,
+                    None => continue,
+                };
+
+                match op {
+                    Op::New(val) => {
+                        let bytes = serialize(&value_layout, &val)?;
+                        entries.insert(key, Op::New(bytes));
+                    },
+                    Op::Modify(val) => {
+                        let bytes = serialize(&value_layout, &val)?;
+                        entries.insert(key, Op::Modify(bytes));
+                    },
+                    Op::Delete => {
+                        entries.insert(key, Op::Delete);
+                    },
+                }
+            }
+            if !entries.is_empty() {
+                changes.insert(handle, TableChange { entries });
+            }
+        }
+        Ok(TableChangeSet {
+            new_tables,
+            removed_tables,
+            changes,
+        })
+    }
+}
+
+impl TableData {
+    /// Gets or creates a new table in the TableData. This initializes information about
+    /// the table, like the type layout for keys and values.
+    fn get_or_create_table(
+        &mut self,
+        context: &SafeNativeContext,
+        handle: TableHandle,
+        key_ty: &Type,
+        value_ty: &Type,
+    ) -> PartialVMResult<&mut Table> {
+        Ok(match self.tables.entry(handle) {
+            Entry::Vacant(e) => {
+                let key_layout = get_type_layout(context, key_ty)?;
+                let value_layout = get_type_layout(context, value_ty)?;
+                let table = Table {
+                    handle,
+                    key_layout,
+                    value_layout,
+                    content: Default::default(),
+                };
+                e.insert(table)
+            },
+            Entry::Occupied(e) => e.into_mut(),
+        })
+    }
+}
+
+impl Table {
+    fn get_or_create_global_value(
+        &mut self,
+        context: &NativeTableContext,
+        key: Vec<u8>,
+    ) -> PartialVMResult<(&mut GlobalValue, Option<Option<NumBytes>>)> {
+        Ok(match self.content.entry(key) {
+            Entry::Vacant(entry) => {
+                let (gv, loaded) = match context
+                    .resolver
+                    .resolve_table_entry(&self.handle, entry.key())
+                    .map_err(|err| {
+                        partial_extension_error(format!("remote table resolver failure: {}", err))
+                    })? {
+                    Some(val_bytes) => {
+                        let val = deserialize(&self.value_layout, &val_bytes)?;
+                        (
+                            GlobalValue::cached(val)?,
+                            Some(NumBytes::new(val_bytes.len() as u64)),
+                        )
+                    },
+                    None => (GlobalValue::none(), None),
+                };
+                (entry.insert(gv), Some(loaded))
+            },
+            Entry::Occupied(entry) => (entry.into_mut(), None),
+        })
+    }
+}
+
+// =========================================================================================
+// Native Function Implementations
+
+/// Returns all natives for tables.
+pub fn table_natives(
+    table_addr: AccountAddress,
+    builder: &mut SafeNativeBuilder,
+) -> NativeFunctionTable {
+    builder.with_incremental_gas_charging(false, |builder| {
+        builder
+            .make_named_natives([
+                ("new_table_handle", native_new_table_handle as RawSafeNative),
+                ("add_box", native_add_box),
+                ("borrow_box", native_borrow_box),
+                ("borrow_box_mut", native_borrow_box),
+                ("remove_box", native_remove_box),
+                ("contains_box", native_contains_box),
+                ("destroy_empty_box", native_destroy_empty_box),
+                ("drop_unchecked_box", native_drop_unchecked_box),
+            ])
+            .map(|(func_name, func)| {
+                (
+                    table_addr,
+                    Identifier::new("table").unwrap(),
+                    Identifier::new(func_name).unwrap(),
+                    func,
+                )
+            })
+            .collect()
+    })
+}
+
+fn charge_load_cost(
+    context: &mut SafeNativeContext,
+    loaded: Option<Option<NumBytes>>,
+) -> SafeNativeResult<()> {
+    context.charge(COMMON_LOAD_BASE_LEGACY)?;
+
+    match loaded {
+        Some(Some(num_bytes)) => {
+            context.charge(COMMON_LOAD_BASE_NEW + COMMON_LOAD_PER_BYTE * num_bytes)
+        },
+        Some(None) => context.charge(COMMON_LOAD_BASE_NEW + COMMON_LOAD_FAILURE),
+        None => Ok(()),
+    }
+}
+
+fn native_new_table_handle(
+    context: &mut SafeNativeContext,
+    ty_args: Vec<Type>,
+    args: VecDeque<Value>,
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
+    assert_eq!(ty_args.len(), 2);
+    assert!(args.is_empty());
+
+    context.charge(NEW_TABLE_HANDLE_BASE)?;
+
+    let table_context = context.extensions().get::<NativeTableContext>();
+    let mut table_data = table_context.table_data.borrow_mut();
+
+    // Take the transaction hash provided by the environment, combine it with the # of tables
+    // produced so far, sha256 this to produce a unique handle. Given the txn hash
+    // is unique, this should create a unique and deterministic global id.
+    let mut digest = Sha3_256::new();
+    let table_len = table_data.new_tables.len() as u32; // cast usize to u32 to ensure same length
+    Digest::update(&mut digest, table_context.txn_hash);
+    Digest::update(&mut digest, table_len.to_be_bytes());
+    let bytes = digest.finalize().to_vec();
+    let handle = AccountAddress::from_bytes(&bytes[0..AccountAddress::LENGTH])
+        .map_err(|_| partial_extension_error("Unable to create table handle"))?;
+    let key_type = context.type_to_type_tag(&ty_args[0])?;
+    let value_type = context.type_to_type_tag(&ty_args[1])?;
+    assert!(table_data
+        .new_tables
+        .insert(TableHandle(handle), TableInfo::new(key_type, value_type))
+        .is_none());
+
+    Ok(smallvec![Value::address(handle)])
+}
+
+fn native_add_box(
+    context: &mut SafeNativeContext,
+    ty_args: Vec<Type>,
+    mut args: VecDeque<Value>,
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
+    assert_eq!(ty_args.len(), 3);
+    assert_eq!(args.len(), 3);
+
+    context.charge(ADD_BOX_BASE)?;
+
+    let table_context = context.extensions().get::<NativeTableContext>();
+    let mut table_data = table_context.table_data.borrow_mut();
+
+    let val = args.pop_back().unwrap();
+    let key = args.pop_back().unwrap();
+    let handle = get_table_handle(&safely_pop_arg!(args, StructRef))?;
+
+    let table = table_data.get_or_create_table(context, handle, &ty_args[0], &ty_args[2])?;
+
+    let key_bytes = serialize(&table.key_layout, &key)?;
+    let key_cost = ADD_BOX_PER_BYTE_SERIALIZED * NumBytes::new(key_bytes.len() as u64);
+
+    let (gv, loaded) = table.get_or_create_global_value(table_context, key_bytes)?;
+
+    let res = match gv.move_to(val) {
+        Ok(_) => Ok(smallvec![]),
+        Err(_) => Err(SafeNativeError::Abort {
+            abort_code: ALREADY_EXISTS,
+        }),
+    };
+
+    drop(table_data);
+
+    // TODO(Gas): Figure out a way to charge this earlier.
+    context.charge(key_cost)?;
+    charge_load_cost(context, loaded)?;
+
+    res
+}
+
+fn native_borrow_box(
+    context: &mut SafeNativeContext,
+    ty_args: Vec<Type>,
+    mut args: VecDeque<Value>,
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
+    assert_eq!(ty_args.len(), 3);
+    assert_eq!(args.len(), 2);
+
+    context.charge(BORROW_BOX_BASE)?;
+
+    let table_context = context.extensions().get::<NativeTableContext>();
+    let mut table_data = table_context.table_data.borrow_mut();
+
+    let key = args.pop_back().unwrap();
+    let handle = get_table_handle(&safely_pop_arg!(args, StructRef))?;
+
+    let table = table_data.get_or_create_table(context, handle, &ty_args[0], &ty_args[2])?;
+
+    let key_bytes = serialize(&table.key_layout, &key)?;
+    let key_cost = BORROW_BOX_PER_BYTE_SERIALIZED * NumBytes::new(key_bytes.len() as u64);
+
+    let (gv, loaded) = table.get_or_create_global_value(table_context, key_bytes)?;
+
+    let res = match gv.borrow_global() {
+        Ok(ref_val) => Ok(smallvec![ref_val]),
+        Err(_) => Err(SafeNativeError::Abort {
+            abort_code: NOT_FOUND,
+        }),
+    };
+
+    drop(table_data);
+
+    // TODO(Gas): Figure out a way to charge this earlier.
+    context.charge(key_cost)?;
+    charge_load_cost(context, loaded)?;
+
+    res
+}
+
+fn native_contains_box(
+    context: &mut SafeNativeContext,
+    ty_args: Vec<Type>,
+    mut args: VecDeque<Value>,
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
+    assert_eq!(ty_args.len(), 3);
+    assert_eq!(args.len(), 2);
+
+    context.charge(CONTAINS_BOX_BASE)?;
+
+    let table_context = context.extensions().get::<NativeTableContext>();
+    let mut table_data = table_context.table_data.borrow_mut();
+
+    let key = args.pop_back().unwrap();
+    let handle = get_table_handle(&safely_pop_arg!(args, StructRef))?;
+
+    let table = table_data.get_or_create_table(context, handle, &ty_args[0], &ty_args[2])?;
+
+    let key_bytes = serialize(&table.key_layout, &key)?;
+    let key_cost = CONTAINS_BOX_PER_BYTE_SERIALIZED * NumBytes::new(key_bytes.len() as u64);
+
+    let (gv, loaded) = table.get_or_create_global_value(table_context, key_bytes)?;
+    let exists = Value::bool(gv.exists()?);
+
+    drop(table_data);
+
+    // TODO(Gas): Figure out a way to charge this earlier.
+    context.charge(key_cost)?;
+    charge_load_cost(context, loaded)?;
+
+    Ok(smallvec![exists])
+}
+
+fn native_remove_box(
+    context: &mut SafeNativeContext,
+    ty_args: Vec<Type>,
+    mut args: VecDeque<Value>,
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
+    assert_eq!(ty_args.len(), 3);
+    assert_eq!(args.len(), 2);
+
+    context.charge(REMOVE_BOX_BASE)?;
+
+    let table_context = context.extensions().get::<NativeTableContext>();
+    let mut table_data = table_context.table_data.borrow_mut();
+
+    let key = args.pop_back().unwrap();
+    let handle = get_table_handle(&safely_pop_arg!(args, StructRef))?;
+
+    let table = table_data.get_or_create_table(context, handle, &ty_args[0], &ty_args[2])?;
+
+    let key_bytes = serialize(&table.key_layout, &key)?;
+    let key_cost = REMOVE_BOX_PER_BYTE_SERIALIZED * NumBytes::new(key_bytes.len() as u64);
+
+    let (gv, loaded) = table.get_or_create_global_value(table_context, key_bytes)?;
+    let res = match gv.move_from() {
+        Ok(val) => Ok(smallvec![val]),
+        Err(_) => Err(SafeNativeError::Abort {
+            abort_code: NOT_FOUND,
+        }),
+    };
+
+    drop(table_data);
+
+    // TODO(Gas): Figure out a way to charge this earlier.
+    context.charge(key_cost)?;
+    charge_load_cost(context, loaded)?;
+
+    res
+}
+
+fn native_destroy_empty_box(
+    context: &mut SafeNativeContext,
+    ty_args: Vec<Type>,
+    mut args: VecDeque<Value>,
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
+    assert_eq!(ty_args.len(), 3);
+    assert_eq!(args.len(), 1);
+
+    context.charge(DESTROY_EMPTY_BOX_BASE)?;
+
+    let table_context = context.extensions().get::<NativeTableContext>();
+    let mut table_data = table_context.table_data.borrow_mut();
+
+    let handle = get_table_handle(&safely_pop_arg!(args, StructRef))?;
+    // TODO: Can the following line be removed?
+    table_data.get_or_create_table(context, handle, &ty_args[0], &ty_args[2])?;
+
+    assert!(table_data.removed_tables.insert(handle));
+
+    Ok(smallvec![])
+}
+
+fn native_drop_unchecked_box(
+    context: &mut SafeNativeContext,
+    ty_args: Vec<Type>,
+    args: VecDeque<Value>,
+) -> SafeNativeResult<SmallVec<[Value; 1]>> {
+    assert_eq!(ty_args.len(), 3);
+    assert_eq!(args.len(), 1);
+
+    context.charge(DROP_UNCHECKED_BOX_BASE)?;
+
+    Ok(smallvec![])
+}
+
+// =========================================================================================
+// Helpers
+
+fn get_table_handle(table: &StructRef) -> PartialVMResult<TableHandle> {
+    let handle = table
+        .borrow_field(HANDLE_FIELD_INDEX)?
+        .value_as::<Reference>()?
+        .read_ref()?
+        .value_as::<AccountAddress>()?;
+    Ok(TableHandle(handle))
+}
+
+fn serialize(layout: &MoveTypeLayout, val: &Value) -> PartialVMResult<Vec<u8>> {
+    val.simple_serialize(layout)
+        .ok_or_else(|| partial_extension_error("cannot serialize table key or value"))
+}
+
+fn deserialize(layout: &MoveTypeLayout, bytes: &[u8]) -> PartialVMResult<Value> {
+    Value::simple_deserialize(bytes, layout)
+        .ok_or_else(|| partial_extension_error("cannot deserialize table key or value"))
+}
+
+fn partial_extension_error(msg: impl ToString) -> PartialVMError {
+    PartialVMError::new(StatusCode::VM_EXTENSION_ERROR).with_message(msg.to_string())
+}
+
+fn get_type_layout(context: &SafeNativeContext, ty: &Type) -> PartialVMResult<MoveTypeLayout> {
+    context
+        .type_to_type_layout(ty)?
+        .ok_or_else(|| partial_extension_error("cannot determine type layout"))
+}
diff --git a/aptos-move/framework/tests/move_unit_test.rs b/aptos-move/framework/tests/move_unit_test.rs
index f71d3b633e81c..b48fe2781442e 100644
--- a/aptos-move/framework/tests/move_unit_test.rs
+++ b/aptos-move/framework/tests/move_unit_test.rs
@@ -3,13 +3,12 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use aptos_framework::path_in_crate;
-use aptos_gas::{AbstractValueSizeGasParameters, NativeGasParameters, LATEST_GAS_FEATURE_VERSION};
+use aptos_gas_schedule::{MiscGasParameters, NativeGasParameters, LATEST_GAS_FEATURE_VERSION};
 use aptos_types::on_chain_config::{Features, TimedFeatures};
 use aptos_vm::natives;
 use move_cli::base::test::{run_move_unit_tests, UnitTestResult};
 use move_unit_test::UnitTestingConfig;
 use move_vm_runtime::native_functions::NativeFunctionTable;
-use std::sync::Arc;
 use tempfile::tempdir;
 
 fn run_tests_for_pkg(path_to_pkg: impl Into<String>) {
@@ -39,11 +38,11 @@ pub fn aptos_test_natives() -> NativeFunctionTable {
     natives::configure_for_unit_test();
     // move_stdlib has the testing feature enabled to include debug native functions
     natives::aptos_natives(
-        NativeGasParameters::zeros(),
-        AbstractValueSizeGasParameters::zeros(),
         LATEST_GAS_FEATURE_VERSION,
+        NativeGasParameters::zeros(),
+        MiscGasParameters::zeros(),
         TimedFeatures::enable_all(),
-        Arc::new(Features::default()),
+        Features::default(),
     )
 }
 
diff --git a/aptos-move/move-examples/Cargo.toml b/aptos-move/move-examples/Cargo.toml
index f32df71924596..a3494f792bd52 100644
--- a/aptos-move/move-examples/Cargo.toml
+++ b/aptos-move/move-examples/Cargo.toml
@@ -14,7 +14,6 @@ rust-version = { workspace = true }
 
 [dependencies]
 aptos-gas-schedule = { workspace = true }
-aptos-gas = { workspace = true }
 aptos-types = { workspace = true }
 aptos-vm ={ workspace = true, features = ["testing"] }
 clap = { workspace = true }
diff --git a/aptos-move/move-examples/tests/move_unit_tests.rs b/aptos-move/move-examples/tests/move_unit_tests.rs
index 86edc673c87fb..5079aaa2ce38c 100644
--- a/aptos-move/move-examples/tests/move_unit_tests.rs
+++ b/aptos-move/move-examples/tests/move_unit_tests.rs
@@ -1,8 +1,7 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use aptos_gas::{AbstractValueSizeGasParameters, NativeGasParameters};
-use aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION;
+use aptos_gas_schedule::{MiscGasParameters, NativeGasParameters, LATEST_GAS_FEATURE_VERSION};
 use aptos_types::{
     account_address::{create_resource_address, AccountAddress},
     on_chain_config::{Features, TimedFeatures},
@@ -11,7 +10,7 @@ use aptos_vm::natives;
 use move_cli::base::test::{run_move_unit_tests, UnitTestResult};
 use move_unit_test::UnitTestingConfig;
 use move_vm_runtime::native_functions::NativeFunctionTable;
-use std::{collections::BTreeMap, path::PathBuf, sync::Arc};
+use std::{collections::BTreeMap, path::PathBuf};
 use tempfile::tempdir;
 
 pub fn path_in_crate<S>(relative: S) -> PathBuf
@@ -52,11 +51,11 @@ pub fn run_tests_for_pkg(
 pub fn aptos_test_natives() -> NativeFunctionTable {
     natives::configure_for_unit_test();
     natives::aptos_natives(
-        NativeGasParameters::zeros(),
-        AbstractValueSizeGasParameters::zeros(),
         LATEST_GAS_FEATURE_VERSION,
+        NativeGasParameters::zeros(),
+        MiscGasParameters::zeros(),
         TimedFeatures::enable_all(),
-        Arc::new(Features::default()),
+        Features::default(),
     )
 }
 
diff --git a/aptos-move/vm-genesis/Cargo.toml b/aptos-move/vm-genesis/Cargo.toml
index 8f06ecb94e4bf..73cd6b09f8931 100644
--- a/aptos-move/vm-genesis/Cargo.toml
+++ b/aptos-move/vm-genesis/Cargo.toml
@@ -18,10 +18,10 @@ aptos-cached-packages =  { workspace = true }
 aptos-crypto = { workspace = true }
 aptos-framework =  { workspace = true }
 aptos-gas-schedule = { workspace = true }
-aptos-gas = { workspace = true }
 aptos-state-view = { workspace = true }
 aptos-types = { workspace = true }
 aptos-vm = { workspace = true }
+aptos-vm-types = { workspace = true }
 bcs = { workspace = true }
 move-core-types = { workspace = true }
 move-vm-types = { workspace = true }
diff --git a/aptos-move/vm-genesis/src/lib.rs b/aptos-move/vm-genesis/src/lib.rs
index 71d59b0af8157..e8a4fa2b182f7 100644
--- a/aptos-move/vm-genesis/src/lib.rs
+++ b/aptos-move/vm-genesis/src/lib.rs
@@ -13,11 +13,10 @@ use aptos_crypto::{
     HashValue, PrivateKey, Uniform,
 };
 use aptos_framework::{ReleaseBundle, ReleasePackage};
-use aptos_gas::{
-    AbstractValueSizeGasParameters, AptosGasParameters, ChangeSetConfigs, InitialGasSchedule,
-    NativeGasParameters, ToOnChainGasSchedule,
+use aptos_gas_schedule::{
+    AptosGasParameters, InitialGasSchedule, MiscGasParameters, NativeGasParameters,
+    ToOnChainGasSchedule, LATEST_GAS_FEATURE_VERSION,
 };
-use aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION;
 use aptos_types::{
     account_config::{self, aptos_test_root_address, events::NewEpochEvent, CORE_CODE_ADDRESS},
     chain_id::ChainId,
@@ -32,6 +31,7 @@ use aptos_vm::{
     data_cache::AsMoveResolver,
     move_vm_ext::{MoveVmExt, SessionExt, SessionId},
 };
+use aptos_vm_types::storage::ChangeSetConfigs;
 use move_core_types::{
     account_address::AccountAddress,
     identifier::Identifier,
@@ -106,7 +106,7 @@ pub fn encode_aptos_mainnet_genesis_transaction(
     let data_cache = state_view.as_move_resolver();
     let move_vm = MoveVmExt::new(
         NativeGasParameters::zeros(),
-        AbstractValueSizeGasParameters::zeros(),
+        MiscGasParameters::zeros(),
         LATEST_GAS_FEATURE_VERSION,
         ChainId::test().id(),
         Features::default(),
@@ -212,7 +212,7 @@ pub fn encode_genesis_change_set(
     let data_cache = state_view.as_move_resolver();
     let move_vm = MoveVmExt::new(
         NativeGasParameters::zeros(),
-        AbstractValueSizeGasParameters::zeros(),
+        MiscGasParameters::zeros(),
         LATEST_GAS_FEATURE_VERSION,
         ChainId::test().id(),
         Features::default(),
@@ -878,7 +878,7 @@ pub fn test_genesis_module_publishing() {
 
     let move_vm = MoveVmExt::new(
         NativeGasParameters::zeros(),
-        AbstractValueSizeGasParameters::zeros(),
+        MiscGasParameters::zeros(),
         LATEST_GAS_FEATURE_VERSION,
         ChainId::test().id(),
         Features::default(),
diff --git a/aptos-move/writeset-transaction-generator/Cargo.toml b/aptos-move/writeset-transaction-generator/Cargo.toml
index e82dcc5de98ab..2340c16547195 100644
--- a/aptos-move/writeset-transaction-generator/Cargo.toml
+++ b/aptos-move/writeset-transaction-generator/Cargo.toml
@@ -18,10 +18,11 @@ aptos-cached-packages =  { workspace = true }
 aptos-crypto = { workspace = true }
 aptos-crypto-derive = { workspace = true }
 aptos-framework =  { workspace = true }
-aptos-gas = { workspace = true }
+aptos-gas-schedule = { workspace = true }
 aptos-state-view = { workspace = true }
 aptos-types = { workspace = true }
 aptos-vm = { workspace = true }
+aptos-vm-types = { workspace = true }
 bcs = { workspace = true }
 handlebars = { workspace = true }
 move-command-line-common = { workspace = true }
diff --git a/aptos-move/writeset-transaction-generator/src/writeset_builder.rs b/aptos-move/writeset-transaction-generator/src/writeset_builder.rs
index 0057a82fbb362..f13d4de5fe640 100644
--- a/aptos-move/writeset-transaction-generator/src/writeset_builder.rs
+++ b/aptos-move/writeset-transaction-generator/src/writeset_builder.rs
@@ -4,10 +4,7 @@
 
 use anyhow::format_err;
 use aptos_crypto::HashValue;
-use aptos_gas::{
-    AbstractValueSizeGasParameters, ChangeSetConfigs, NativeGasParameters,
-    LATEST_GAS_FEATURE_VERSION,
-};
+use aptos_gas_schedule::{MiscGasParameters, NativeGasParameters, LATEST_GAS_FEATURE_VERSION};
 use aptos_state_view::StateView;
 use aptos_types::{
     account_address::AccountAddress,
@@ -19,6 +16,7 @@ use aptos_vm::{
     data_cache::StorageAdapter,
     move_vm_ext::{MoveVmExt, SessionExt, SessionId},
 };
+use aptos_vm_types::storage::ChangeSetConfigs;
 use move_core_types::{
     identifier::Identifier,
     language_storage::{ModuleId, TypeTag},
@@ -113,7 +111,7 @@ where
 {
     let move_vm = MoveVmExt::new(
         NativeGasParameters::zeros(),
-        AbstractValueSizeGasParameters::zeros(),
+        MiscGasParameters::zeros(),
         LATEST_GAS_FEATURE_VERSION,
         chain_id,
         Features::default(),
diff --git a/crates/aptos/Cargo.toml b/crates/aptos/Cargo.toml
index ccdebdce15cd0..d9ae89eed1015 100644
--- a/crates/aptos/Cargo.toml
+++ b/crates/aptos/Cargo.toml
@@ -26,9 +26,8 @@ aptos-db-tool = { workspace = true }
 aptos-debugger = { workspace = true }
 aptos-faucet-core = { workspace = true }
 aptos-framework = { workspace = true }
-aptos-gas-schedule = { workspace = true }
-aptos-gas = { workspace = true }
 aptos-gas-profiling = { workspace = true }
+aptos-gas-schedule = { workspace = true }
 aptos-genesis = { workspace = true }
 aptos-github-client = { workspace = true }
 aptos-global-constants = { workspace = true }
diff --git a/crates/aptos/src/move_tool/aptos_debug_natives.rs b/crates/aptos/src/move_tool/aptos_debug_natives.rs
index 1e018938683b7..539e362206861 100644
--- a/crates/aptos/src/move_tool/aptos_debug_natives.rs
+++ b/crates/aptos/src/move_tool/aptos_debug_natives.rs
@@ -1,27 +1,25 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-use aptos_gas::{AbstractValueSizeGasParameters, NativeGasParameters};
-use aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION;
+use aptos_gas_schedule::{MiscGasParameters, NativeGasParameters, LATEST_GAS_FEATURE_VERSION};
 use aptos_types::on_chain_config::{Features, TimedFeatures};
 use aptos_vm::natives;
 use move_vm_runtime::native_functions::NativeFunctionTable;
-use std::sync::Arc;
 
 // move_stdlib has the testing feature enabled to include debug native functions
 pub fn aptos_debug_natives(
-    gas_parameters: NativeGasParameters,
-    abs_val_size_gas_params: AbstractValueSizeGasParameters,
+    native_gas_parameters: NativeGasParameters,
+    misc_gas_params: MiscGasParameters,
 ) -> NativeFunctionTable {
     // As a side effect, also configure for unit testing
     natives::configure_for_unit_test();
     // Return all natives -- build with the 'testing' feature, therefore containing
     // debug related functions.
     natives::aptos_natives(
-        gas_parameters,
-        abs_val_size_gas_params,
         LATEST_GAS_FEATURE_VERSION,
+        native_gas_parameters,
+        misc_gas_params,
         TimedFeatures::enable_all(),
-        Arc::new(Features::default()),
+        Features::default(),
     )
 }
diff --git a/crates/aptos/src/move_tool/mod.rs b/crates/aptos/src/move_tool/mod.rs
index 255e3c95b9bb2..7103e29d91024 100644
--- a/crates/aptos/src/move_tool/mod.rs
+++ b/crates/aptos/src/move_tool/mod.rs
@@ -37,7 +37,7 @@ use aptos_framework::{
     build_model, docgen::DocgenOptions, extended_checks, natives::code::UpgradePolicy,
     prover::ProverOptions, BuildOptions, BuiltPackage,
 };
-use aptos_gas::{AbstractValueSizeGasParameters, NativeGasParameters};
+use aptos_gas_schedule::{MiscGasParameters, NativeGasParameters};
 use aptos_rest_client::aptos_api_types::{
     EntryFunctionId, HexEncodedBytes, IdentifierWrapper, MoveModuleId,
 };
@@ -490,7 +490,7 @@ impl CliCommand<&'static str> for TestPackage {
             // TODO(Gas): we may want to switch to non-zero costs in the future
             aptos_debug_natives::aptos_debug_natives(
                 NativeGasParameters::zeros(),
-                AbstractValueSizeGasParameters::zeros(),
+                MiscGasParameters::zeros(),
             ),
             None,
             self.compute_coverage,
diff --git a/testsuite/smoke-test/Cargo.toml b/testsuite/smoke-test/Cargo.toml
index 1bc3258edc5d6..f68bbd07def3e 100644
--- a/testsuite/smoke-test/Cargo.toml
+++ b/testsuite/smoke-test/Cargo.toml
@@ -24,8 +24,8 @@ aptos-debugger = { workspace = true }
 aptos-faucet-core = { workspace = true }
 aptos-forge = { workspace = true }
 aptos-framework = { workspace = true }
-aptos-gas = { workspace = true, features = ["testing"] }
 aptos-gas-algebra = { workspace = true }
+aptos-gas-schedule = { workspace = true }
 aptos-global-constants = { workspace = true }
 aptos-indexer = { workspace = true }
 aptos-keygen = { workspace = true }
diff --git a/testsuite/smoke-test/src/rosetta.rs b/testsuite/smoke-test/src/rosetta.rs
index 413605d14805c..b3722e8f90b1d 100644
--- a/testsuite/smoke-test/src/rosetta.rs
+++ b/testsuite/smoke-test/src/rosetta.rs
@@ -15,7 +15,7 @@ use aptos_crypto::{
     HashValue, PrivateKey,
 };
 use aptos_forge::{AptosPublicInfo, LocalSwarm, Node, NodeExt, Swarm};
-use aptos_gas::{AptosGasParameters, FromOnChainGasSchedule};
+use aptos_gas_schedule::{AptosGasParameters, FromOnChainGasSchedule};
 use aptos_genesis::builder::InitConfigFn;
 use aptos_global_constants::GAS_UNIT_PRICE;
 use aptos_rest_client::{
@@ -728,7 +728,7 @@ async fn test_block() {
         feature_version,
     )
     .unwrap();
-    let min_gas_price = u64::from(gas_params.txn.min_price_per_gas_unit);
+    let min_gas_price = u64::from(gas_params.vm.txn.min_price_per_gas_unit);
 
     let private_key_0 = cli.private_key(0);
     let private_key_1 = cli.private_key(1);
diff --git a/testsuite/smoke-test/src/upgrade.rs b/testsuite/smoke-test/src/upgrade.rs
index 17543544da4f4..47e4dc47e07ed 100644
--- a/testsuite/smoke-test/src/upgrade.rs
+++ b/testsuite/smoke-test/src/upgrade.rs
@@ -7,8 +7,8 @@ use crate::{
 };
 use aptos_crypto::ValidCryptoMaterialStringExt;
 use aptos_forge::Swarm;
-use aptos_gas::{AptosGasParameters, InitialGasSchedule, ToOnChainGasSchedule};
 use aptos_gas_algebra::GasQuantity;
+use aptos_gas_schedule::{AptosGasParameters, InitialGasSchedule, ToOnChainGasSchedule};
 use aptos_release_builder::{
     components::{
         feature_flags::{FeatureFlag, Features},
@@ -50,11 +50,12 @@ async fn test_upgrade_flow() {
     // Bump the limit in gas schedule
     // TODO: Replace this logic with aptos-gas
     let mut gas_parameters = AptosGasParameters::initial();
-    gas_parameters.txn.max_transaction_size_in_bytes = GasQuantity::new(100_000_000);
+    gas_parameters.vm.txn.max_transaction_size_in_bytes = GasQuantity::new(100_000_000);
 
     let gas_schedule = aptos_types::on_chain_config::GasScheduleV2 {
-        feature_version: aptos_gas::LATEST_GAS_FEATURE_VERSION,
-        entries: gas_parameters.to_on_chain_gas_schedule(aptos_gas::LATEST_GAS_FEATURE_VERSION),
+        feature_version: aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION,
+        entries: gas_parameters
+            .to_on_chain_gas_schedule(aptos_gas_schedule::LATEST_GAS_FEATURE_VERSION),
     };
 
     let (_, update_gas_script) =
diff --git a/third_party/move/move-core/types/src/gas_algebra.rs b/third_party/move/move-core/types/src/gas_algebra.rs
index 1c2a0b4c1a273..3a74479d6df68 100644
--- a/third_party/move/move-core/types/src/gas_algebra.rs
+++ b/third_party/move/move-core/types/src/gas_algebra.rs
@@ -421,3 +421,12 @@ impl<U> GasQuantity<U> {
         GasQuantity::new(apply_ratio_round_up(self.val, n, d))
     }
 }
+/***************************************************************************************************
+ * Per Unit
+ *
+ **************************************************************************************************/
+impl<U1> GasQuantity<U1> {
+    pub fn per<U2>(self) -> GasQuantity<UnitDiv<U1, U2>> {
+        GasQuantity::new(self.into())
+    }
+}
diff --git a/types/Cargo.toml b/types/Cargo.toml
index fb27effe6cddf..a1b57b59f377e 100644
--- a/types/Cargo.toml
+++ b/types/Cargo.toml
@@ -24,7 +24,6 @@ derivative = { workspace = true }
 hex = { workspace = true }
 itertools = { workspace = true }
 move-core-types = { workspace = true }
-move-table-extension = { workspace = true }
 num-derive = { workspace = true }
 num-traits = { workspace = true }
 once_cell = { workspace = true }
diff --git a/types/src/state_store/table.rs b/types/src/state_store/table.rs
index bade243389a61..f6f9c762e936c 100644
--- a/types/src/state_store/table.rs
+++ b/types/src/state_store/table.rs
@@ -27,12 +27,6 @@ impl FromStr for TableHandle {
     }
 }
 
-impl From<move_table_extension::TableHandle> for TableHandle {
-    fn from(hdl: move_table_extension::TableHandle) -> Self {
-        Self(hdl.0)
-    }
-}
-
 #[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize)]
 #[cfg_attr(any(test, feature = "fuzzing"), derive(proptest_derive::Arbitrary))]
 pub struct TableInfo {
diff --git a/vm-validator/Cargo.toml b/vm-validator/Cargo.toml
index 967b2b7b26b2e..40d708bdb0702 100644
--- a/vm-validator/Cargo.toml
+++ b/vm-validator/Cargo.toml
@@ -14,7 +14,7 @@ rust-version = { workspace = true }
 
 [dependencies]
 anyhow = { workspace = true }
-aptos-gas = { workspace = true }
+aptos-gas-meter = { workspace = true }
 aptos-scratchpad = { workspace = true }
 aptos-state-view = { workspace = true }
 aptos-storage-interface = { workspace = true }
@@ -27,7 +27,7 @@ aptos-cached-packages = { workspace = true }
 aptos-crypto = { workspace = true }
 aptos-db = { workspace = true }
 aptos-executor-test-helpers = { workspace = true }
-aptos-gas = { workspace = true, features = ["testing"] }
+aptos-gas-schedule = { workspace = true }
 aptos-temppath = { workspace = true }
 aptos-types = { workspace = true }
 aptos-vm = { workspace = true }
diff --git a/vm-validator/src/unit_tests/vm_validator_test.rs b/vm-validator/src/unit_tests/vm_validator_test.rs
index ecf7162f6b366..a67d18f1d85f6 100644
--- a/vm-validator/src/unit_tests/vm_validator_test.rs
+++ b/vm-validator/src/unit_tests/vm_validator_test.rs
@@ -6,7 +6,7 @@ use crate::vm_validator::{get_account_sequence_number, TransactionValidation, VM
 use aptos_cached_packages::aptos_stdlib;
 use aptos_crypto::{ed25519::Ed25519PrivateKey, PrivateKey, Uniform};
 use aptos_db::AptosDB;
-use aptos_gas::{InitialGasSchedule, TransactionGasParameters};
+use aptos_gas_schedule::{InitialGasSchedule, TransactionGasParameters};
 use aptos_storage_interface::{state_view::LatestDbStateCheckpointView, DbReaderWriter};
 use aptos_types::{
     account_address, account_config,
@@ -16,7 +16,7 @@ use aptos_types::{
     vm_status::StatusCode,
 };
 use aptos_vm::AptosVM;
-use move_core_types::account_address::AccountAddress;
+use move_core_types::{account_address::AccountAddress, gas_algebra::GasQuantity};
 use rand::SeedableRng;
 
 const MAX_TRANSACTION_SIZE_IN_BYTES: u64 = 6 * 1024 * 1024;
@@ -175,9 +175,10 @@ fn test_validate_max_gas_units_below_min() {
     // external gas units.
     let txn_gas_params = TransactionGasParameters::initial();
     let txn_bytes = txn_gas_params.large_transaction_cutoff
-        + (u64::from(txn_gas_params.gas_unit_scaling_factor)
-            / u64::from(txn_gas_params.intrinsic_gas_per_byte))
-        .into();
+        + GasQuantity::from(
+            u64::from(txn_gas_params.gas_unit_scaling_factor)
+                / u64::from(txn_gas_params.intrinsic_gas_per_byte),
+        );
     let transaction = transaction_test_helpers::get_test_signed_transaction(
         address,
         1,

From 16845b906857825eb47e1d333cec359d6f520fc4 Mon Sep 17 00:00:00 2001
From: "zhoujun.ma" <zhoujun@aptoslabs.com>
Date: Thu, 13 Jul 2023 17:52:25 -0700
Subject: [PATCH 4/4] update algebra gas script

---
 .../src/gas_schedule/aptos_framework.rs       |  2 +-
 scripts/algebra-gas/README.md                 |  4 ++--
 .../algebra-gas/update_algebra_gas_params.py  | 21 +++++++++++++------
 3 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/aptos-move/aptos-gas-schedule/src/gas_schedule/aptos_framework.rs b/aptos-move/aptos-gas-schedule/src/gas_schedule/aptos_framework.rs
index 5c7f2d801691f..9828f2eb8cc03 100644
--- a/aptos-move/aptos-gas-schedule/src/gas_schedule/aptos_framework.rs
+++ b/aptos-move/aptos-gas-schedule/src/gas_schedule/aptos_framework.rs
@@ -17,7 +17,7 @@ crate::gas_schedule::macros::define_gas_parameters!(
         [account_create_signer_base: InternalGas, "account.create_signer.base", 6000],
 
         // Algebra gas parameters begin.
-        // Generated at time 1680606720.0709136 by `scripts/algebra-gas/update_algebra_gas_params.py` with gas_per_ns=10.23.
+        // Generated at time 1680606720.0709136 by `scripts/algebra-gas/update_algebra_gas_params.py` with gas_per_ns=204.6.
         [algebra_ark_bls12_381_fq12_add: InternalGas, { 8.. => "algebra.ark_bls12_381_fq12_add" }, 36380],
         [algebra_ark_bls12_381_fq12_clone: InternalGas, { 8.. => "algebra.ark_bls12_381_fq12_clone" }, 4220],
         [algebra_ark_bls12_381_fq12_deser: InternalGas, { 8.. => "algebra.ark_bls12_381_fq12_deser" }, 223600],
diff --git a/scripts/algebra-gas/README.md b/scripts/algebra-gas/README.md
index 77388fa7db306..dcdf908b076ec 100644
--- a/scripts/algebra-gas/README.md
+++ b/scripts/algebra-gas/README.md
@@ -28,8 +28,8 @@ Value `k` and `b` should be printed.
 {"b": 336.51096106242346, "k": 4.868293006038344}
 ```
 
-Combined with the [pre-defined](https://github.com/aptos-labs/aptos-core/blob/28df4c1f0ea0d6c6dc6b0460257aa9086e830d1a/aptos-move/aptos-gas/src/move_stdlib.rs#L17-L18) SHA2-256 gas formula (unscaled internal gas):`g(n)=50n+3000`,
-it can be calculated that `gas_per_ns = 50/k`.
+Combined with the [pre-defined](https://github.com/aptos-labs/aptos-core/blob/28df4c1f0ea0d6c6dc6b0460257aa9086e830d1a/aptos-move/aptos-gas/src/move_stdlib.rs#L17-L18) SHA2-256 gas formula (internal gas):`g(n)=1000n+60000`,
+it can be calculated that `gas_per_ns = 1000/k`.
 
 Second last, go to `scripts/algebra-gas/update_algebra_gas_params.py`
 and update the value of the global variable `TARGET_GAS_VERSION` if necessary.
diff --git a/scripts/algebra-gas/update_algebra_gas_params.py b/scripts/algebra-gas/update_algebra_gas_params.py
index 2eb69aa21cfb4..dc66025ad5bd2 100755
--- a/scripts/algebra-gas/update_algebra_gas_params.py
+++ b/scripts/algebra-gas/update_algebra_gas_params.py
@@ -12,6 +12,7 @@
 import load_bench_datapoints
 from math import ceil
 from pathlib import Path
+from re
 from time import time
 
 # Typically you are making a new version of gas schedule,
@@ -31,6 +32,14 @@ def prettify_number(x:int) -> str:
     chunks = chunks_0 + [s[i:i+3] for i in range(b,n,3)]
     return '_'.join(chunks)
 
+def get_gas_param_type(param_name):
+    if param_name == 'ark_bls12_381_multi_pairing_per_pair':
+        return 'InternalGasPerArg'
+    elif re.match(r'^ark_h2c_bls12381g(1|2)_xmd_sha256_sswu_per_msg_byte$', param_name):
+        return 'InternalGasPerByte'
+    else:
+        return 'InternalGas'
+
 def get_algebra_lines(gas_per_ns):
     nanoseconds = {}
     nanoseconds['ark_bls12_381_fr_add'] = load_bench_ns.main('target/criterion/ark_bls12_381/fr_add')
@@ -92,21 +101,21 @@ def get_algebra_lines(gas_per_ns):
     _,_,nanoseconds['ark_h2c_bls12381g1_xmd_sha256_sswu_per_msg_byte'],nanoseconds['ark_h2c_bls12381g1_xmd_sha256_sswu_base'] = get_bench_ns_linear('target/criterion/ark_bls12_381/hash_to_g1_proj')
     _,_,nanoseconds['ark_h2c_bls12381g2_xmd_sha256_sswu_per_msg_byte'],nanoseconds['ark_h2c_bls12381g2_xmd_sha256_sswu_base'] = get_bench_ns_linear('target/criterion/ark_bls12_381/hash_to_g2_proj')
     gas_units = {k:gas_per_ns*v for k,v in nanoseconds.items()}
-    lines = [f'    [.algebra.{k}, {{ {TARGET_GAS_VERSION}.. => "algebra.{k}" }}, {prettify_number(v)} * MUL],' for k,v in sorted(gas_units.items())]
+    lines = [f'        [algebra_{k}: {get_gas_param_type(k)}, {{ {TARGET_GAS_VERSION}.. => "algebra.{k}" }}, {prettify_number(v)}],' for k,v in sorted(gas_units.items())]
     return lines
 
 def main(gas_per_ns):
-    path = Path('aptos-move/aptos-gas/src/aptos_framework.rs')
+    path = Path('aptos-move/aptos-gas-schedule/src/gas_schedule/aptos_framework.rs')
     lines = path.read_text().split('\n')
-    line_id_begin = lines.index('    // Algebra gas parameters begin.')
-    line_id_end = lines.index('    // Algebra gas parameters end.')
-    generator_note_line = f'    // Generated at time {time()} by `scripts/algebra-gas/update_algebra_gas_params.py` with gas_per_ns={gas_per_ns}.'
+    line_id_begin = lines.index('        // Algebra gas parameters begin.')
+    line_id_end = lines.index('        // Algebra gas parameters end.')
+    generator_note_line = f'        // Generated at time {time()} by `scripts/algebra-gas/update_algebra_gas_params.py` with gas_per_ns={gas_per_ns}.'
     new_lines = lines[:line_id_begin+1] + [generator_note_line] + get_algebra_lines(gas_per_ns) + lines[line_id_end:]
     path.write_text('\n'.join(new_lines))
 
 if __name__=='__main__':
     parser = argparse.ArgumentParser(
-        description='Generate gas parameters for algebra module in `aptos-move/aptos-gas/src/aptos_framework.rs`.')
+        description='Generate gas parameters for algebra module in `aptos-move/aptos-gas-schedule/src/gas_schedule/aptos_framework.rs`.')
     parser.add_argument('--gas_per_ns', required=True, type=float)
     args = parser.parse_args()
     main(args.gas_per_ns)