refactor: Rename sfield names, sfExtensionComputeLimit -> sfGasLimit, sfExtensionSizeLimit -> sfBytecodeSizeLimit (#7708)

2026-07-23 15:10:34 +00:00 · 2026-07-08 16:26:58 -04:00
parent 4a01fe5aa6
commit 2e48bb4b7f
21 changed files with 249 additions and 262 deletions
--- a/cfg/xrpld-example.cfg
+++ b/cfg/xrpld-example.cfg
@@ -1283,9 +1283,9 @@
 #       Example:
 #           owner_reserve = 200000      # 0.2 XRP
 #
-#   extension_compute_limit = <gas>
+#   gas_limit = <gas>
 #
-#       The extension compute limit is the maximum amount of gas that can be
+#       The gas limit is the maximum amount of gas that can be
 #       consumed by a single transaction. The gas limit is used to prevent
 #       transactions from consuming too many resources.
 #
@@ -1293,11 +1293,11 @@
 #       default. Don't change this without understanding the consequences.
 #
 #       Example:
-#           extension_compute_limit = 1000000      # 1 million gas
+#           gas_limit = 1000000      # 1 million gas
 #
-#   extension_size_limit = <bytes>
+#   bytecode_size_limit = <bytes>
 #
-#       The extension size limit is the maximum size of a WASM extension in
+#       The bytecode size limit is the maximum size of a WASM extension in
 #       bytes. The size limit is used to prevent extensions from consuming
 #       too many resources.
 #
@@ -1305,7 +1305,7 @@
 #       default. Don't change this without understanding the consequences.
 #
 #       Example:
-#           extension_size_limit = 100000      # 100 kb
+#           bytecode_size_limit = 100000      # 100 kb
 #
 #   gas_price = <micro-drops>
 #
--- a/include/xrpl/protocol/Fees.h
+++ b/include/xrpl/protocol/Fees.h
@@ -14,8 +14,8 @@ inline constexpr std::uint32_t kFeeUnitsDeprecated = 10;
 constexpr std::uint32_t microDropsPerDrop{1'000'000};

 /** Maximum Feature Extension fee settings. */
-inline constexpr std::uint32_t kMaxExtensionComputeLimit{2'000'000};
-inline constexpr std::uint32_t kMaxExtensionSizeLimit{200'000};
+inline constexpr std::uint32_t kMaxGasLimit{2'000'000};
+inline constexpr std::uint32_t kMaxBytecodeSizeLimit{200'000};

 /** Reflects the fee settings for a particular ledger.

@@ -33,11 +33,11 @@ struct Fees
    /** @brief Additional XRP reserve required per owned ledger object. */
    XRPAmount increment{0};

-    /** @brief Compute limit for Feature Extensions (instructions). */
-    std::uint32_t extensionComputeLimit{0};
+    /** @brief Gas limit for Feature Extensions (instructions). */
+    std::uint32_t gasLimit{0};

-    /** @brief Size limit for Feature Extensions (bytes). */
-    std::uint32_t extensionSizeLimit{0};
+    /** @brief Bytecode size limit for Feature Extensions (bytes). */
+    std::uint32_t bytecodeSizeLimit{0};

    /** @brief Price of WASM gas (micro-drops). */
    std::uint32_t gasPrice{0};
--- a/include/xrpl/protocol/detail/ledger_entries.macro
+++ b/include/xrpl/protocol/detail/ledger_entries.macro
@@ -305,8 +305,8 @@ LEDGER_ENTRY(ltFEE_SETTINGS, 0x0073, FeeSettings, fee, ({
    {sfReserveBaseDrops,       SoeOptional},
    {sfReserveIncrementDrops,  SoeOptional},
    // Smart Escrow fields
-    {sfExtensionComputeLimit,  SoeOptional},
-    {sfExtensionSizeLimit,     SoeOptional},
+    {sfGasLimit,               SoeOptional},
+    {sfBytecodeSizeLimit,      SoeOptional},
    {sfGasPrice,               SoeOptional},

    {sfPreviousTxnID,          SoeOptional},
--- a/include/xrpl/protocol/detail/sfields.macro
+++ b/include/xrpl/protocol/detail/sfields.macro
@@ -113,8 +113,8 @@ TYPED_SFIELD(sfInterestRate,             UINT32,    65) // 1/10 basis points (bi
 TYPED_SFIELD(sfLateInterestRate,         UINT32,    66) // 1/10 basis points (bips)
 TYPED_SFIELD(sfCloseInterestRate,        UINT32,    67) // 1/10 basis points (bips)
 TYPED_SFIELD(sfOverpaymentInterestRate,  UINT32,    68) // 1/10 basis points (bips)
-TYPED_SFIELD(sfExtensionComputeLimit,    UINT32,    69)
-TYPED_SFIELD(sfExtensionSizeLimit,       UINT32,    70)
+TYPED_SFIELD(sfGasLimit,                 UINT32,    69)
+TYPED_SFIELD(sfBytecodeSizeLimit,        UINT32,    70)
 TYPED_SFIELD(sfGasPrice,                 UINT32,    71)

 // 64-bit integers (common)
--- a/include/xrpl/protocol/detail/transactions.macro
+++ b/include/xrpl/protocol/detail/transactions.macro
@@ -1111,8 +1111,8 @@ TRANSACTION(ttFEE, 101, SetFee,
    {sfReserveBaseDrops, SoeOptional},
    {sfReserveIncrementDrops, SoeOptional},
    // Smart Escrow fields
-    {sfExtensionComputeLimit, SoeOptional},
-    {sfExtensionSizeLimit, SoeOptional},
+    {sfGasLimit, SoeOptional},
+    {sfBytecodeSizeLimit, SoeOptional},
    {sfGasPrice, SoeOptional},
 }))

--- a/include/xrpl/protocol/jss.h
+++ b/include/xrpl/protocol/jss.h
@@ -248,8 +248,8 @@ JSS(expected_date);               // out: any (warnings)
 JSS(expected_date_UTC);           // out: any (warnings)
 JSS(expected_ledger_size);        // out: TxQ
 JSS(expiration);                  // out: AccountOffers, AccountChannels, ValidatorList, amm_info
-JSS(extension_compute);           // out: NetworkOPs
-JSS(extension_size);              // out: NetworkOPs
+JSS(gas_limit);                   // out: NetworkOPs
+JSS(bytecode_size_limit);         // out: NetworkOPs
 JSS(gas_price);                   // out: NetworkOPs
 JSS(fail_hard);                   // in: Sign, Submit
 JSS(failed);                      // out: InboundLedger
--- a/include/xrpl/protocol_autogen/ledger_entries/FeeSettings.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/FeeSettings.h
@@ -214,51 +214,51 @@ public:
    }

    /**
-     * @brief Get sfExtensionComputeLimit (SoeOptional)
+     * @brief Get sfGasLimit (SoeOptional)
     * @return The field value, or std::nullopt if not present.
     */
    [[nodiscard]]
    protocol_autogen::Optional<SF_UINT32::type::value_type>
-    getExtensionComputeLimit() const
+    getGasLimit() const
    {
-        if (hasExtensionComputeLimit())
-            return this->sle_->at(sfExtensionComputeLimit);
+        if (hasGasLimit())
+            return this->sle_->at(sfGasLimit);
        return std::nullopt;
    }

    /**
-     * @brief Check if sfExtensionComputeLimit is present.
+     * @brief Check if sfGasLimit is present.
     * @return True if the field is present, false otherwise.
     */
    [[nodiscard]]
    bool
-    hasExtensionComputeLimit() const
+    hasGasLimit() const
    {
-        return this->sle_->isFieldPresent(sfExtensionComputeLimit);
+        return this->sle_->isFieldPresent(sfGasLimit);
    }

    /**
-     * @brief Get sfExtensionSizeLimit (SoeOptional)
+     * @brief Get sfBytecodeSizeLimit (SoeOptional)
     * @return The field value, or std::nullopt if not present.
     */
    [[nodiscard]]
    protocol_autogen::Optional<SF_UINT32::type::value_type>
-    getExtensionSizeLimit() const
+    getBytecodeSizeLimit() const
    {
-        if (hasExtensionSizeLimit())
-            return this->sle_->at(sfExtensionSizeLimit);
+        if (hasBytecodeSizeLimit())
+            return this->sle_->at(sfBytecodeSizeLimit);
        return std::nullopt;
    }

    /**
-     * @brief Check if sfExtensionSizeLimit is present.
+     * @brief Check if sfBytecodeSizeLimit is present.
     * @return True if the field is present, false otherwise.
     */
    [[nodiscard]]
    bool
-    hasExtensionSizeLimit() const
+    hasBytecodeSizeLimit() const
    {
-        return this->sle_->isFieldPresent(sfExtensionSizeLimit);
+        return this->sle_->isFieldPresent(sfBytecodeSizeLimit);
    }

    /**
@@ -446,24 +446,24 @@ public:
    }

    /**
-     * @brief Set sfExtensionComputeLimit (SoeOptional)
+     * @brief Set sfGasLimit (SoeOptional)
     * @return Reference to this builder for method chaining.
     */
    FeeSettingsBuilder&
-    setExtensionComputeLimit(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    setGasLimit(std::decay_t<typename SF_UINT32::type::value_type> const& value)
    {
-        object_[sfExtensionComputeLimit] = value;
+        object_[sfGasLimit] = value;
        return *this;
    }

    /**
-     * @brief Set sfExtensionSizeLimit (SoeOptional)
+     * @brief Set sfBytecodeSizeLimit (SoeOptional)
     * @return Reference to this builder for method chaining.
     */
    FeeSettingsBuilder&
-    setExtensionSizeLimit(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    setBytecodeSizeLimit(std::decay_t<typename SF_UINT32::type::value_type> const& value)
    {
-        object_[sfExtensionSizeLimit] = value;
+        object_[sfBytecodeSizeLimit] = value;
        return *this;
    }

--- a/include/xrpl/protocol_autogen/transactions/SetFee.h
+++ b/include/xrpl/protocol_autogen/transactions/SetFee.h
@@ -256,55 +256,55 @@ public:
    }

    /**
-     * @brief Get sfExtensionComputeLimit (SoeOptional)
+     * @brief Get sfGasLimit (SoeOptional)
     * @return The field value, or std::nullopt if not present.
     */
    [[nodiscard]]
    protocol_autogen::Optional<SF_UINT32::type::value_type>
-    getExtensionComputeLimit() const
+    getGasLimit() const
    {
-        if (hasExtensionComputeLimit())
+        if (hasGasLimit())
        {
-            return this->tx_->at(sfExtensionComputeLimit);
+            return this->tx_->at(sfGasLimit);
        }
        return std::nullopt;
    }

    /**
-     * @brief Check if sfExtensionComputeLimit is present.
+     * @brief Check if sfGasLimit is present.
     * @return True if the field is present, false otherwise.
     */
    [[nodiscard]]
    bool
-    hasExtensionComputeLimit() const
+    hasGasLimit() const
    {
-        return this->tx_->isFieldPresent(sfExtensionComputeLimit);
+        return this->tx_->isFieldPresent(sfGasLimit);
    }

    /**
-     * @brief Get sfExtensionSizeLimit (SoeOptional)
+     * @brief Get sfBytecodeSizeLimit (SoeOptional)
     * @return The field value, or std::nullopt if not present.
     */
    [[nodiscard]]
    protocol_autogen::Optional<SF_UINT32::type::value_type>
-    getExtensionSizeLimit() const
+    getBytecodeSizeLimit() const
    {
-        if (hasExtensionSizeLimit())
+        if (hasBytecodeSizeLimit())
        {
-            return this->tx_->at(sfExtensionSizeLimit);
+            return this->tx_->at(sfBytecodeSizeLimit);
        }
        return std::nullopt;
    }

    /**
-     * @brief Check if sfExtensionSizeLimit is present.
+     * @brief Check if sfBytecodeSizeLimit is present.
     * @return True if the field is present, false otherwise.
     */
    [[nodiscard]]
    bool
-    hasExtensionSizeLimit() const
+    hasBytecodeSizeLimit() const
    {
-        return this->tx_->isFieldPresent(sfExtensionSizeLimit);
+        return this->tx_->isFieldPresent(sfBytecodeSizeLimit);
    }

    /**
@@ -463,24 +463,24 @@ public:
    }

    /**
-     * @brief Set sfExtensionComputeLimit (SoeOptional)
+     * @brief Set sfGasLimit (SoeOptional)
     * @return Reference to this builder for method chaining.
     */
    SetFeeBuilder&
-    setExtensionComputeLimit(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    setGasLimit(std::decay_t<typename SF_UINT32::type::value_type> const& value)
    {
-        object_[sfExtensionComputeLimit] = value;
+        object_[sfGasLimit] = value;
        return *this;
    }

    /**
-     * @brief Set sfExtensionSizeLimit (SoeOptional)
+     * @brief Set sfBytecodeSizeLimit (SoeOptional)
     * @return Reference to this builder for method chaining.
     */
    SetFeeBuilder&
-    setExtensionSizeLimit(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    setBytecodeSizeLimit(std::decay_t<typename SF_UINT32::type::value_type> const& value)
    {
-        object_[sfExtensionSizeLimit] = value;
+        object_[sfBytecodeSizeLimit] = value;
        return *this;
    }

--- a/src/libxrpl/ledger/Ledger.cpp
+++ b/src/libxrpl/ledger/Ledger.cpp
@@ -200,8 +200,8 @@ Ledger::Ledger(
        }
        if (std::ranges::find(amendments, featureSmartEscrow) != amendments.end())
        {
-            sle->at(sfExtensionComputeLimit) = fees.extensionComputeLimit;
-            sle->at(sfExtensionSizeLimit) = fees.extensionSizeLimit;
+            sle->at(sfGasLimit) = fees.gasLimit;
+            sle->at(sfBytecodeSizeLimit) = fees.bytecodeSizeLimit;
            sle->at(sfGasPrice) = fees.gasPrice;
        }
        rawInsert(sle);
@@ -607,8 +607,8 @@ Ledger::setup()
                newFees = baseFeeXRP || reserveBaseXRP || reserveIncrementXRP;
            }
            {
-                auto const extensionComputeLimit = sle->at(~sfExtensionComputeLimit);
-                auto const extensionSizeLimit = sle->at(~sfExtensionSizeLimit);
+                auto const gasLimit = sle->at(~sfGasLimit);
+                auto const bytecodeSizeLimit = sle->at(~sfBytecodeSizeLimit);
                auto const gasPrice = sle->at(~sfGasPrice);

                auto assign = [](std::uint32_t& dest, std::optional<std::uint32_t> const& src) {
@@ -617,10 +617,10 @@ Ledger::setup()
                        dest = src.value();
                    }
                };
-                assign(fees_.extensionComputeLimit, extensionComputeLimit);
-                assign(fees_.extensionSizeLimit, extensionSizeLimit);
+                assign(fees_.gasLimit, gasLimit);
+                assign(fees_.bytecodeSizeLimit, bytecodeSizeLimit);
                assign(fees_.gasPrice, gasPrice);
-                extensionFees = extensionComputeLimit || extensionSizeLimit || gasPrice;
+                extensionFees = gasLimit || bytecodeSizeLimit || gasPrice;
            }
            if (oldFees && newFees)
            {
--- a/src/libxrpl/protocol/STValidation.cpp
+++ b/src/libxrpl/protocol/STValidation.cpp
@@ -60,8 +60,8 @@ STValidation::validationFormat()
        {sfReserveBaseDrops,      SoeOptional},
        {sfReserveIncrementDrops, SoeOptional},
        // featureSmartEscrow
-        {sfExtensionComputeLimit,  SoeOptional},
-        {sfExtensionSizeLimit,     SoeOptional},
+        {sfGasLimit,               SoeOptional},
+        {sfBytecodeSizeLimit,      SoeOptional},
        {sfGasPrice,               SoeOptional},
    };
    // clang-format on
--- a/src/libxrpl/tx/transactors/system/Change.cpp
+++ b/src/libxrpl/tx/transactors/system/Change.cpp
@@ -126,19 +126,18 @@ Change::preclaim(PreclaimContext const& ctx)
            }
            if (ctx.view.rules().enabled(featureSmartEscrow))
            {
-                if (!ctx.tx.isFieldPresent(sfExtensionComputeLimit) ||
-                    !ctx.tx.isFieldPresent(sfExtensionSizeLimit) ||
+                if (!ctx.tx.isFieldPresent(sfGasLimit) ||
+                    !ctx.tx.isFieldPresent(sfBytecodeSizeLimit) ||
                    !ctx.tx.isFieldPresent(sfGasPrice))
                    return temMALFORMED;
-                if (ctx.tx[sfExtensionComputeLimit] > kMaxExtensionComputeLimit ||
-                    ctx.tx[sfExtensionSizeLimit] > kMaxExtensionSizeLimit)
+                if (ctx.tx[sfGasLimit] > kMaxGasLimit ||
+                    ctx.tx[sfBytecodeSizeLimit] > kMaxBytecodeSizeLimit)
                    return temBAD_FEE;
            }
            else
            {
-                if (ctx.tx.isFieldPresent(sfExtensionComputeLimit) ||
-                    ctx.tx.isFieldPresent(sfExtensionSizeLimit) ||
-                    ctx.tx.isFieldPresent(sfGasPrice))
+                if (ctx.tx.isFieldPresent(sfGasLimit) ||
+                    ctx.tx.isFieldPresent(sfBytecodeSizeLimit) || ctx.tx.isFieldPresent(sfGasPrice))
                    return temDISABLED;
            }
            return tesSUCCESS;
@@ -304,8 +303,8 @@ Change::applyFee()
    }
    if (view().rules().enabled(featureSmartEscrow))
    {
-        set(feeObject, ctx_.tx, sfExtensionComputeLimit);
-        set(feeObject, ctx_.tx, sfExtensionSizeLimit);
+        set(feeObject, ctx_.tx, sfGasLimit);
+        set(feeObject, ctx_.tx, sfBytecodeSizeLimit);
        set(feeObject, ctx_.tx, sfGasPrice);
    }

--- a/src/test/app/FeeVote_test.cpp
+++ b/src/test/app/FeeVote_test.cpp
@@ -48,8 +48,8 @@ struct FeeSettingsFields
    std::optional<XRPAmount> baseFeeDrops = std::nullopt;
    std::optional<XRPAmount> reserveBaseDrops = std::nullopt;
    std::optional<XRPAmount> reserveIncrementDrops = std::nullopt;
-    std::optional<std::uint32_t> extensionComputeLimit = std::nullopt;
-    std::optional<std::uint32_t> extensionSizeLimit = std::nullopt;
+    std::optional<std::uint32_t> gasLimit = std::nullopt;
+    std::optional<std::uint32_t> bytecodeSizeLimit = std::nullopt;
    std::optional<std::uint32_t> gasPrice = std::nullopt;
 };

@@ -88,11 +88,9 @@ createFeeTx(
        }
        if (rules.enabled(featureSmartEscrow) || forceAllFields)
        {
+            obj.setFieldU32(sfGasLimit, fields.gasLimit ? *fields.gasLimit : 0);
            obj.setFieldU32(
-                sfExtensionComputeLimit,
-                fields.extensionComputeLimit ? *fields.extensionComputeLimit : 0);
-            obj.setFieldU32(
-                sfExtensionSizeLimit, fields.extensionSizeLimit ? *fields.extensionSizeLimit : 0);
+                sfBytecodeSizeLimit, fields.bytecodeSizeLimit ? *fields.bytecodeSizeLimit : 0);
            obj.setFieldU32(sfGasPrice, fields.gasPrice ? *fields.gasPrice : 0);
        }
    };
