feat: Update CryptoCreate/CryptoDelete to use new simple fees

hedera-node/hedera-app-spi/src/main/java/com/hedera/node/app/spi/fees/AbstractSimpleFeeCalculator.java

@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.node.app.spi.fees;
+
+import static org.hiero.hapi.fees.FeeScheduleUtils.lookupExtraFee;
+
+import edu.umd.cs.findbugs.annotations.NonNull;
+import java.util.List;
+import java.util.function.Function;
+import org.hiero.hapi.support.fees.Extra;
+import org.hiero.hapi.support.fees.ExtraFeeReference;
+import org.hiero.hapi.support.fees.FeeSchedule;
+
+/**
+ * Base class for simple fee calculators. Provides reusable utility methods for common fee
+ * calculation patterns per HIP-1261.
+ *
+ * <p>Subclasses implement {@link SimpleFeeCalculator} directly and can use the static utility
+ * methods provided here to avoid code duplication.
+ */
+public abstract class AbstractSimpleFeeCalculator implements SimpleFeeCalculator {
+
+    /**
+     * Utility: Calculates extra fees from a list of ExtraFeeReferences.
+     * Subclasses provide a lambda/method reference to map Extra enum to usage count.
+     *
+     * <p>This implements the common pattern: base + sum(overage * feePerUnit) where overage =
+     * max(0, used - included).
+     *
+     * @param extras The list of extra fee references to process
+     * @param feeSchedule The fee schedule to lookup extra fee costs
+     * @param usageMapper Function that returns usage count for each Extra type
+     * @return Total extra fees
+     */
+    protected static long calculateExtraFees(
+            @NonNull final List<ExtraFeeReference> extras,
+            @NonNull final FeeSchedule feeSchedule,
+            @NonNull final Function<Extra, Long> usageMapper) {
+        long total = 0;
+        for (final var ref : extras) {
+            final long used = usageMapper.apply(ref.name());
+            if (used > ref.includedCount()) {
+                final long overage = used - ref.includedCount();
+                total += overage * lookupExtraFee(feeSchedule, ref).fee();
+            }
+        }
+        return total;
+    }
+
+    /**
+     * Utility: Calculates network fee from node fee and multiplier.
+     * @param nodeFee The calculated node fee
+     * @param multiplier The network multiplier from fee schedule
+     * @return Network fee
+     */
+    protected static long calculateNetworkFee(long nodeFee, int multiplier) {
+        return nodeFee * multiplier;
+    }
+
+    /**
+     * Creates a builder for constructing usage mappers.
+     * Usage example:
+     * <pre>
+     * var usageMapper = usageBuilder()
+     *     .withSignatures(context.numTxnSignatures())
+     *     .withKeys(keyCount)
+     *     .build();
+     * </pre>
+     *
+     * @return a new UsageBuilder instance
+     */
+    protected static UsageBuilder usageBuilder() {
+        return new UsageBuilder();
+    }
+
+    /**
+     * Fluent builder for creating Extra usage mappers per HIP-1261.
+     * Provides named methods for each Extra type to clearly document which extras
+     * a transaction uses.
+     */
+    protected static final class UsageBuilder {
+        private final long[] counts = new long[Extra.values().length];
+
+        private UsageBuilder() {}
+
+        public UsageBuilder withSignatures(long count) {
+            counts[Extra.SIGNATURES.ordinal()] = count;
+            return this;
+        }
+
+        public UsageBuilder withBytes(long count) {
+            counts[Extra.BYTES.ordinal()] = count;
+            return this;
+        }
+
+        public UsageBuilder withKeys(long count) {
+            counts[Extra.KEYS.ordinal()] = count;
+            return this;
+        }
+
+        public UsageBuilder withTokenTypes(long count) {
+            counts[Extra.TOKEN_TYPES.ordinal()] = count;
+            return this;
+        }
+
+        public UsageBuilder withNftSerials(long count) {
+            counts[Extra.NFT_SERIALS.ordinal()] = count;
+            return this;
+        }
+
+        public UsageBuilder withAccounts(long count) {
+            counts[Extra.ACCOUNTS.ordinal()] = count;
+            return this;
+        }
+
+        public UsageBuilder withStandardFungibleTokens(long count) {
+            counts[Extra.STANDARD_FUNGIBLE_TOKENS.ordinal()] = count;
+            return this;
+        }
+
+        public UsageBuilder withStandardNonFungibleTokens(long count) {
+            counts[Extra.STANDARD_NON_FUNGIBLE_TOKENS.ordinal()] = count;
+            return this;
+        }
+
+        public UsageBuilder withCustomFeeFungibleTokens(long count) {
+            counts[Extra.CUSTOM_FEE_FUNGIBLE_TOKENS.ordinal()] = count;
+            return this;
+        }
+
+        public UsageBuilder withCustomFeeNonFungibleTokens(long count) {
+            counts[Extra.CUSTOM_FEE_NON_FUNGIBLE_TOKENS.ordinal()] = count;
+            return this;
+        }
+
+        public UsageBuilder withCreatedAutoAssociations(long count) {
+            counts[Extra.CREATED_AUTO_ASSOCIATIONS.ordinal()] = count;
+            return this;
+        }
+
+        public UsageBuilder withCreatedAccounts(long count) {
+            counts[Extra.CREATED_ACCOUNTS.ordinal()] = count;
+            return this;
+        }
+
+        public UsageBuilder withCustomFee(long count) {
+            counts[Extra.CUSTOM_FEE.ordinal()] = count;
+            return this;
+        }
+
+        public UsageBuilder withGas(long count) {
+            counts[Extra.GAS.ordinal()] = count;
+            return this;
+        }
+
+        public UsageBuilder withAllowances(long count) {
+            counts[Extra.ALLOWANCES.ordinal()] = count;
+            return this;
+        }
+
+        public UsageBuilder withAirdrops(long count) {
+            counts[Extra.AIRDROPS.ordinal()] = count;
+            return this;
+        }
+
+        /**
+         * Builds the usage mapper function.
+         * @return Function that maps Extra types to their usage counts
+         */
+        public Function<Extra, Long> build() {
+            return extra -> counts[extra.ordinal()];
+        }
+    }
+}

