feat!: fee calculation now takes into account reference script size

BREAKING CHANGE: minFee now takes resolvedInputs and complete protocol parameters as arguments
- removed ProtocolParametersForInputSelection type
- removed ProtocolParametersRequiredByInputSelection type

Author: AngelCastilloB

packages/input-selection/src/types.ts

@@ -99,12 +99,3 @@ export interface InputSelector {
    */
   select(params: InputSelectionParameters): Promise<SelectionResult>;
 }
-
-export type ProtocolParametersForInputSelection = Pick<
-  Cardano.ProtocolParameters,
-  'coinsPerUtxoByte' | 'maxTxSize' | 'maxValueSize' | 'minFeeCoefficient' | 'minFeeConstant' | 'prices'
->;
-
-export type ProtocolParametersRequiredByInputSelection = Required<{
-  [k in keyof ProtocolParametersForInputSelection]: ProtocolParametersForInputSelection[k];
-}>;

packages/input-selection/test/vectors.ts

@@ -1,6 +1,5 @@
 import { Cardano, Serialization } from '@cardano-sdk/core';
 import { HexBlob } from '@cardano-sdk/util';
-import { ProtocolParametersForInputSelection } from '../src';
 import { SelectionSkeleton } from '../dist/cjs';
 import { TxTestUtil } from '@cardano-sdk/util-dev';
 