@@ -145,8 +143,8 @@ createInvalidFeeTx(
            }
            if (rules.enabled(featureSmartEscrow))
            {
-                obj.setFieldU32(sfExtensionComputeLimit, 100 + uniqueValue);
-                obj.setFieldU32(sfExtensionSizeLimit, 200 + uniqueValue);
+                obj.setFieldU32(sfGasLimit, 100 + uniqueValue);
+                obj.setFieldU32(sfBytecodeSizeLimit, 200 + uniqueValue);
                obj.setFieldU32(sfGasPrice, 300 + uniqueValue);
            }
        }
@@ -213,18 +211,17 @@ verifyFeeObject(
    }
    if (rules.enabled(featureSmartEscrow))
    {
-        if (!checkEquality(sfExtensionComputeLimit, expected.extensionComputeLimit.value_or(0)))
+        if (!checkEquality(sfGasLimit, expected.gasLimit.value_or(0)))
            return false;
-        if (!checkEquality(sfExtensionSizeLimit, expected.extensionSizeLimit.value_or(0)))
+        if (!checkEquality(sfBytecodeSizeLimit, expected.bytecodeSizeLimit.value_or(0)))
            return false;
        if (!checkEquality(sfGasPrice, expected.gasPrice.value_or(0)))
            return false;
    }
    else
    {
-        if (feeObject->isFieldPresent(sfExtensionComputeLimit) ||
-            feeObject->isFieldPresent(sfExtensionSizeLimit) ||
-            feeObject->isFieldPresent(sfGasPrice))
+        if (feeObject->isFieldPresent(sfGasLimit) ||
+            feeObject->isFieldPresent(sfBytecodeSizeLimit) || feeObject->isFieldPresent(sfGasPrice))
            return false;
    }