hedera-node/hedera-app-spi/src/main/java/com/hedera/node/app/spi/fees/SimpleFeeCalculator.java

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+ * Copyright (C) 2025 Hedera Hashgraph, LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.hedera.node.app.spi.fees;
+
+import com.hedera.hapi.node.base.AccountID;
+import com.hedera.hapi.node.base.TokenID;
+import com.hedera.hapi.node.state.token.Account;
+import com.hedera.hapi.node.state.token.Token;
+import com.hedera.hapi.node.transaction.Query;
+import com.hedera.hapi.node.transaction.TransactionBody;
+import com.hedera.pbj.runtime.io.buffer.Bytes;
+import com.swirlds.config.api.Configuration;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import edu.umd.cs.findbugs.annotations.Nullable;
+import java.util.Optional;
+import java.util.OptionalInt;
+import org.hiero.hapi.fees.FeeResult;
+
+/** Calculates transaction and query fees. Null context = approximate, non-null = exact using state. */
+public interface SimpleFeeCalculator {
+
+    /** Provides state access for exact fee calculation. */
+    interface TxContext {
+        int cryptoVerificationsRequired();
+
+        boolean existsAccountWith(@NonNull Bytes alias);
+
+        boolean existsAccount(@NonNull AccountID accountId);
+
+        @NonNull
+        Optional<Account> getAccount(@NonNull AccountID accountId);
+
+        boolean tokenHasCustomFees(@NonNull TokenID tokenId);
+
+        @NonNull
+        OptionalInt customFeeCount(@NonNull TokenID tokenId);
+
+        @NonNull
+        Optional<Token> getToken(@NonNull TokenID tokenId);
+
+        boolean existsTokenRelation(@NonNull AccountID accountId, @NonNull TokenID tokenId);
+
+        @NonNull
+        Configuration configuration();
+
+        int numTxnSignatures();
+
+        @NonNull
+        FeeCalculatorFactory feeCalculatorFactory();
+    }
+
+    /** Provides state access for exact query fee calculation. */
+    interface QueryContext {
+        int cryptoVerificationsRequired();
+    }
+
+    @NonNull
+    FeeResult calculateTxFee(@NonNull TransactionBody body, @Nullable TxContext context);
+
+    @NonNull
+    FeeResult calculateQueryFee(@NonNull Query query, @Nullable QueryContext context);
+}