@@ -28,7 +27,7 @@ export const babbageSelectionParameters = {
   minFeeCoefficient: 44,
   minFeeConstant: 155_381,
   prices: { memory: 0.0577, steps: 0.000_007_21 }
-} as ProtocolParametersForInputSelection;
+} as Cardano.ProtocolParameters;
 
 export const cborUtxoSetWithManyAssets = [
   HexBlob(

packages/tx-construction/src/fees/fees.ts

@@ -1,5 +1,4 @@
 import { Cardano, Serialization } from '@cardano-sdk/core';
-import { OpaqueNumber } from '@cardano-sdk/util';
 
 /**
  * The constant overhead of 160 bytes accounts for the transaction input and the entry in the UTxO map data
@@ -52,34 +51,69 @@ const getTotalExUnits = (redeemers: Cardano.Redeemer[]): Cardano.ExUnits => {
 };
 
 /**
- * Gets the minimum fee incurred by the scripts on the transaction.
+ * Starting in the Conway era, the ref script min fee calculation is given by the total size (in bytes) of
+ * reference scripts priced according to a different, growing tiered pricing model.
+ * See https://github.com/CardanoSolutions/ogmios/releases/tag/v6.5.0
  *
- * @param tx The transaction to compute the min script fee from.
- * @param exUnitsPrice The prices of the execution units.
+ * @param tx The transaction to compute the min ref script fee from.
+ * @param resolvedInputs The resolved inputs of the transaction.
+ * @param coinsPerRefScriptByte The price per byte of the reference script.
  */
-const minScriptFee = (tx: Cardano.Tx, exUnitsPrice: Cardano.Prices): bigint => {
-  if (!tx.witness.redeemers) return BigInt(0);
+const minRefScriptFee = (tx: Cardano.Tx, resolvedInputs: Cardano.Utxo[], coinsPerRefScriptByte: number): bigint => {
+  if (coinsPerRefScriptByte === 0) return BigInt(0);
 
-  const totalExUnits = getTotalExUnits(tx.witness.redeemers);
+  let base: number = coinsPerRefScriptByte;
+  const range = 25_600;
+  const multiplier = 1.2;
+
+  let totalRefScriptsSize = 0;
+
+  const totalInputs = [...tx.body.inputs, ...(tx.body.referenceInputs ?? [])];
+  for (const output of totalInputs) {
+    const resolvedInput = resolvedInputs.find(
+      (input) => input[0].txId === output.txId && input[0].index === output.index
+    );
 
-  return BigInt(Math.ceil(totalExUnits.steps * exUnitsPrice.steps + totalExUnits.memory * exUnitsPrice.memory));
+    if (resolvedInput && resolvedInput[1].scriptReference) {
+      totalRefScriptsSize += Serialization.Script.fromCore(resolvedInput[1].scriptReference).toCbor().length / 2;
+    }
+  }
+
+  let scriptRefFee = 0;
+  while (totalRefScriptsSize > 0) {
+    scriptRefFee += Math.ceil(Math.min(range, totalRefScriptsSize) * base);
+    totalRefScriptsSize = Math.max(totalRefScriptsSize - range, 0);
+    base *= multiplier;
+  }
+
+  return BigInt(scriptRefFee);
 };
 
 /**
- * The value of the min fee constant is a payable fee, regardless of the size of the transaction. This parameter was
- * primarily introduced to prevent Distributed-Denial-of-Service (DDoS) attacks. This constant makes such attacks
- * prohibitively expensive, and eliminates the possibility of an attacker generating millions of small transactions
- * to flood and crash the system.
+ * Gets the minimum fee incurred by the scripts on the transaction.
+ *
+ * @param tx The transaction to compute the min script fee from.
+ * @param exUnitsPrice The prices of the execution units.
+ * @param resolvedInputs The resolved inputs of the transaction.
+ * @param coinsPerRefScriptByte The price per byte of the reference script.
  */
-export type MinFeeConstant = OpaqueNumber<'MinFeeConstant'>;
-export const MinFeeConstant = (value: number): MinFeeConstant => value as unknown as MinFeeConstant;
+const minScriptFee = (
+  tx: Cardano.Tx,
+  exUnitsPrice: Cardano.Prices,
+  resolvedInputs: Cardano.Utxo[],
+  coinsPerRefScriptByte: number
+): bigint => {
+  const scriptRefFee = minRefScriptFee(tx, resolvedInputs, coinsPerRefScriptByte);
 
-/**
- * Min fee coefficient reflects the dependence of the transaction cost on the size of the transaction. The larger
- * the transaction, the more resources are needed to store and process it.
- */
-export type MinFeeCoefficient = OpaqueNumber<'MinFeeCoefficient'>;
-export const MinFeeCoefficient = (value: number): MinFeeCoefficient => value as unknown as MinFeeCoefficient;
+  if (!tx.witness.redeemers) return BigInt(scriptRefFee);
+
+  const totalExUnits = getTotalExUnits(tx.witness.redeemers);
+
+  return (
+    BigInt(Math.ceil(totalExUnits.steps * exUnitsPrice.steps + totalExUnits.memory * exUnitsPrice.memory)) +
+    scriptRefFee
+  );
+};
 
 /**
  * Gets the minimum fee incurred by the transaction size.
@@ -88,7 +122,7 @@ export const MinFeeCoefficient = (value: number): MinFeeCoefficient => value as
  * @param minFeeConstant The prices of the execution units.
  * @param minFeeCoefficient The prices of the execution units.
  */
-const minNoScriptFee = (tx: Cardano.Tx, minFeeConstant: MinFeeConstant, minFeeCoefficient: MinFeeCoefficient) => {
+const minNoScriptFee = (tx: Cardano.Tx, minFeeConstant: number, minFeeCoefficient: number) => {
   const txSize = serializeTx(tx).length;
   return BigInt(Math.ceil(txSize * minFeeCoefficient + minFeeConstant));
 };
@@ -130,13 +164,14 @@ export const minAdaRequired = (output: Cardano.TxOut, coinsPerUtxoByte: bigint):
  * Gets the minimum transaction fee for the given transaction given its size and its execution units budget.
  *
  * @param tx The transaction to compute the min fee from.
- * @param exUnitsPrice The current (given by protocol parameters) execution unit prices.
- * @param minFeeConstant The current (given by protocol parameters) constant fee that all transaction must pay.
- * @param minFeeCoefficient The current (given by protocol parameters) transaction size fee coefficient.
+ * @param resolvedInputs The resolved inputs of the transaction.
+ * @param pparams The protocol parameters.
  */
-export const minFee = (
-  tx: Cardano.Tx,
-  exUnitsPrice: Cardano.Prices,
-  minFeeConstant: MinFeeConstant,
-  minFeeCoefficient: MinFeeCoefficient
-) => minNoScriptFee(tx, minFeeConstant, minFeeCoefficient) + minScriptFee(tx, exUnitsPrice);
+export const minFee = (tx: Cardano.Tx, resolvedInputs: Cardano.Utxo[], pparams: Cardano.ProtocolParameters) =>
+  minNoScriptFee(tx, pparams.minFeeConstant, pparams.minFeeCoefficient) +
+  minScriptFee(
+    tx,
+    pparams.prices,
+    resolvedInputs,
+    pparams.minFeeRefScriptCostPerByte ? Number(pparams.minFeeRefScriptCostPerByte) : 0
+  );

packages/tx-construction/src/input-selection/selectionConstraints.ts

@@ -3,15 +3,13 @@ import {
   ComputeMinimumCoinQuantity,
   ComputeSelectionLimit,
   EstimateTxCosts,
-  ProtocolParametersForInputSelection,
-  ProtocolParametersRequiredByInputSelection,
   SelectionConstraints,
   SelectionSkeleton,
   TokenBundleSizeExceedsLimit,
   sortTxIn
 } from '@cardano-sdk/input-selection';
-import { MinFeeCoefficient, MinFeeConstant, minAdaRequired, minFee } from '../fees';
 import { TxEvaluationResult, TxEvaluator, TxIdWithIndex } from '../tx-builder';
+import { minAdaRequired, minFee } from '../fees';
 
 export const MAX_U64 = 18_446_744_073_709_551_615n;
 
@@ -27,7 +25,7 @@ export interface RedeemersByType {
 }
 
 export interface DefaultSelectionConstraintsProps {
-  protocolParameters: ProtocolParametersForInputSelection;
+  protocolParameters: Cardano.ProtocolParameters;
   buildTx: BuildTx;
   redeemersByType: RedeemersByType;
   txEvaluator: TxEvaluator;
@@ -105,11 +103,7 @@ const reorgRedeemers = (
 
 export const computeMinimumCost =
   (
-    {
-      minFeeCoefficient,
-      minFeeConstant,
-      prices
-    }: Pick<ProtocolParametersRequiredByInputSelection, 'minFeeCoefficient' | 'minFeeConstant' | 'prices'>,
+    pparams: Cardano.ProtocolParameters,
     buildTx: BuildTx,
     txEvaluator: TxEvaluator,
     redeemersByType: RedeemersByType
@@ -126,18 +120,18 @@ export const computeMinimumCost =
     }
 
     return {
-      fee: minFee(tx, prices, MinFeeConstant(minFeeConstant), MinFeeCoefficient(minFeeCoefficient)),
+      fee: minFee(tx, utxos, pparams),
       redeemers: tx.witness.redeemers
     };
   };
 
 export const computeMinimumCoinQuantity =
-  (coinsPerUtxoByte: ProtocolParametersRequiredByInputSelection['coinsPerUtxoByte']): ComputeMinimumCoinQuantity =>
+  (coinsPerUtxoByte: Cardano.ProtocolParameters['coinsPerUtxoByte']): ComputeMinimumCoinQuantity =>
   (output) =>
     minAdaRequired(output, BigInt(coinsPerUtxoByte));
 
 export const tokenBundleSizeExceedsLimit =
-  (maxValueSize: ProtocolParametersRequiredByInputSelection['maxValueSize']): TokenBundleSizeExceedsLimit =>
+  (maxValueSize: Cardano.ProtocolParameters['maxValueSize']): TokenBundleSizeExceedsLimit =>
   (tokenBundle) => {
     if (!tokenBundle) {
       return false;
@@ -159,7 +153,7 @@ const getTxSize = (tx: Serialization.Transaction) => Buffer.from(tx.toCbor(), 'h
  * @returns {ComputeSelectionLimit} constraint that returns txSize <= maxTxSize ? utxo[].length : utxo[].length-1
  */
 export const computeSelectionLimit =
-  (maxTxSize: ProtocolParametersRequiredByInputSelection['maxTxSize'], buildTx: BuildTx): ComputeSelectionLimit =>
+  (maxTxSize: Cardano.ProtocolParameters['maxTxSize'], buildTx: BuildTx): ComputeSelectionLimit =>
   async (selectionSkeleton) => {
     const tx = await buildTx(selectionSkeleton);
     const txSize = getTxSize(Serialization.Transaction.fromCore(tx));
@@ -170,25 +164,27 @@ export const computeSelectionLimit =
   };
 
 export const defaultSelectionConstraints = ({
-  protocolParameters: { coinsPerUtxoByte, maxTxSize, maxValueSize, minFeeCoefficient, minFeeConstant, prices },
+  protocolParameters,
   buildTx,
   redeemersByType,
   txEvaluator
 }: DefaultSelectionConstraintsProps): SelectionConstraints => {
-  if (!coinsPerUtxoByte || !maxTxSize || !maxValueSize || !minFeeCoefficient || !minFeeConstant || !prices) {
+  if (
+    !protocolParameters.coinsPerUtxoByte ||
+    !protocolParameters.maxTxSize ||
+    !protocolParameters.maxValueSize ||
+    !protocolParameters.minFeeCoefficient ||
+    !protocolParameters.minFeeConstant ||
+    !protocolParameters.prices
+  ) {
     throw new InvalidProtocolParametersError(
       'Missing one of: coinsPerUtxoByte, maxTxSize, maxValueSize, minFeeCoefficient, minFeeConstant, prices'
     );
   }
   return {
-    computeMinimumCoinQuantity: computeMinimumCoinQuantity(coinsPerUtxoByte),
-    computeMinimumCost: computeMinimumCost(
-      { minFeeCoefficient, minFeeConstant, prices },
-      buildTx,
-      txEvaluator,
-      redeemersByType
-    ),
-    computeSelectionLimit: computeSelectionLimit(maxTxSize, buildTx),
-    tokenBundleSizeExceedsLimit: tokenBundleSizeExceedsLimit(maxValueSize)
+    computeMinimumCoinQuantity: computeMinimumCoinQuantity(protocolParameters.coinsPerUtxoByte),
+    computeMinimumCost: computeMinimumCost(protocolParameters, buildTx, txEvaluator, redeemersByType),
+    computeSelectionLimit: computeSelectionLimit(protocolParameters.maxTxSize, buildTx),
+    tokenBundleSizeExceedsLimit: tokenBundleSizeExceedsLimit(protocolParameters.maxValueSize)
   };
 };