@@ -258,8 +255,8 @@ class FeeVote_test : public beast::unit_test::Suite
            BEAST_EXPECT(setup.reference_fee == defaultSetup.reference_fee);
            BEAST_EXPECT(setup.account_reserve == defaultSetup.account_reserve);
            BEAST_EXPECT(setup.owner_reserve == defaultSetup.owner_reserve);
-            BEAST_EXPECT(setup.extension_compute_limit == defaultSetup.extension_compute_limit);
-            BEAST_EXPECT(setup.extension_size_limit == defaultSetup.extension_size_limit);
+            BEAST_EXPECT(setup.gas_limit == defaultSetup.gas_limit);
+            BEAST_EXPECT(setup.bytecode_size_limit == defaultSetup.bytecode_size_limit);
            BEAST_EXPECT(setup.gas_price == defaultSetup.gas_price);
        }
        {
@@ -268,15 +265,15 @@ class FeeVote_test : public beast::unit_test::Suite
                {"reference_fee = 50",
                 "account_reserve = 1234567",
                 "owner_reserve = 1234",
-                 "extension_compute_limit = 100",
-                 "extension_size_limit = 200",
+                 "gas_limit = 100",
+                 "bytecode_size_limit = 200",
                 "gas_price = 300"});
            auto setup = setupFeeVote(config);
            BEAST_EXPECT(setup.reference_fee == 50);
            BEAST_EXPECT(setup.account_reserve == 1234567);
            BEAST_EXPECT(setup.owner_reserve == 1234);
-            BEAST_EXPECT(setup.extension_compute_limit == 100);
-            BEAST_EXPECT(setup.extension_size_limit == 200);
+            BEAST_EXPECT(setup.gas_limit == 100);
+            BEAST_EXPECT(setup.bytecode_size_limit == 200);
            BEAST_EXPECT(setup.gas_price == 300);
        }
        {
@@ -285,16 +282,16 @@ class FeeVote_test : public beast::unit_test::Suite
                {"reference_fee = blah",
                 "account_reserve = yada",
                 "owner_reserve = foo",
-                 "extension_compute_limit = bar",
-                 "extension_size_limit = baz",
+                 "gas_limit = bar",
+                 "bytecode_size_limit = baz",
                 "gas_price = qux"});
            // Illegal values are ignored, and the defaults left unchanged
            auto setup = setupFeeVote(config);
            BEAST_EXPECT(setup.reference_fee == defaultSetup.reference_fee);
            BEAST_EXPECT(setup.account_reserve == defaultSetup.account_reserve);
            BEAST_EXPECT(setup.owner_reserve == defaultSetup.owner_reserve);
