fix: add reference script size to base fee calculation for native scripts

- Include reference script bytes in transaction size for base fee
- Apply tiered pricing separately (15/25/100 lovelace per byte)
- Fix native script detection in reference inputs for redeemer validation
- Use Equal.equals() for KeyHash deduplication in AddSigner

Author: solidsnakedev

packages/evolution-devnet/test/TxBuilder.NativeScript.test.ts

@@ -324,9 +324,7 @@ describe("TxBuilder NativeScript (Devnet Submit)", () => {
 
     const submitBuilder = await signBuilder.sign()
     const txHash = await submitBuilder.submit()
-
     expect(txHash.length).toBe(64)
-
     const confirmed = await client.awaitTx(txHash, 1000)
     expect(confirmed).toBe(true)
   })
@@ -558,4 +556,105 @@ describe("TxBuilder NativeScript (Devnet Submit)", () => {
     const mintConfirmed = await client1.awaitTx(mintTxHash, 1000)
     expect(mintConfirmed).toBe(true)
   })
+
+  it("should spend from script address using native script as reference input", { timeout: 60_000 }, async () => {
+    const client1 = createTestClient(0)
+    const client2 = createTestClient(1)
+
+    const address1 = await client1.address()
+    const address2 = await client2.address()
+
+    const credential1 = address1.paymentCredential
+    const credential2 = address2.paymentCredential
+
+    if (credential1._tag !== "KeyHash" || credential2._tag !== "KeyHash") {
+      throw new Error("Expected KeyHash credentials")
+    }
+
+    // Create a 2-of-2 multi-sig native script
+    const script1 = NativeScripts.makeScriptPubKey(credential1.hash)
+    const script2 = NativeScripts.makeScriptPubKey(credential2.hash)
+    const multiSigScript = NativeScripts.makeScriptAll([script1.script, script2.script])
+
+    const scriptHash = ScriptHash.fromScript(multiSigScript)
+
+    // Create script address
+    const scriptAddress = new Address.Address({
+      networkId: 0,
+      paymentCredential: scriptHash,
+      stakingCredential: undefined
+    })
+
+    // Step 1: Create a UTxO with the native script as a reference script
+    const refScriptSignBuilder = await client1
+      .newTx()
+      .payToAddress({
+        address: address1,
+        assets: Core.Assets.fromLovelace(5_000_000n),
+        script: multiSigScript
+      })
+      .build()
+
+    const refScriptSubmitBuilder = await refScriptSignBuilder.sign()
+    const refScriptTxHash = await refScriptSubmitBuilder.submit()
+
+    expect(refScriptTxHash.length).toBe(64)
+    await client1.awaitTx(refScriptTxHash, 1000)
+    await new Promise((resolve) => setTimeout(resolve, 2_000))
+
+    // Step 2: Fund the script address
+    const fundSignBuilder = await client1
+      .newTx()
+      .payToAddress({
+        address: scriptAddress,
+        assets: Core.Assets.fromLovelace(10_000_000n)
+      })
+      .build()
+
+    const fundSubmitBuilder = await fundSignBuilder.sign()
+    const fundTxHash = await fundSubmitBuilder.submit()
+
+    await client1.awaitTx(fundTxHash, 1000)
+    await new Promise((resolve) => setTimeout(resolve, 2_000))
+
+    // Fetch UTxOs at the script address
+    const scriptUtxos = await client1.getUtxos(scriptAddress)
+    expect(scriptUtxos.length).toBeGreaterThan(0)
+
+    const scriptUtxo = scriptUtxos.find((u) => UTxO.toOutRefString(u).startsWith(fundTxHash))
+    expect(scriptUtxo).toBeDefined()
+
+    // Find the UTxO with the reference script (fetch AFTER fund tx to get fresh state)
+    const walletUtxos = await client1.getUtxos(address1)
+    const refScriptUtxo = walletUtxos.find(
+      (u) => UTxO.toOutRefString(u).startsWith(refScriptTxHash) && u.scriptRef !== undefined
+    )
+    expect(refScriptUtxo).toBeDefined()
+    expect(refScriptUtxo!.scriptRef).toBeDefined()
+
+    // Step 3: Spend from script address using readFrom (reference input) instead of attachScript
+    // This tests that native scripts provided via reference inputs don't incorrectly require redeemers
+    const spendSignBuilder = await client1
+      .newTx()
+      .readFrom({ referenceInputs: [refScriptUtxo!] }) // Reference the UTxO with the script
+      .collectFrom({ inputs: [scriptUtxo!] }) // Spend from the script address
+      .payToAddress({
+        address: address1,
+        assets: Core.Assets.fromLovelace(5_000_000n)
+      })
+      .build()
+
+    const spendTx = await spendSignBuilder.toTransaction()
+
+    // Both clients must sign (native script requires signatures)
+    const witness1 = await spendSignBuilder.partialSign()
+    const witness2 = await client2.signTx(spendTx)
+
+    const spendSubmitBuilder = await spendSignBuilder.assemble([witness1, witness2])
+    const spendTxHash = await spendSubmitBuilder.submit()
+    
+    expect(spendTxHash.length).toBe(64)
+    const spendConfirmed = await client1.awaitTx(spendTxHash, 1000)
+    expect(spendConfirmed).toBe(true)
+  })
 })