hedera-node/hedera-app/src/main/java/com/hedera/node/app/workflows/dispatcher/TransactionDispatcher.java

@@ -132,8 +132,12 @@
         }
 
         return switch (feeContext.body().data().kind()) {
-            case CONSENSUS_CREATE_TOPIC, CONSENSUS_SUBMIT_MESSAGE, CONSENSUS_UPDATE_TOPIC, CONSENSUS_DELETE_TOPIC ->
-                true;
+            case CONSENSUS_CREATE_TOPIC,
+                    CONSENSUS_SUBMIT_MESSAGE,
+                    CONSENSUS_UPDATE_TOPIC,
+                    CONSENSUS_DELETE_TOPIC,
+                    CRYPTO_DELETE,
+                    CRYPTO_CREATE_ACCOUNT -> true;
             default -> false;
         };
     }

hedera-node/hedera-file-service-impl/src/main/resources/genesis/simpleFeesSchedules.json

@@ -15,19 +15,19 @@
   },
 
   "extras": [
-    { "name":  "SIGNATURES",                     "fee": 60000000 },
-    { "name":  "BYTES",                          "fee": 300 },
-    { "name":  "KEYS",                           "fee": 2200000 },
-    { "name":  "TOKEN_TYPES",                    "fee": 3 },
-    { "name":  "NFT_SERIALS",                    "fee": 1 },
-    { "name":  "ACCOUNTS",                       "fee": 3 },
-    { "name":  "STANDARD_FUNGIBLE_TOKENS",       "fee": 3 },
-    { "name":  "STANDARD_NON_FUNGIBLE_TOKENS",   "fee": 3 },
-    { "name":  "CUSTOM_FEE_FUNGIBLE_TOKENS",     "fee": 3 },
-    { "name":  "CUSTOM_FEE_NON_FUNGIBLE_TOKENS", "fee": 3 },
-    { "name":  "CREATED_AUTO_ASSOCIATIONS",      "fee": 3 },
-    { "name":  "CREATED_ACCOUNTS",               "fee": 3 },
-    { "name":  "CUSTOM_FEE",                     "fee": 1 },
+    { "name":  "SIGNATURES",                     "fee": 1000000 },
+    { "name":  "BYTES",                          "fee": 110 },
+    { "name":  "KEYS",                           "fee": 100000000 },
+    { "name":  "TOKEN_TYPES",                    "fee": 0 },
+    { "name":  "NFT_SERIALS",                    "fee": 8900000 },
+    { "name":  "ACCOUNTS",                       "fee": 0 },
+    { "name":  "STANDARD_FUNGIBLE_TOKENS",       "fee": 9000000 },
+    { "name":  "STANDARD_NON_FUNGIBLE_TOKENS",   "fee": 100000 },
+    { "name":  "CUSTOM_FEE_FUNGIBLE_TOKENS",     "fee": 19000000 },
+    { "name":  "CUSTOM_FEE_NON_FUNGIBLE_TOKENS", "fee": 10100000 },
+    { "name":  "CREATED_AUTO_ASSOCIATIONS",      "fee": 0 },
+    { "name":  "CREATED_ACCOUNTS",               "fee": 0 },
+    { "name":  "CUSTOM_FEE",                     "fee": 0 },
     { "name":  "GAS",                            "fee": 1 },
     { "name":  "ALLOWANCES",                     "fee": 2000 },
     { "name":  "AIRDROPS",                       "fee": 8800 }
@@ -51,6 +51,13 @@
             {  "name": "KEYS",       "includedCount": 1 }
           ]
         },