-            BEAST_EXPECT(setup.extension_compute_limit == defaultSetup.extension_compute_limit);
-            BEAST_EXPECT(setup.extension_size_limit == defaultSetup.extension_size_limit);
+            BEAST_EXPECT(setup.gas_limit == defaultSetup.gas_limit);
+            BEAST_EXPECT(setup.bytecode_size_limit == defaultSetup.bytecode_size_limit);
            BEAST_EXPECT(setup.gas_price == defaultSetup.gas_price);
        }
        {
@@ -303,17 +300,17 @@ class FeeVote_test : public beast::unit_test::Suite
                {"reference_fee = -50",
                 "account_reserve = -1234567",
                 "owner_reserve = -1234",
-                 "extension_compute_limit = -100",
-                 "extension_size_limit = -200",
+                 "gas_limit = -100",
+                 "bytecode_size_limit = -200",
                 "gas_price = -300"});
-            // Negative extension limit values wrap past their maximum and are
+            // Negative gas/bytecode limit values wrap past their maximum and are
            // ignored. Other uint32_t fields keep the existing behavior.
            auto setup = setupFeeVote(config);
            BEAST_EXPECT(setup.reference_fee == defaultSetup.reference_fee);
            BEAST_EXPECT(setup.account_reserve == static_cast<std::uint32_t>(-1234567));
            BEAST_EXPECT(setup.owner_reserve == static_cast<std::uint32_t>(-1234));
-            BEAST_EXPECT(setup.extension_compute_limit == defaultSetup.extension_compute_limit);
-            BEAST_EXPECT(setup.extension_size_limit == defaultSetup.extension_size_limit);
+            BEAST_EXPECT(setup.gas_limit == defaultSetup.gas_limit);
+            BEAST_EXPECT(setup.bytecode_size_limit == defaultSetup.bytecode_size_limit);
            BEAST_EXPECT(setup.gas_price == static_cast<std::uint32_t>(-300));
        }
        {
@@ -324,35 +321,35 @@ class FeeVote_test : public beast::unit_test::Suite
                {"reference_fee = " + big64,
                 "account_reserve = " + big64,
                 "owner_reserve = " + big64,
-                 "extension_compute_limit = " + big64,
-                 "extension_size_limit = " + big64,
+                 "gas_limit = " + big64,
+                 "bytecode_size_limit = " + big64,
                 "gas_price = " + big64});
            // Illegal values are ignored, and the defaults left unchanged
            auto setup = setupFeeVote(config);
            BEAST_EXPECT(setup.reference_fee == defaultSetup.reference_fee);
            BEAST_EXPECT(setup.account_reserve == defaultSetup.account_reserve);
            BEAST_EXPECT(setup.owner_reserve == defaultSetup.owner_reserve);
-            BEAST_EXPECT(setup.extension_compute_limit == defaultSetup.extension_compute_limit);
-            BEAST_EXPECT(setup.extension_size_limit == defaultSetup.extension_size_limit);
+            BEAST_EXPECT(setup.gas_limit == defaultSetup.gas_limit);
+            BEAST_EXPECT(setup.bytecode_size_limit == defaultSetup.bytecode_size_limit);
            BEAST_EXPECT(setup.gas_price == defaultSetup.gas_price);
        }
        {
            Section config;
            config.append(
-                {"extension_compute_limit = " + std::to_string(kMaxExtensionComputeLimit + 1),
-                 "extension_size_limit = " + std::to_string(kMaxExtensionSizeLimit + 1)});
+                {"gas_limit = " + std::to_string(kMaxGasLimit + 1),
+                 "bytecode_size_limit = " + std::to_string(kMaxBytecodeSizeLimit + 1)});
            auto const setup = setupFeeVote(config);
-            BEAST_EXPECT(setup.extension_compute_limit == defaultSetup.extension_compute_limit);
-            BEAST_EXPECT(setup.extension_size_limit == defaultSetup.extension_size_limit);
+            BEAST_EXPECT(setup.gas_limit == defaultSetup.gas_limit);
+            BEAST_EXPECT(setup.bytecode_size_limit == defaultSetup.bytecode_size_limit);
        }
        {
            Section config;
            config.append(
-                {"extension_compute_limit = " + std::to_string(kMaxExtensionComputeLimit),
-                 "extension_size_limit = " + std::to_string(kMaxExtensionSizeLimit)});
+                {"gas_limit = " + std::to_string(kMaxGasLimit),
+                 "bytecode_size_limit = " + std::to_string(kMaxBytecodeSizeLimit)});
            auto const setup = setupFeeVote(config);
-            BEAST_EXPECT(setup.extension_compute_limit == kMaxExtensionComputeLimit);
-            BEAST_EXPECT(setup.extension_size_limit == kMaxExtensionSizeLimit);
+            BEAST_EXPECT(setup.gas_limit == kMaxGasLimit);
+            BEAST_EXPECT(setup.bytecode_size_limit == kMaxBytecodeSizeLimit);
        }
    }

@@ -436,8 +433,8 @@ class FeeVote_test : public beast::unit_test::Suite
                .baseFeeDrops = XRPAmount{10},
                .reserveBaseDrops = XRPAmount{200000},
                .reserveIncrementDrops = XRPAmount{50000},
-                .extensionComputeLimit = 100,
-                .extensionSizeLimit = 200,
+                .gasLimit = 100,
+                .bytecodeSizeLimit = 200,
                .gasPrice = 300};
            // Test successful fee transaction with new fields
            auto feeTx = createFeeTx(ledger->rules(), ledger->seq(), fields);
@@ -472,15 +469,15 @@ class FeeVote_test : public beast::unit_test::Suite
                {.baseFeeDrops = XRPAmount{10},
                 .reserveBaseDrops = XRPAmount{200000},
                 .reserveIncrementDrops = XRPAmount{50000},
-                 .extensionComputeLimit = kMaxExtensionComputeLimit + 1,
-                 .extensionSizeLimit = kMaxExtensionSizeLimit,
+                 .gasLimit = kMaxGasLimit + 1,
+                 .bytecodeSizeLimit = kMaxBytecodeSizeLimit,
                 .gasPrice = 300});
            testBadFields(
                {.baseFeeDrops = XRPAmount{10},
                 .reserveBaseDrops = XRPAmount{200000},
                 .reserveIncrementDrops = XRPAmount{50000},
-                 .extensionComputeLimit = kMaxExtensionComputeLimit,
-                 .extensionSizeLimit = kMaxExtensionSizeLimit + 1,
+                 .gasLimit = kMaxGasLimit,
+                 .bytecodeSizeLimit = kMaxBytecodeSizeLimit + 1,
                 .gasPrice = 300});
        }

@@ -502,8 +499,8 @@ class FeeVote_test : public beast::unit_test::Suite
                .baseFeeDrops = XRPAmount{10},
                .reserveBaseDrops = XRPAmount{200000},
                .reserveIncrementDrops = XRPAmount{50000},
-                .extensionComputeLimit = 100,
-                .extensionSizeLimit = 200,
+                .gasLimit = 100,
+                .bytecodeSizeLimit = 200,
                .gasPrice = 300};
            // Test successful fee transaction with new fields
            auto feeTx = createFeeTx(ledger->rules(), ledger->seq(), fields, true);
@@ -951,8 +948,8 @@ class FeeVote_test : public beast::unit_test::Suite
        BEAST_EXPECT(env.current()->fees().base == XRPAmount{UNIT_TEST_REFERENCE_FEE});
        BEAST_EXPECT(env.current()->fees().reserve == XRPAmount{200'000'000});
        BEAST_EXPECT(env.current()->fees().increment == XRPAmount{50'000'000});
-        BEAST_EXPECT(env.current()->fees().extensionComputeLimit == 0);
-        BEAST_EXPECT(env.current()->fees().extensionSizeLimit == 0);
+        BEAST_EXPECT(env.current()->fees().gasLimit == 0);
+        BEAST_EXPECT(env.current()->fees().bytecodeSizeLimit == 0);
        BEAST_EXPECT(env.current()->fees().gasPrice == 0);

        auto const createFeeTxFromVoting =