packages/evolution-devnet/test/utils/utxo-helpers.ts

@@ -2,8 +2,7 @@ import { Core } from "@evolution-sdk/evolution"
 import * as CoreAddress from "@evolution-sdk/evolution/core/Address"
 import * as CoreData from "@evolution-sdk/evolution/core/Data"
 import * as CoreDatumOption from "@evolution-sdk/evolution/core/DatumOption"
-import * as CoreScript from "@evolution-sdk/evolution/core/Script"
-import * as CoreScriptRef from "@evolution-sdk/evolution/core/ScriptRef"
+import type * as CoreScript from "@evolution-sdk/evolution/core/Script"
 import * as CoreTransactionHash from "@evolution-sdk/evolution/core/TransactionHash"
 import * as CoreUTxO from "@evolution-sdk/evolution/core/UTxO"
 import type * as Datum from "@evolution-sdk/evolution/sdk/Datum"
@@ -103,20 +102,12 @@ export const createCoreTestUtxo = (options: CreateCoreTestUtxoOptions): CoreUTxO
     }
   }
 
-  // Convert Core Script to ScriptRef
-  let coreScriptRef: CoreScriptRef.ScriptRef | undefined
-  if (scriptRef) {
-    // Convert Script to ScriptRef bytes (CBOR-encoded script)
-    const scriptBytes = CoreScript.toCBOR(scriptRef)
-    coreScriptRef = new CoreScriptRef.ScriptRef({ bytes: scriptBytes })
-  }
-
   return new CoreUTxO.UTxO({
     transactionId: CoreTransactionHash.fromHex(paddedTxId),
     index: BigInt(index),
     address: CoreAddress.fromBech32(address),
     assets,
-    scriptRef: coreScriptRef,
+    scriptRef,
     datumOption: coreDatumOption
   })
 }

packages/evolution/src/core/NativeScripts.ts

@@ -636,3 +636,45 @@ export const countRequiredSigners = (script: NativeScriptVariants): number => {
       return 0
   }
 }
+/**
+ * Extract all key hashes from a native script.
+ * Recursively traverses nested scripts to find all ScriptPubKey key hashes.
+ *
+ * @example
+ * import { NativeScripts } from "@evolution-sdk/core"
+ *
+ * const script = NativeScripts.makeScriptAll([
+ *   NativeScripts.makeScriptPubKey(keyHash1).script,
+ *   NativeScripts.makeScriptPubKey(keyHash2).script
+ * ])
+ * const keyHashes = NativeScripts.extractKeyHashes(script.script)
+ * // Returns Set<Uint8Array> containing keyHash1 and keyHash2
+ *
+ * @since 2.0.0
+ * @category utilities
+ */
+export const extractKeyHashes = (script: NativeScriptVariants): ReadonlyArray<Uint8Array> => {
+  const keyHashes: Array<Uint8Array> = []
+  
+  const traverse = (s: NativeScriptVariants): void => {
+    switch (s._tag) {
+      case "ScriptPubKey":
+        keyHashes.push(s.keyHash)
+        break
+      case "ScriptAll":
+      case "ScriptAny":
+        for (const nested of s.scripts) traverse(nested)
+        break
+      case "ScriptNOfK":
+        for (const nested of s.scripts) traverse(nested)
+        break
+      case "InvalidBefore":
+      case "InvalidHereafter":
+        // Time-based scripts don't contain key hashes
+        break
+    }
+  }
+  
+  traverse(script)
+  return keyHashes
+}

packages/evolution/src/sdk/builders/TxBuilderImpl.ts

