fixing lrp datum serialisation re canonicality

src/contracts/lrp/helpers.ts

@@ -93,7 +93,8 @@ export function buildRedemptionsTx(
           lovelacesForRedemption,
         );
 
-        const lrpDatum = parseLrpDatumOrThrow(getInlineDatumOrThrow(lrpUtxo));
+        const lrpRawInlineDatum = getInlineDatumOrThrow(lrpUtxo);
+        const lrpDatum = parseLrpDatumOrThrow(lrpRawInlineDatum);
 
         const resultVal = addAssets(
           lrpUtxo.assets,
@@ -137,11 +138,14 @@ export function buildRedemptionsTx(
             lrpUtxo.address,
             {
               kind: 'inline',
-              value: serialiseLrpDatum({
-                ...lrpDatum,
-                lovelacesToSpend:
-                  lrpDatum.lovelacesToSpend - lovelacesForRedemption,
-              }),
+              value: serialiseLrpDatum(
+                {
+                  ...lrpDatum,
+                  lovelacesToSpend:
+                    lrpDatum.lovelacesToSpend - lovelacesForRedemption,
+                },
+                { _tag: 'adaptiveReplace', spentLrpDatum: lrpRawInlineDatum },
+              ),
             },
             resultVal,
           );

src/contracts/lrp/types.ts

@@ -5,6 +5,7 @@ import {
   OnChainDecimalSchema,
 } from '../../types/on-chain-decimal';
 import { option as O, function as F } from 'fp-ts';
+import { match, P } from 'ts-pattern';
 
 export const LRPParamsSchema = Data.Object({
   versionRecordToken: AssetClassSchema,
@@ -63,27 +64,60 @@ export function parseLrpDatumOrThrow(datum: Datum): LRPDatum {
   );
 }
 
-export function serialiseLrpDatum(datum: LRPDatum): Datum {
+type LRPSerialisationOptions =
+  // No replacing, just use non-canonical format.
+  | { _tag: 'noReplace' }
+  // Adaptive replace, when the spentDatum is canonical, do the replace,
+  // otherwise use the non canonical.
+  | { _tag: 'adaptiveReplace'; spentLrpDatum: string };
+
+export function serialiseLrpDatum(
+  datum: LRPDatum,
+  // Overall, we don't want to do the replacing. We just use non-canonical format.
+  serialisationOptions: LRPSerialisationOptions = { _tag: 'noReplace' },
+): Datum {
   const d = Data.to<LRPDatum>(datum, LRPDatum);
 
-  // If the lrp was created using a canonical on-chain decimal, we need to serialise it canonically.
-  // This is due to some issue related to how Aiken compares objects.
-  // See "Wrong continuing output" trace, specifically the spread of the previous datum ie. expecting the serialisation to be the same as it was created with
-  // We however do not want to do this for any lrps that are being build canonical.
-  const ocdSerialisedCanonical = Data.to<OnChainDecimal>(
-    datum.maxPrice,
-    OnChainDecimal,
-    { canonical: true },
-  );
-  const ocdSerialisedNonCanonical = Data.to<OnChainDecimal>(
-    datum.maxPrice,
-    OnChainDecimal,
-    { canonical: false },
-  );
+  return match(serialisationOptions)
+    .returnType<Datum>()
+    .with({ _tag: 'noReplace' }, () => d)
+    .with(
+      { _tag: 'adaptiveReplace', spentLrpDatum: P.select() },
+      (spentLrpDatum) => {
+        const isSpentDatumCanonical = spentLrpDatum.includes(
+          Data.to<OnChainDecimal>(
+            parseLrpDatumOrThrow(spentLrpDatum).maxPrice,
+            OnChainDecimal,
+            {
+              canonical: true,
+            },
+          ),
+        );
+
+        // When spent datum was canonical, replace.
+        if (isSpentDatumCanonical) {
+          // If the lrp was created using a canonical on-chain decimal, we need to serialise it canonically.
+          // This is due to some issue related to how Aiken compares objects.
+          // See "Wrong continuing output" trace, specifically the spread of the previous datum ie. expecting the serialisation to be the same as it was created with
+          // We however do not want to do this for any lrps that are being build canonical.
+          const ocdSerialisedCanonical = Data.to<OnChainDecimal>(
+            datum.maxPrice,
+            OnChainDecimal,
+            { canonical: true },
+          );
+          const ocdSerialisedNonCanonical = Data.to<OnChainDecimal>(
+            datum.maxPrice,
+            OnChainDecimal,
+            { canonical: false },
+          );
 
-  return d.replace(ocdSerialisedNonCanonical, ocdSerialisedCanonical);
+          return d.replace(ocdSerialisedNonCanonical, ocdSerialisedCanonical);
+        }
 
-  // return d;
+        return d;
+      },
+    )
+    .exhaustive();
 }
 
 export function serialiseLrpRedeemer(redeemer: LRPRedeemer): Redeemer {

src/contracts/stability-pool/types-new.ts

@@ -2,7 +2,6 @@ import { Core as EvoCore } from '@evolution-sdk/evolution';
 import { match, P } from 'ts-pattern';
 import { AddressSchema } from '@3rd-eye-labs/cardano-offchain-common';
 import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
-import { Data } from '@lucid-evolution/lucid';
 
 export const SPIntegerSchema = EvoCore.TSchema.Struct({
   value: EvoCore.TSchema.Integer,

src/contracts/staking/types-new.ts

@@ -2,7 +2,6 @@ import { Core as EvoCore } from '@evolution-sdk/evolution';
 import { option as O, function as F } from 'fp-ts';
 import { match, P } from 'ts-pattern';
 import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
-import { Data } from '@lucid-evolution/lucid';
 
 const StakingPosLockedAmtSchema = EvoCore.TSchema.Map(
   EvoCore.TSchema.Integer,