@@ -993,8 +990,8 @@ class FeeVote_test : public beast::unit_test::Suite
                        v.setFieldAmount(sfBaseFeeDrops, XRPAmount{setup.reference_fee});
                        v.setFieldAmount(sfReserveBaseDrops, XRPAmount{setup.account_reserve});
                        v.setFieldAmount(sfReserveIncrementDrops, XRPAmount{setup.owner_reserve});
-                        v.setFieldU32(sfExtensionComputeLimit, setup.extension_compute_limit);
-                        v.setFieldU32(sfExtensionSizeLimit, setup.extension_size_limit);
+                        v.setFieldU32(sfGasLimit, setup.gas_limit);
+                        v.setFieldU32(sfBytecodeSizeLimit, setup.bytecode_size_limit);
                        v.setFieldU32(sfGasPrice, setup.gas_price);
                    });
                if (i % 2)
@@ -1041,10 +1038,9 @@ class FeeVote_test : public beast::unit_test::Suite
            BEAST_EXPECTS(
                feeTx.getFieldAmount(sfReserveIncrementDrops) == XRPAmount{setup.owner_reserve},
                line);
+            BEAST_EXPECTS(feeTx.getFieldU32(sfGasLimit) == setup.gas_limit, line);
            BEAST_EXPECTS(
-                feeTx.getFieldU32(sfExtensionComputeLimit) == setup.extension_compute_limit, line);
-            BEAST_EXPECTS(
-                feeTx.getFieldU32(sfExtensionSizeLimit) == setup.extension_size_limit, line);
+                feeTx.getFieldU32(sfBytecodeSizeLimit) == setup.bytecode_size_limit, line);
            BEAST_EXPECTS(feeTx.getFieldU32(sfGasPrice) == setup.gas_price, line);
        };

@@ -1053,8 +1049,8 @@ class FeeVote_test : public beast::unit_test::Suite
            setup.reference_fee = 42;
            setup.account_reserve = 1234567;
            setup.owner_reserve = 7654321;
-            setup.extension_compute_limit = 100;
-            setup.extension_size_limit = 200;
+            setup.gas_limit = 100;
+            setup.bytecode_size_limit = 200;
            setup.gas_price = 300;
            auto const [feeTx, ledger] = createFeeTxFromVoting(setup);

@@ -1066,8 +1062,8 @@ class FeeVote_test : public beast::unit_test::Suite
            setup.reference_fee = 42;
            setup.account_reserve = 1234567;
            setup.owner_reserve = 7654321;
-            setup.extension_compute_limit = 0;
-            setup.extension_size_limit = 0;
+            setup.gas_limit = 0;
+            setup.bytecode_size_limit = 0;
            setup.gas_price = 300;
            auto const [feeTx, ledger] = createFeeTxFromVoting(setup);

@@ -1079,13 +1075,13 @@ class FeeVote_test : public beast::unit_test::Suite
            setup.reference_fee = 42;
            setup.account_reserve = 1234567;
            setup.owner_reserve = 7654321;
-            setup.extension_compute_limit = kMaxExtensionComputeLimit + 1;
-            setup.extension_size_limit = kMaxExtensionSizeLimit + 1;
+            setup.gas_limit = kMaxGasLimit + 1;
+            setup.bytecode_size_limit = kMaxBytecodeSizeLimit + 1;
            setup.gas_price = 300;
            auto const [feeTx, ledger] = createFeeTxFromVoting(setup);

-            setup.extension_compute_limit = ledger->fees().extensionComputeLimit;
-            setup.extension_size_limit = ledger->fees().extensionSizeLimit;
+            setup.gas_limit = ledger->fees().gasLimit;
+            setup.bytecode_size_limit = ledger->fees().bytecodeSizeLimit;
            checkFeeTx(setup, feeTx, ledger);
        }
    }
--- a/src/test/app/PseudoTx_test.cpp
+++ b/src/test/app/PseudoTx_test.cpp
@@ -45,8 +45,8 @@ struct PseudoTx_test : public beast::unit_test::Suite
            }
            if (rules.enabled(featureSmartEscrow))
            {
-                obj[sfExtensionComputeLimit] = 0;
-                obj[sfExtensionSizeLimit] = 0;
+                obj[sfGasLimit] = 0;
+                obj[sfBytecodeSizeLimit] = 0;
                obj[sfGasPrice] = 0;
            }
        });
--- a/src/test/jtx/impl/envconfig.cpp
+++ b/src/test/jtx/impl/envconfig.cpp
@@ -23,8 +23,8 @@ setupConfigForUnitTests(Config& cfg)
    cfg.FEES.reference_fee = UNIT_TEST_REFERENCE_FEE;
    cfg.FEES.account_reserve = XRP(200).value().xrp().drops();
    cfg.FEES.owner_reserve = XRP(50).value().xrp().drops();
-    cfg.FEES.extension_compute_limit = 1'000'000;
-    cfg.FEES.extension_size_limit = 1'000'000;
+    cfg.FEES.gas_limit = 1'000'000;
+    cfg.FEES.bytecode_size_limit = 1'000'000;
    cfg.FEES.gas_price = 1'000;

    // The Beta API (currently v2) is always available to tests
--- a/src/test/rpc/Subscribe_test.cpp
+++ b/src/test/rpc/Subscribe_test.cpp
@@ -513,18 +513,18 @@ public:

                if (env.closed()->rules().enabled(featureSmartEscrow))
                {
-                    if (jv.isMember(jss::extension_compute) != isFlagLedger)
+                    if (jv.isMember(jss::gas_limit) != isFlagLedger)
                        return false;

-                    if (jv.isMember(jss::extension_size) != isFlagLedger)
+                    if (jv.isMember(jss::bytecode_size_limit) != isFlagLedger)
                        return false;
                }
                else
                {
-                    if (jv.isMember(jss::extension_compute))
+                    if (jv.isMember(jss::gas_limit))
                        return false;

-                    if (jv.isMember(jss::extension_size))
+                    if (jv.isMember(jss::bytecode_size_limit))
                        return false;
                }
                return true;
--- a/src/tests/libxrpl/protocol_autogen/ledger_entries/FeeSettingsTests.cpp
+++ b/src/tests/libxrpl/protocol_autogen/ledger_entries/FeeSettingsTests.cpp
@@ -27,8 +27,8 @@ TEST(FeeSettingsTests, BuilderSettersRoundTrip)
    auto const baseFeeDropsValue = canonical_AMOUNT();
    auto const reserveBaseDropsValue = canonical_AMOUNT();
    auto const reserveIncrementDropsValue = canonical_AMOUNT();
-    auto const extensionComputeLimitValue = canonical_UINT32();
-    auto const extensionSizeLimitValue = canonical_UINT32();
+    auto const gasLimitValue = canonical_UINT32();
+    auto const bytecodeSizeLimitValue = canonical_UINT32();
    auto const gasPriceValue = canonical_UINT32();
    auto const previousTxnIDValue = canonical_UINT256();
    auto const previousTxnLgrSeqValue = canonical_UINT32();
@@ -43,8 +43,8 @@ TEST(FeeSettingsTests, BuilderSettersRoundTrip)
    builder.setBaseFeeDrops(baseFeeDropsValue);
    builder.setReserveBaseDrops(reserveBaseDropsValue);
    builder.setReserveIncrementDrops(reserveIncrementDropsValue);
-    builder.setExtensionComputeLimit(extensionComputeLimitValue);
-    builder.setExtensionSizeLimit(extensionSizeLimitValue);
+    builder.setGasLimit(gasLimitValue);
+    builder.setBytecodeSizeLimit(bytecodeSizeLimitValue);
    builder.setGasPrice(gasPriceValue);
    builder.setPreviousTxnID(previousTxnIDValue);
    builder.setPreviousTxnLgrSeq(previousTxnLgrSeqValue);
