From 2e48bb4b7fd83a7d1c6264acccc4cabf1e12cb01 Mon Sep 17 00:00:00 2001 From: Rithvik Reddygari <67663680+ricky122-5@users.noreply.github.com> Date: Wed, 8 Jul 2026 16:26:58 -0400 Subject: [PATCH] refactor: Rename sfield names, sfExtensionComputeLimit -> sfGasLimit, sfExtensionSizeLimit -> sfBytecodeSizeLimit (#7708) --- cfg/xrpld-example.cfg | 12 +- include/xrpl/protocol/Fees.h | 12 +- .../xrpl/protocol/detail/ledger_entries.macro | 4 +- include/xrpl/protocol/detail/sfields.macro | 4 +- .../xrpl/protocol/detail/transactions.macro | 4 +- include/xrpl/protocol/jss.h | 4 +- .../ledger_entries/FeeSettings.h | 40 +++--- .../protocol_autogen/transactions/SetFee.h | 40 +++--- src/libxrpl/ledger/Ledger.cpp | 14 +- src/libxrpl/protocol/STValidation.cpp | 4 +- src/libxrpl/tx/transactors/system/Change.cpp | 17 ++- src/test/app/FeeVote_test.cpp | 122 +++++++++--------- src/test/app/PseudoTx_test.cpp | 4 +- src/test/jtx/impl/envconfig.cpp | 4 +- src/test/rpc/Subscribe_test.cpp | 8 +- .../ledger_entries/FeeSettingsTests.cpp | 60 ++++----- .../transactions/SetFeeTests.cpp | 60 ++++----- src/xrpld/app/misc/FeeVoteImpl.cpp | 57 ++++---- src/xrpld/app/misc/NetworkOPs.cpp | 25 ++-- src/xrpld/core/Config.h | 8 +- src/xrpld/core/detail/Config.cpp | 8 +- 21 files changed, 249 insertions(+), 262 deletions(-) diff --git a/cfg/xrpld-example.cfg b/cfg/xrpld-example.cfg index 0289503aa4..9a55ba256f 100644 --- 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_limit = # -# 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 = +# bytecode_size_limit = # -# 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 = # diff --git a/include/xrpl/protocol/Fees.h b/include/xrpl/protocol/Fees.h index a7ec00ba5b..3ab5769144 100644 --- 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}; diff --git a/include/xrpl/protocol/detail/ledger_entries.macro b/include/xrpl/protocol/detail/ledger_entries.macro index d8bd9b10f9..7f4a9ad9ce 100644 --- 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}, diff --git a/include/xrpl/protocol/detail/sfields.macro b/include/xrpl/protocol/detail/sfields.macro index 7b67213258..a7af72c3aa 100644 --- 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) diff --git a/include/xrpl/protocol/detail/transactions.macro b/include/xrpl/protocol/detail/transactions.macro index f4e04d1875..22b650fff6 100644 --- 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}, })) diff --git a/include/xrpl/protocol/jss.h b/include/xrpl/protocol/jss.h index ddd88e8d5b..87c882196b 100644 --- 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 diff --git a/include/xrpl/protocol_autogen/ledger_entries/FeeSettings.h b/include/xrpl/protocol_autogen/ledger_entries/FeeSettings.h index 58a8887b11..0d3a8ca6bf 100644 --- 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 - 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 - 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 const& value) + setGasLimit(std::decay_t 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 const& value) + setBytecodeSizeLimit(std::decay_t const& value) { - object_[sfExtensionSizeLimit] = value; + object_[sfBytecodeSizeLimit] = value; return *this; } diff --git a/include/xrpl/protocol_autogen/transactions/SetFee.h b/include/xrpl/protocol_autogen/transactions/SetFee.h index 801f221e2e..eb6543a047 100644 --- 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 - 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 - 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 const& value) + setGasLimit(std::decay_t 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 const& value) + setBytecodeSizeLimit(std::decay_t const& value) { - object_[sfExtensionSizeLimit] = value; + object_[sfBytecodeSizeLimit] = value; return *this; } diff --git a/src/libxrpl/ledger/Ledger.cpp b/src/libxrpl/ledger/Ledger.cpp index 717b77b17b..930629c29a 100644 --- 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 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) { diff --git a/src/libxrpl/protocol/STValidation.cpp b/src/libxrpl/protocol/STValidation.cpp index df2c384ccc..a13be64df1 100644 --- 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 diff --git a/src/libxrpl/tx/transactors/system/Change.cpp b/src/libxrpl/tx/transactors/system/Change.cpp index 8691834ea3..30603b8b4a 100644 --- 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); } diff --git a/src/test/app/FeeVote_test.cpp b/src/test/app/FeeVote_test.cpp index 75d95f6433..b75dd5dddb 100644 --- a/src/test/app/FeeVote_test.cpp +++ b/src/test/app/FeeVote_test.cpp @@ -48,8 +48,8 @@ struct FeeSettingsFields std::optional baseFeeDrops = std::nullopt; std::optional reserveBaseDrops = std::nullopt; std::optional reserveIncrementDrops = std::nullopt; - std::optional extensionComputeLimit = std::nullopt; - std::optional extensionSizeLimit = std::nullopt; + std::optional gasLimit = std::nullopt; + std::optional bytecodeSizeLimit = std::nullopt; std::optional 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(-1234567)); BEAST_EXPECT(setup.owner_reserve == static_cast(-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(-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); } } diff --git a/src/test/app/PseudoTx_test.cpp b/src/test/app/PseudoTx_test.cpp index 84f1bce5ed..d9ace0cf49 100644 --- 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; } }); diff --git a/src/test/jtx/impl/envconfig.cpp b/src/test/jtx/impl/envconfig.cpp index bbbc3a3922..cb5af59c82 100644 --- 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 diff --git a/src/test/rpc/Subscribe_test.cpp b/src/test/rpc/Subscribe_test.cpp index 1957910782..e924a384b0 100644 --- 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; diff --git a/src/tests/libxrpl/protocol_autogen/ledger_entries/FeeSettingsTests.cpp b/src/tests/libxrpl/protocol_autogen/ledger_entries/FeeSettingsTests.cpp index 6d593bb138..92bf25398c 100644 --- 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()); diff --git a/src/tests/libxrpl/protocol_autogen/transactions/SetFeeTests.cpp b/src/tests/libxrpl/protocol_autogen/transactions/SetFeeTests.cpp index 0084b232dd..d7cfb469ba 100644 --- 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()); } diff --git a/src/xrpld/app/misc/FeeVoteImpl.cpp b/src/xrpld/app/misc/FeeVoteImpl.cpp index d61994e3c1..0e2b0f4e8c 100644 --- 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 const& val, detail::VotableValue& 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::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; } }); diff --git a/src/xrpld/app/misc/NetworkOPs.cpp b/src/xrpld/app/misc/NetworkOPs.cpp index 3cb0b7cb4c..2e54deb436 100644 --- a/src/xrpld/app/misc/NetworkOPs.cpp +++ b/src/xrpld/app/misc/NetworkOPs.cpp @@ -2429,12 +2429,11 @@ NetworkOPsImp::pubValidation(std::shared_ptr 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 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; } } diff --git a/src/xrpld/core/Config.h b/src/xrpld/core/Config.h index c5de421267..17df277820 100644 --- 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}; diff --git a/src/xrpld/core/detail/Config.cpp b/src/xrpld/core/detail/Config.cpp index 94939ed2f4..daa9a6a688 100644 --- 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; }