ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2026-07-26 16:40:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Rithvik Reddygari
2026-07-08 16:26:58 -04:00
committed by GitHub
parent 4a01fe5aa6
commit 2e48bb4b7f
21 changed files with 249 additions and 262 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
src/libxrpl/ledger/Ledger.cpp
View File

@@ -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)
{

4
src/libxrpl/protocol/STValidation.cpp
View File

@@ -60,8 +60,8 @@ STValidation::validationFormat()
{sfReserveBaseDrops, SoeOptional},
{sfReserveIncrementDrops, SoeOptional},
// featureSmartEscrow
{sfExtensionComputeLimit, SoeOptional},
{sfExtensionSizeLimit, SoeOptional},
{sfGasLimit, SoeOptional},
{sfBytecodeSizeLimit, SoeOptional},
{sfGasPrice, SoeOptional},
};
// clang-format on

17
src/libxrpl/tx/transactors/system/Change.cpp
View File

@@ -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);
}

122
src/test/app/FeeVote_test.cpp
View File

@@ -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);
}
}

4
src/test/app/PseudoTx_test.cpp
View File

@@ -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;
}
});

4
src/test/jtx/impl/envconfig.cpp
View File

@@ -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

8
src/test/rpc/Subscribe_test.cpp
View File

@@ -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;

60
src/tests/libxrpl/protocol_autogen/ledger_entries/FeeSettingsTests.cpp
View File

@@ -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());

60
src/tests/libxrpl/protocol_autogen/transactions/SetFeeTests.cpp
View File

@@ -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());
}

57
src/xrpld/app/misc/FeeVoteImpl.cpp
View File

@@ -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;
}
});

25
src/xrpld/app/misc/NetworkOPs.cpp
View File

@@ -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;
}
}

8
src/xrpld/core/Config.h
View File

@@ -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};

8
src/xrpld/core/detail/Config.cpp
View File

@@ -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;
}