@@ -115,19 +115,19 @@ TEST(FeeSettingsTests, BuilderSettersRoundTrip)
    }

    {
-        auto const& expected = extensionComputeLimitValue;
-        auto const actualOpt = entry.getExtensionComputeLimit();
+        auto const& expected = gasLimitValue;
+        auto const actualOpt = entry.getGasLimit();
        ASSERT_TRUE(actualOpt.has_value());
-        expectEqualField(expected, *actualOpt, "sfExtensionComputeLimit");
-        EXPECT_TRUE(entry.hasExtensionComputeLimit());
+        expectEqualField(expected, *actualOpt, "sfGasLimit");
+        EXPECT_TRUE(entry.hasGasLimit());
    }

    {
-        auto const& expected = extensionSizeLimitValue;
-        auto const actualOpt = entry.getExtensionSizeLimit();
+        auto const& expected = bytecodeSizeLimitValue;
+        auto const actualOpt = entry.getBytecodeSizeLimit();
        ASSERT_TRUE(actualOpt.has_value());
-        expectEqualField(expected, *actualOpt, "sfExtensionSizeLimit");
-        EXPECT_TRUE(entry.hasExtensionSizeLimit());
+        expectEqualField(expected, *actualOpt, "sfBytecodeSizeLimit");
+        EXPECT_TRUE(entry.hasBytecodeSizeLimit());
    }

    {
@@ -174,8 +174,8 @@ TEST(FeeSettingsTests, BuilderFromSleRoundTrip)
    auto const baseFeeDropsValue = canonical_AMOUNT();
    auto const reserveBaseDropsValue = canonical_AMOUNT();
    auto const reserveIncrementDropsValue = canonical_AMOUNT();
-    auto const extensionComputeLimitValue = canonical_UINT32();
-    auto const extensionSizeLimitValue = canonical_UINT32();
+    auto const gasLimitValue = canonical_UINT32();
+    auto const bytecodeSizeLimitValue = canonical_UINT32();
    auto const gasPriceValue = canonical_UINT32();
    auto const previousTxnIDValue = canonical_UINT256();
    auto const previousTxnLgrSeqValue = canonical_UINT32();
@@ -189,8 +189,8 @@ TEST(FeeSettingsTests, BuilderFromSleRoundTrip)
    sle->at(sfBaseFeeDrops) = baseFeeDropsValue;
    sle->at(sfReserveBaseDrops) = reserveBaseDropsValue;
    sle->at(sfReserveIncrementDrops) = reserveIncrementDropsValue;
-    sle->at(sfExtensionComputeLimit) = extensionComputeLimitValue;
-    sle->at(sfExtensionSizeLimit) = extensionSizeLimitValue;
+    sle->at(sfGasLimit) = gasLimitValue;
+    sle->at(sfBytecodeSizeLimit) = bytecodeSizeLimitValue;
    sle->at(sfGasPrice) = gasPriceValue;
    sle->at(sfPreviousTxnID) = previousTxnIDValue;
    sle->at(sfPreviousTxnLgrSeq) = previousTxnLgrSeqValue;
@@ -296,29 +296,29 @@ TEST(FeeSettingsTests, BuilderFromSleRoundTrip)
    }

    {
-        auto const& expected = extensionComputeLimitValue;
+        auto const& expected = gasLimitValue;

-        auto const fromSleOpt = entryFromSle.getExtensionComputeLimit();
-        auto const fromBuilderOpt = entryFromBuilder.getExtensionComputeLimit();
+        auto const fromSleOpt = entryFromSle.getGasLimit();
+        auto const fromBuilderOpt = entryFromBuilder.getGasLimit();

        ASSERT_TRUE(fromSleOpt.has_value());
        ASSERT_TRUE(fromBuilderOpt.has_value());

-        expectEqualField(expected, *fromSleOpt, "sfExtensionComputeLimit");
-        expectEqualField(expected, *fromBuilderOpt, "sfExtensionComputeLimit");
+        expectEqualField(expected, *fromSleOpt, "sfGasLimit");
+        expectEqualField(expected, *fromBuilderOpt, "sfGasLimit");
    }

    {
-        auto const& expected = extensionSizeLimitValue;
+        auto const& expected = bytecodeSizeLimitValue;

-        auto const fromSleOpt = entryFromSle.getExtensionSizeLimit();
-        auto const fromBuilderOpt = entryFromBuilder.getExtensionSizeLimit();
+        auto const fromSleOpt = entryFromSle.getBytecodeSizeLimit();
+        auto const fromBuilderOpt = entryFromBuilder.getBytecodeSizeLimit();

        ASSERT_TRUE(fromSleOpt.has_value());
        ASSERT_TRUE(fromBuilderOpt.has_value());

-        expectEqualField(expected, *fromSleOpt, "sfExtensionSizeLimit");
-        expectEqualField(expected, *fromBuilderOpt, "sfExtensionSizeLimit");
+        expectEqualField(expected, *fromSleOpt, "sfBytecodeSizeLimit");
+        expectEqualField(expected, *fromBuilderOpt, "sfBytecodeSizeLimit");
    }

    {
@@ -426,10 +426,10 @@ TEST(FeeSettingsTests, OptionalFieldsReturnNullopt)
    EXPECT_FALSE(entry.getReserveBaseDrops().has_value());
    EXPECT_FALSE(entry.hasReserveIncrementDrops());
    EXPECT_FALSE(entry.getReserveIncrementDrops().has_value());
-    EXPECT_FALSE(entry.hasExtensionComputeLimit());
-    EXPECT_FALSE(entry.getExtensionComputeLimit().has_value());
-    EXPECT_FALSE(entry.hasExtensionSizeLimit());
-    EXPECT_FALSE(entry.getExtensionSizeLimit().has_value());
+    EXPECT_FALSE(entry.hasGasLimit());
+    EXPECT_FALSE(entry.getGasLimit().has_value());
+    EXPECT_FALSE(entry.hasBytecodeSizeLimit());
+    EXPECT_FALSE(entry.getBytecodeSizeLimit().has_value());
    EXPECT_FALSE(entry.hasGasPrice());
    EXPECT_FALSE(entry.getGasPrice().has_value());
    EXPECT_FALSE(entry.hasPreviousTxnID());
--- a/src/tests/libxrpl/protocol_autogen/transactions/SetFeeTests.cpp
+++ b/src/tests/libxrpl/protocol_autogen/transactions/SetFeeTests.cpp
@@ -37,8 +37,8 @@ TEST(TransactionsSetFeeTests, BuilderSettersRoundTrip)
    auto const baseFeeDropsValue = canonical_AMOUNT();
    auto const reserveBaseDropsValue = canonical_AMOUNT();
    auto const reserveIncrementDropsValue = canonical_AMOUNT();
-    auto const extensionComputeLimitValue = canonical_UINT32();
-    auto const extensionSizeLimitValue = canonical_UINT32();
+    auto const gasLimitValue = canonical_UINT32();
+    auto const bytecodeSizeLimitValue = canonical_UINT32();
    auto const gasPriceValue = canonical_UINT32();

    SetFeeBuilder builder{
@@ -56,8 +56,8 @@ TEST(TransactionsSetFeeTests, BuilderSettersRoundTrip)
    builder.setBaseFeeDrops(baseFeeDropsValue);
    builder.setReserveBaseDrops(reserveBaseDropsValue);
    builder.setReserveIncrementDrops(reserveIncrementDropsValue);
-    builder.setExtensionComputeLimit(extensionComputeLimitValue);
-    builder.setExtensionSizeLimit(extensionSizeLimitValue);
+    builder.setGasLimit(gasLimitValue);
+    builder.setBytecodeSizeLimit(bytecodeSizeLimitValue);
    builder.setGasPrice(gasPriceValue);

    auto tx = builder.build(publicKey, secretKey);
@@ -141,19 +141,19 @@ TEST(TransactionsSetFeeTests, BuilderSettersRoundTrip)
    }

    {
-        auto const& expected = extensionComputeLimitValue;
-        auto const actualOpt = tx.getExtensionComputeLimit();
-        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfExtensionComputeLimit should be present";
-        expectEqualField(expected, *actualOpt, "sfExtensionComputeLimit");
-        EXPECT_TRUE(tx.hasExtensionComputeLimit());
+        auto const& expected = gasLimitValue;
+        auto const actualOpt = tx.getGasLimit();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfGasLimit should be present";
+        expectEqualField(expected, *actualOpt, "sfGasLimit");
+        EXPECT_TRUE(tx.hasGasLimit());
    }

    {
-        auto const& expected = extensionSizeLimitValue;
-        auto const actualOpt = tx.getExtensionSizeLimit();
-        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfExtensionSizeLimit should be present";
-        expectEqualField(expected, *actualOpt, "sfExtensionSizeLimit");
-        EXPECT_TRUE(tx.hasExtensionSizeLimit());
+        auto const& expected = bytecodeSizeLimitValue;
+        auto const actualOpt = tx.getBytecodeSizeLimit();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfBytecodeSizeLimit should be present";
+        expectEqualField(expected, *actualOpt, "sfBytecodeSizeLimit");
+        EXPECT_TRUE(tx.hasBytecodeSizeLimit());
    }

    {
@@ -188,8 +188,8 @@ TEST(TransactionsSetFeeTests, BuilderFromStTxRoundTrip)
    auto const baseFeeDropsValue = canonical_AMOUNT();
    auto const reserveBaseDropsValue = canonical_AMOUNT();
    auto const reserveIncrementDropsValue = canonical_AMOUNT();
-    auto const extensionComputeLimitValue = canonical_UINT32();
-    auto const extensionSizeLimitValue = canonical_UINT32();
+    auto const gasLimitValue = canonical_UINT32();
+    auto const bytecodeSizeLimitValue = canonical_UINT32();
    auto const gasPriceValue = canonical_UINT32();

    // Build an initial transaction
@@ -207,8 +207,8 @@ TEST(TransactionsSetFeeTests, BuilderFromStTxRoundTrip)
    initialBuilder.setBaseFeeDrops(baseFeeDropsValue);
    initialBuilder.setReserveBaseDrops(reserveBaseDropsValue);
    initialBuilder.setReserveIncrementDrops(reserveIncrementDropsValue);
-    initialBuilder.setExtensionComputeLimit(extensionComputeLimitValue);
-    initialBuilder.setExtensionSizeLimit(extensionSizeLimitValue);
+    initialBuilder.setGasLimit(gasLimitValue);
+    initialBuilder.setBytecodeSizeLimit(bytecodeSizeLimitValue);
    initialBuilder.setGasPrice(gasPriceValue);

    auto initialTx = initialBuilder.build(publicKey, secretKey);
@@ -285,17 +285,17 @@ TEST(TransactionsSetFeeTests, BuilderFromStTxRoundTrip)
    }

    {
-        auto const& expected = extensionComputeLimitValue;
-        auto const actualOpt = rebuiltTx.getExtensionComputeLimit();
-        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfExtensionComputeLimit should be present";
-        expectEqualField(expected, *actualOpt, "sfExtensionComputeLimit");
+        auto const& expected = gasLimitValue;
+        auto const actualOpt = rebuiltTx.getGasLimit();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfGasLimit should be present";
+        expectEqualField(expected, *actualOpt, "sfGasLimit");
    }

    {
-        auto const& expected = extensionSizeLimitValue;
-        auto const actualOpt = rebuiltTx.getExtensionSizeLimit();
-        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfExtensionSizeLimit should be present";
-        expectEqualField(expected, *actualOpt, "sfExtensionSizeLimit");
+        auto const& expected = bytecodeSizeLimitValue;
+        auto const actualOpt = rebuiltTx.getBytecodeSizeLimit();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfBytecodeSizeLimit should be present";
+        expectEqualField(expected, *actualOpt, "sfBytecodeSizeLimit");
    }

    {
@@ -376,10 +376,10 @@ TEST(TransactionsSetFeeTests, OptionalFieldsReturnNullopt)
    EXPECT_FALSE(tx.getReserveBaseDrops().has_value());
    EXPECT_FALSE(tx.hasReserveIncrementDrops());
    EXPECT_FALSE(tx.getReserveIncrementDrops().has_value());
-    EXPECT_FALSE(tx.hasExtensionComputeLimit());
-    EXPECT_FALSE(tx.getExtensionComputeLimit().has_value());
-    EXPECT_FALSE(tx.hasExtensionSizeLimit());
-    EXPECT_FALSE(tx.getExtensionSizeLimit().has_value());
+    EXPECT_FALSE(tx.hasGasLimit());
+    EXPECT_FALSE(tx.getGasLimit().has_value());
+    EXPECT_FALSE(tx.hasBytecodeSizeLimit());
+    EXPECT_FALSE(tx.getBytecodeSizeLimit().has_value());
    EXPECT_FALSE(tx.hasGasPrice());
    EXPECT_FALSE(tx.getGasPrice().has_value());
 }
--- a/src/xrpld/app/misc/FeeVoteImpl.cpp
+++ b/src/xrpld/app/misc/FeeVoteImpl.cpp
@@ -174,21 +174,17 @@ FeeVoteImpl::doValidation(Fees const& lastFees, Rules const& rules, STValidation
    }
    if (rules.enabled(featureSmartEscrow))
    {
-        if (target_.extension_compute_limit <= kMaxExtensionComputeLimit)
+        if (target_.gas_limit <= kMaxGasLimit)
        {
-            vote(
-                lastFees.extensionComputeLimit,
-                target_.extension_compute_limit,
-                "extension compute limit",
-                sfExtensionComputeLimit);
+            vote(lastFees.gasLimit, target_.gas_limit, "gas limit", sfGasLimit);
        }
-        if (target_.extension_size_limit <= kMaxExtensionSizeLimit)
+        if (target_.bytecode_size_limit <= kMaxBytecodeSizeLimit)
        {
            vote(
-                lastFees.extensionSizeLimit,
-                target_.extension_size_limit,
-                "extension size limit",
-                sfExtensionSizeLimit);
+                lastFees.bytecodeSizeLimit,
+                target_.bytecode_size_limit,
+                "bytecode size limit",
+                sfBytecodeSizeLimit);
        }
        vote(lastFees.gasPrice, target_.gas_price, "gas price", sfGasPrice);
    }