+        {
+          "name": "CryptoDelete",
+          "baseFee": 5,
+          "extras": [
+            { "name": "SIGNATURES", "includedCount": 1 }
+          ]
+        },
         {
           "name": "CryptoTransfer",
           "baseFee": 18,

hedera-node/hedera-token-service-impl/src/main/java/com/hedera/node/app/service/token/impl/handlers/CryptoCreateFeeCalculator.java

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.node.app.service.token.impl.handlers;
+
+import static java.util.Objects.requireNonNull;
+import static org.hiero.hapi.fees.FeeScheduleUtils.lookupServiceFee;
+
+import com.hedera.hapi.node.base.HederaFunctionality;
+import com.hedera.hapi.node.base.Key;
+import com.hedera.hapi.node.base.SubType;
+import com.hedera.hapi.node.transaction.Query;
+import com.hedera.hapi.node.transaction.TransactionBody;
+import com.hedera.node.app.spi.fees.AbstractSimpleFeeCalculator;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import edu.umd.cs.findbugs.annotations.Nullable;
+import org.hiero.hapi.fees.FeeResult;
+
+/** Calculates CryptoCreate fees. Per HIP-1261, uses SIGNATURES and KEYS extras. */
+public class CryptoCreateFeeCalculator extends AbstractSimpleFeeCalculator {
+
+    @Override
+    @NonNull
+    public FeeResult calculateTxFee(@NonNull final TransactionBody body, @Nullable final TxContext context) {
+        requireNonNull(body, "body");
+        final var op = body.cryptoCreateAccountOrThrow();
+        // Count keys in the account being created
+        final long keyCount = op.hasKey() ? countKeys(op.key()) : 0L;
+
+        // Build usage mapper - fluent API makes fee structure explicit
+        final var usageMapper = usageBuilder()
+                .withSignatures(context.numTxnSignatures())
+                .withKeys(keyCount)
+                .build();
+
+        // Get fee schedule
+        final var feeCalculator = context.feeCalculatorFactory().feeCalculator(SubType.DEFAULT);
+        final var feeSchedule = feeCalculator.getSimpleFeesSchedule();
+        final var serviceDef = lookupServiceFee(feeSchedule, HederaFunctionality.CRYPTO_CREATE);
+
+        // Calculate fees
+        long nodeFee = feeSchedule.node().baseFee()
+                + calculateExtraFees(feeSchedule.node().extras(), feeSchedule, usageMapper);
+
+        long serviceFee = serviceDef.baseFee() + calculateExtraFees(serviceDef.extras(), feeSchedule, usageMapper);
+
+        long networkFee = calculateNetworkFee(nodeFee, feeSchedule.network().multiplier());
+
+        // Return result
+        final var result = new FeeResult();
+        result.node = nodeFee;
+        result.network = networkFee;
+        result.service = serviceFee;
+        return result;
+    }
+
+    /**
+     * Counts all keys including nested ones in threshold/key lists.
+     */
+    private long countKeys(Key key) {
+        return switch (key.key().kind()) {
+            case ED25519, ECDSA_SECP256K1, ECDSA_384 -> 1L;
+            case THRESHOLD_KEY ->
+                key.thresholdKeyOrThrow().keys().keys().stream()
+                        .mapToLong(this::countKeys)
+                        .sum();
+            case KEY_LIST ->
+                key.keyListOrThrow().keys().stream().mapToLong(this::countKeys).sum();
+            default -> 0L;
+        };
+    }
+
+    @Override
+    @NonNull
+    public FeeResult calculateQueryFee(@NonNull final Query query, @Nullable final QueryContext context) {
+        throw new UnsupportedOperationException("Query fee calculation not implemented for CRYPTO_CREATE");
+    }
+}