@@ -152,22 +152,26 @@ export const calculateReferenceScriptFee = (
   referenceInputs: ReadonlyArray<CoreUTxO.UTxO>
 ): Effect.Effect<bigint, TransactionBuilderError> =>
   Effect.gen(function* () {
-    // Calculate total reference script size in bytes
+    // Calculate total reference script size in bytes (both native and Plutus)
+    // Per ADR 2024-08-14_009: "Native scripts that are used as reference scripts also contribute their size to this calculation"
     let totalScriptSize = 0
 
     for (const utxo of referenceInputs) {
       if (utxo.scriptRef) {
-        // Get script CBOR bytes length from Core Script type
         const scriptBytes = CoreScript.toCBOR(utxo.scriptRef).length
         totalScriptSize += scriptBytes
+        const scriptType = utxo.scriptRef._tag === "NativeScript" ? "Native" : "Plutus"
+        yield* Effect.logDebug(`[RefScriptFee] ${scriptType} script in ref input: ${scriptBytes} bytes`)
       }
     }
 
-    // No reference scripts = no fee
+    // No reference scripts = no tiered fee
     if (totalScriptSize === 0) {
       return 0n
     }
 
+    yield* Effect.logDebug(`[RefScriptFee] Total reference script size: ${totalScriptSize} bytes`)
+    
     // Check maximum size limit (200KB)
     if (totalScriptSize > 200_000) {
       return yield* Effect.fail(
@@ -177,7 +181,7 @@ export const calculateReferenceScriptFee = (
       )
     }
 
-    // Calculate tiered fees
+    // Calculate tiered fees for all reference scripts
     let fee = 0n
     let remainingSize = totalScriptSize
     let tierIndex = 0
@@ -188,11 +192,14 @@ export const calculateReferenceScriptFee = (
       const bytesInThisTier = Math.min(remainingSize, tierSize)
       const tierFee = BigInt(Math.ceil(bytesInThisTier * tierPrices[tierIndex]!))
       fee += tierFee
+      yield* Effect.logDebug(`[RefScriptFee] Tier ${tierIndex + 1}: ${bytesInThisTier} bytes × ${tierPrices[tierIndex]} lovelace/byte = ${tierFee} lovelace`)
 
       remainingSize -= tierSize
       tierIndex++
     }
 
+    yield* Effect.logDebug(`[RefScriptFee] Total tiered fee (Plutus only): ${fee} lovelace`)
+    
     return fee
   })
 
@@ -1224,6 +1231,19 @@ export const calculateFeeIteratively = (
       ? (state.requiredSigners as [KeyHash.KeyHash, ...Array<KeyHash.KeyHash>])
       : undefined
 
+    // Build referenceInputs for size estimation
+    // Reference inputs add to transaction size and must be included in fee calculation
+    let referenceInputsForFee:
+      | readonly [TransactionInput.TransactionInput, ...Array<TransactionInput.TransactionInput>]
+      | undefined
+    if (state.referenceInputs.length > 0) {
+      const refInputs = yield* buildTransactionInputs(state.referenceInputs)
+      referenceInputsForFee = refInputs as readonly [
+        TransactionInput.TransactionInput,
+        ...Array<TransactionInput.TransactionInput>,
+      ]
+    }
+
     while (iterations < maxIterations) {
       // Build transaction with current fee estimate
       const body = new TransactionBody.TransactionBody({
@@ -1237,7 +1257,8 @@ export const calculateFeeIteratively = (
         totalCollateral, // Include total collateral for accurate size
         certificates, // Include certificates for accurate size calculation
         withdrawals, // Include withdrawals for accurate size calculation
-        requiredSigners // Include requiredSigners for accurate size calculation
+        requiredSigners, // Include requiredSigners for accurate size calculation
+        referenceInputs: referenceInputsForFee // Include reference inputs for accurate size calculation
       })
 
       const transaction = new Transaction.Transaction({
@@ -1249,9 +1270,20 @@ export const calculateFeeIteratively = (
 
       // Calculate size
       const size = yield* calculateTransactionSize(transaction)
+      
+      // Add reference script sizes to transaction size for base fee calculation
+      // Despite ADR docs, actual node behavior includes ref scripts in tx size for base fee
+      let refScriptSize = 0
+      for (const utxo of state.referenceInputs) {
+        if (utxo.scriptRef) {
+          const scriptBytes = CoreScript.toCBOR(utxo.scriptRef).length
+          refScriptSize += scriptBytes
+        }
+      }
+      const sizeWithRefScripts = size + refScriptSize
 
-      // Calculate base fee based on size
-      const baseFee = calculateMinimumFee(size, {
+      // Calculate base fee based on size including reference scripts
+      const baseFee = calculateMinimumFee(sizeWithRefScripts, {
         minFeeCoefficient: protocolParams.minFeeCoefficient,
         minFeeConstant: protocolParams.minFeeConstant
       })

packages/evolution/src/sdk/builders/operations/AddSigner.ts

@@ -9,7 +9,7 @@
  * @since 2.0.0
  */
 
-import { Effect, Ref } from "effect"
+import { Effect, Equal, Ref } from "effect"
 
 import { TxContext } from "../TransactionBuilder.js"
 import type { AddSignerParams } from "./Operations.js"
@@ -31,11 +31,7 @@ export const createAddSignerProgram = (params: AddSignerParams) =>
 
     yield* Ref.update(ctx, (state) => {
       // Check if this key hash is already in requiredSigners (deduplicate)
-      const alreadyExists = state.requiredSigners.some(
-        (existing) => 
-          existing.hash.length === params.keyHash.hash.length &&
-          existing.hash.every((b, i) => b === params.keyHash.hash[i])
-      )
+      const alreadyExists = state.requiredSigners.some((existing) => Equal.equals(existing, params.keyHash))
 
       if (alreadyExists) {
         return state

packages/evolution/src/sdk/builders/operations/Collect.ts

@@ -52,19 +52,29 @@ export const createCollectFromProgram = (params: CollectFromParams) =>
     // 2. Filter script-locked UTxOs
     const scriptUtxos = yield* filterScriptUtxos(params.inputs)
 
-    // 3. Filter out native script UTxOs (those with attached native scripts don't need redeemers)
+    // 3. Filter out native script UTxOs (those with native scripts don't need redeemers)
     // Native scripts are validated by signatures, not redeemers
+    // Check: attached scripts, inline scriptRef, and reference inputs
     const plutusScriptUtxos = scriptUtxos.filter((utxo) => {
       const credential = utxo.address.paymentCredential
       if (credential?._tag !== "ScriptHash") return false
 
       const scriptHashHex = ScriptHash.toHex(credential)
-      const attachedScript = state.scripts.get(scriptHashHex)
 
-      // If script is attached and is a NativeScript, no redeemer needed
+      // Check 1: Script attached via attachScript()
+      const attachedScript = state.scripts.get(scriptHashHex)
       if (attachedScript?._tag === "NativeScript") return false
 
-      // Otherwise it's a Plutus script (or script not attached yet)
+      // Check 2: Script inline in the UTxO being spent
+      if (utxo.scriptRef?._tag === "NativeScript") return false
+      
+      // Check 3: Script available via reference input
+      const refScript = state.referenceInputs.find((ref) => 
+        ref.scriptRef && ScriptHash.toHex(ScriptHash.fromScript(ref.scriptRef)) === scriptHashHex
+      )
+      if (refScript?.scriptRef?._tag === "NativeScript") return false
+      
+      // Otherwise it's a Plutus script (or script not found)
       return true
     })
 

packages/evolution/src/sdk/builders/phases/FeeCalculation.ts

@@ -85,14 +85,14 @@ export const executeFeeCalculation = (): Effect.Effect<
       priceStep: protocolParams.priceStep
     })
 
-    yield* Effect.logDebug(`[FeeCalculation] Base fee: ${baseFee}`)
+    yield* Effect.logDebug(`[FeeCalculation] Base fee (includes ref script size): ${baseFee}`)
 
-    // Step 4a: Add reference script fee if reference inputs are present
+    // Step 4a: Add tiered reference script fee for all reference scripts
     const refScriptFee = yield* calculateReferenceScriptFee(state.referenceInputs)
-    yield* Effect.logDebug(`[FeeCalculation] Reference script fee: ${refScriptFee}`)
+    yield* Effect.logDebug(`[FeeCalculation] Tiered reference script fee: ${refScriptFee}`)
 
     const calculatedFee = baseFee + refScriptFee
-    yield* Effect.logDebug(`[FeeCalculation] Total fee (base + refScript): ${calculatedFee}`)
+    yield* Effect.logDebug(`[FeeCalculation] Total fee: ${calculatedFee}`)
 
     // Step 5: Calculate leftover after fee NOW (after fee is known)
     const inputAssets = state.totalInputAssets