@@ -215,19 +211,16 @@ FeeVoteImpl::doVoting(
        return target <= max ? target : current;
    };

-    detail::VotableValue extensionComputeVote(
-        lastClosedLedger->fees().extensionComputeLimit,
-        validOrCurrent(
-            target_.extension_compute_limit,
-            kMaxExtensionComputeLimit,
-            lastClosedLedger->fees().extensionComputeLimit));
+    detail::VotableValue gasLimitVote(
+        lastClosedLedger->fees().gasLimit,
+        validOrCurrent(target_.gas_limit, kMaxGasLimit, lastClosedLedger->fees().gasLimit));

-    detail::VotableValue extensionSizeVote(
-        lastClosedLedger->fees().extensionSizeLimit,
+    detail::VotableValue bytecodeSizeLimitVote(
+        lastClosedLedger->fees().bytecodeSizeLimit,
        validOrCurrent(
-            target_.extension_size_limit,
-            kMaxExtensionSizeLimit,
-            lastClosedLedger->fees().extensionSizeLimit));
+            target_.bytecode_size_limit,
+            kMaxBytecodeSizeLimit,
+            lastClosedLedger->fees().bytecodeSizeLimit));

    detail::VotableValue gasPriceVote(lastClosedLedger->fees().gasPrice, target_.gas_price);

@@ -305,9 +298,9 @@ FeeVoteImpl::doVoting(
    {
        auto doVote = [](std::shared_ptr<STValidation> const& val,
                         detail::VotableValue<std::uint32_t>& value,
-                         SF_UINT32 const& extensionField,
+                         SF_UINT32 const& sfield,
                         std::uint32_t maxValue) {
-            if (auto const field = ~val->at(~extensionField); field)
+            if (auto const field = ~val->at(~sfield); field)
            {
                if (field.value() <= maxValue)
                {
@@ -328,8 +321,8 @@ FeeVoteImpl::doVoting(
        {
            if (!val->isTrusted())
                continue;
-            doVote(val, extensionComputeVote, sfExtensionComputeLimit, kMaxExtensionComputeLimit);
-            doVote(val, extensionSizeVote, sfExtensionSizeLimit, kMaxExtensionSizeLimit);
+            doVote(val, gasLimitVote, sfGasLimit, kMaxGasLimit);
+            doVote(val, bytecodeSizeLimitVote, sfBytecodeSizeLimit, kMaxBytecodeSizeLimit);
            doVote(val, gasPriceVote, sfGasPrice, std::numeric_limits<std::uint32_t>::max());
        }
    }
@@ -341,15 +334,15 @@ FeeVoteImpl::doVoting(
    auto const baseFee = baseFeeVote.getVotes();
    auto const baseReserve = baseReserveVote.getVotes();
    auto const incReserve = incReserveVote.getVotes();
-    auto const extensionCompute = extensionComputeVote.getVotes();
-    auto const extensionSize = extensionSizeVote.getVotes();
+    auto const gasLimit = gasLimitVote.getVotes();
+    auto const bytecodeSizeLimit = bytecodeSizeLimitVote.getVotes();
    auto const gasPrice = gasPriceVote.getVotes();

    auto const seq = lastClosedLedger->header().seq + 1;

    // add transactions to our position
-    if (baseFee.second || baseReserve.second || incReserve.second || extensionCompute.second ||
-        extensionSize.second || gasPrice.second)
+    if (baseFee.second || baseReserve.second || incReserve.second || gasLimit.second ||
+        bytecodeSizeLimit.second || gasPrice.second)
    {
        JLOG(journal_.warn()) << "We are voting for a fee change: " << baseFee.first << "/"
                              << baseReserve.first << "/" << incReserve.first;
@@ -376,8 +369,8 @@ FeeVoteImpl::doVoting(
            }
            if (rules.enabled(featureSmartEscrow))
            {
-                obj[sfExtensionComputeLimit] = extensionCompute.first;
-                obj[sfExtensionSizeLimit] = extensionSize.first;
+                obj[sfGasLimit] = gasLimit.first;
+                obj[sfBytecodeSizeLimit] = bytecodeSizeLimit.first;
                obj[sfGasPrice] = gasPrice.first;
            }
        });
--- a/src/xrpld/app/misc/NetworkOPs.cpp
+++ b/src/xrpld/app/misc/NetworkOPs.cpp
@@ -2429,12 +2429,11 @@ NetworkOPsImp::pubValidation(std::shared_ptr<STValidation> const& val)
            reserveIncXRP && reserveIncXRP->native())
            jvObj[jss::reserve_inc] = reserveIncXRP->xrp().jsonClipped();

-        if (auto const extensionComputeLimit = ~val->at(~sfExtensionComputeLimit);
-            extensionComputeLimit)
-            jvObj[jss::extension_compute] = *extensionComputeLimit;
+        if (auto const gasLimit = ~val->at(~sfGasLimit); gasLimit)
+            jvObj[jss::gas_limit] = *gasLimit;

-        if (auto const extensionSizeLimit = ~val->at(~sfExtensionSizeLimit); extensionSizeLimit)
-            jvObj[jss::extension_size] = *extensionSizeLimit;
+        if (auto const bytecodeSizeLimit = ~val->at(~sfBytecodeSizeLimit); bytecodeSizeLimit)
+            jvObj[jss::bytecode_size_limit] = *bytecodeSizeLimit;

        if (auto const gasPrice = ~val->at(~sfGasPrice); gasPrice)
            jvObj[jss::gas_price] = *gasPrice;
@@ -2895,8 +2894,8 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters)
            l[jss::reserve_inc] = lpClosed->fees().increment.jsonClipped();
            if (smartEscrowEnabled)
            {
-                l[jss::extension_compute] = lpClosed->fees().extensionComputeLimit;
-                l[jss::extension_size] = lpClosed->fees().extensionSizeLimit;
+                l[jss::gas_limit] = lpClosed->fees().gasLimit;
+                l[jss::bytecode_size_limit] = lpClosed->fees().bytecodeSizeLimit;
                l[jss::gas_price] = lpClosed->fees().gasPrice;
            }
            l[jss::close_time] =
@@ -2909,8 +2908,8 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters)
            l[jss::reserve_inc_xrp] = lpClosed->fees().increment.decimalXRP();
            if (smartEscrowEnabled)
            {
-                l[jss::extension_compute] = lpClosed->fees().extensionComputeLimit;
-                l[jss::extension_size] = lpClosed->fees().extensionSizeLimit;
+                l[jss::gas_limit] = lpClosed->fees().gasLimit;
+                l[jss::bytecode_size_limit] = lpClosed->fees().bytecodeSizeLimit;
                l[jss::gas_price] = lpClosed->fees().gasPrice;
            }

@@ -3110,8 +3109,8 @@ NetworkOPsImp::pubLedger(std::shared_ptr<ReadView const> const& lpAccepted)
            jvObj[jss::reserve_inc] = lpAccepted->fees().increment.jsonClipped();
            if (lpAccepted->rules().enabled(featureSmartEscrow))
            {
-                jvObj[jss::extension_compute] = lpAccepted->fees().extensionComputeLimit;
-                jvObj[jss::extension_size] = lpAccepted->fees().extensionSizeLimit;
+                jvObj[jss::gas_limit] = lpAccepted->fees().gasLimit;
+                jvObj[jss::bytecode_size_limit] = lpAccepted->fees().bytecodeSizeLimit;
                jvObj[jss::gas_price] = lpAccepted->fees().gasPrice;
            }

@@ -4096,8 +4095,8 @@ NetworkOPsImp::subLedger(InfoSub::ref isrListener, json::Value& jvResult)
        jvResult[jss::network_id] = registry_.get().getNetworkIDService().getNetworkID();
        if (lpClosed->rules().enabled(featureSmartEscrow))
        {
-            jvResult[jss::extension_compute] = lpClosed->fees().extensionComputeLimit;
-            jvResult[jss::extension_size] = lpClosed->fees().extensionSizeLimit;
+            jvResult[jss::gas_limit] = lpClosed->fees().gasLimit;
+            jvResult[jss::bytecode_size_limit] = lpClosed->fees().bytecodeSizeLimit;
            jvResult[jss::gas_price] = lpClosed->fees().gasPrice;
        }
    }
--- a/src/xrpld/core/Config.h
+++ b/src/xrpld/core/Config.h
@@ -56,11 +56,11 @@ struct FeeSetup
    /** The per-owned item reserve requirement in drops. */
    XRPAmount owner_reserve{2 * kDropsPerXrp};

-    /** The compute limit for Feature Extensions. */
-    std::uint32_t extension_compute_limit{1'000'000};
+    /** The gas limit for Feature Extensions. */
+    std::uint32_t gas_limit{1'000'000};

-    /** The WASM size limit for Feature Extensions. */
-    std::uint32_t extension_size_limit{100'000};
+    /** The bytecode size limit for Feature Extensions. */
+    std::uint32_t bytecode_size_limit{100'000};

    /** The price of 1 WASM gas, in micro-drops. */
    std::uint32_t gas_price{1'000'000};
--- a/src/xrpld/core/detail/Config.cpp
+++ b/src/xrpld/core/detail/Config.cpp
@@ -1195,10 +1195,10 @@ setupFeeVote(Section const& section)
            setup.account_reserve = temp;
        if (set(temp, "owner_reserve", section))
            setup.owner_reserve = temp;
-        if (set(temp, "extension_compute_limit", section) && temp <= kMaxExtensionComputeLimit)
-            setup.extension_compute_limit = temp;
-        if (set(temp, "extension_size_limit", section) && temp <= kMaxExtensionSizeLimit)
-            setup.extension_size_limit = temp;
+        if (set(temp, "gas_limit", section) && temp <= kMaxGasLimit)
+            setup.gas_limit = temp;
+        if (set(temp, "bytecode_size_limit", section) && temp <= kMaxBytecodeSizeLimit)
+            setup.bytecode_size_limit = temp;
        if (set(temp, "gas_price", section))
            setup.gas_price = temp;
    }