@indigo-labs/indigo-sdk 0.2.32 → 0.2.34

package/dist/index.d.mts

@@ -322,6 +322,7 @@ declare const OnChainDecimalSchema: _lucid_evolution_lucid.TObject<{
     getOnChainInt: _lucid_evolution_lucid.TUnsafe<bigint>;
 }>;
 type OnChainDecimal = Data.Static<typeof OnChainDecimalSchema>;
+declare const OnChainDecimal: OnChainDecimal;
 
 declare const CdpParamsSchema: _lucid_evolution_lucid.TObject<{
     cdp_auth_token: _lucid_evolution_lucid.TObject<{
@@ -2012,7 +2013,13 @@ declare const LRPRedeemerSchema: _lucid_evolution_lucid.TUnion<(_lucid_evolution
 type LRPRedeemer = Data.Static<typeof LRPRedeemerSchema>;
 declare function parseLrpDatum(datum: Datum): option.Option<LRPDatum>;
 declare function parseLrpDatumOrThrow(datum: Datum): LRPDatum;
-declare function serialiseLrpDatum(datum: LRPDatum): Datum;
+type LRPSerialisationOptions = {
+    _tag: 'noReplace';
+} | {
+    _tag: 'adaptiveReplace';
+    spentLrpDatum: string;
+};
+declare function serialiseLrpDatum(datum: LRPDatum, serialisationOptions?: LRPSerialisationOptions): Datum;
 declare function serialiseLrpRedeemer(redeemer: LRPRedeemer): Redeemer;
 declare function castLrpParams(params: LRPParams): Data;
 type LrpOutput = {

package/dist/index.d.ts

@@ -322,6 +322,7 @@ declare const OnChainDecimalSchema: _lucid_evolution_lucid.TObject<{
     getOnChainInt: _lucid_evolution_lucid.TUnsafe<bigint>;
 }>;
 type OnChainDecimal = Data.Static<typeof OnChainDecimalSchema>;
+declare const OnChainDecimal: OnChainDecimal;
 
 declare const CdpParamsSchema: _lucid_evolution_lucid.TObject<{
     cdp_auth_token: _lucid_evolution_lucid.TObject<{
@@ -2012,7 +2013,13 @@ declare const LRPRedeemerSchema: _lucid_evolution_lucid.TUnion<(_lucid_evolution
 type LRPRedeemer = Data.Static<typeof LRPRedeemerSchema>;
 declare function parseLrpDatum(datum: Datum): option.Option<LRPDatum>;
 declare function parseLrpDatumOrThrow(datum: Datum): LRPDatum;
-declare function serialiseLrpDatum(datum: LRPDatum): Datum;
+type LRPSerialisationOptions = {
+    _tag: 'noReplace';
+} | {
+    _tag: 'adaptiveReplace';
+    spentLrpDatum: string;
+};
+declare function serialiseLrpDatum(datum: LRPDatum, serialisationOptions?: LRPSerialisationOptions): Datum;
 declare function serialiseLrpRedeemer(redeemer: LRPRedeemer): Redeemer;
 declare function castLrpParams(params: LRPParams): Data;
 type LrpOutput = {

package/dist/index.js

@@ -414,6 +414,7 @@ var OCD_DECIMAL_UNIT = 1000000n;
 var OnChainDecimalSchema = import_lucid4.Data.Object({
   getOnChainInt: import_lucid4.Data.Integer()
 });
+var OnChainDecimal = OnChainDecimalSchema;
 function ocdCeil(a) {
   const whole = a.getOnChainInt / OCD_DECIMAL_UNIT;
   return a.getOnChainInt > whole * OCD_DECIMAL_UNIT ? whole + 1n : whole;
@@ -5373,6 +5374,7 @@ var import_lucid47 = require("@lucid-evolution/lucid");
 // src/contracts/lrp/types.ts
 var import_lucid46 = require("@lucid-evolution/lucid");
 var import_fp_ts11 = require("fp-ts");
+var import_ts_pattern12 = require("ts-pattern");
 var LRPParamsSchema = import_lucid46.Data.Object({
   versionRecordToken: AssetClassSchema,
   iassetNft: AssetClassSchema,
@@ -5422,11 +5424,39 @@ function parseLrpDatumOrThrow(datum) {
     }, import_fp_ts11.function.identity)
   );
 }
-function serialiseLrpDatum(datum) {
-  return import_lucid46.Data.to(datum, LRPDatum);
+function serialiseLrpDatum(datum, serialisationOptions = { _tag: "noReplace" }) {
+  const d = import_lucid46.Data.to(datum, LRPDatum);
+  return (0, import_ts_pattern12.match)(serialisationOptions).returnType().with({ _tag: "noReplace" }, () => d).with(
+    { _tag: "adaptiveReplace", spentLrpDatum: import_ts_pattern12.P.select() },
+    (spentLrpDatum) => {
+      const isSpentDatumCanonical = spentLrpDatum.includes(
+        import_lucid46.Data.to(
+          parseLrpDatumOrThrow(spentLrpDatum).maxPrice,
+          OnChainDecimal,
+          {
+            canonical: true
+          }
+        )
+      );
+      if (isSpentDatumCanonical) {
+        const ocdSerialisedCanonical = import_lucid46.Data.to(
+          datum.maxPrice,
+          OnChainDecimal,
+          { canonical: true }
+        );
+        const ocdSerialisedNonCanonical = import_lucid46.Data.to(
+          datum.maxPrice,
+          OnChainDecimal,
+          { canonical: false }
+        );
+        return d.replace(ocdSerialisedNonCanonical, ocdSerialisedCanonical);
+      }
+      return d;
+    }
+  ).exhaustive();
 }
 function serialiseLrpRedeemer(redeemer) {
-  return import_lucid46.Data.to(redeemer, LRPRedeemer, { canonical: false });
+  return import_lucid46.Data.to(redeemer, LRPRedeemer);
 }
 function castLrpParams(params) {
   return import_lucid46.Data.castTo(params, LRPParams);
@@ -5466,7 +5496,7 @@ function insertSorted(arr, item, ord) {
 }
 
 // src/contracts/lrp/helpers.ts
-var import_ts_pattern12 = require("ts-pattern");
+var import_ts_pattern13 = require("ts-pattern");
 var MIN_LRP_COLLATERAL_AMT = 2000000n;
 function lrpRedeemableLovelacesInclReimb(lrp, lrpParams) {
   const datum = lrp[1];
@@ -5483,8 +5513,8 @@ function lrpRedeemableLovelacesInclReimb(lrp, lrpParams) {
   return res;
 }
 function buildRedemptionsTx(redemptions, price, redemptionReimbursementPercentage, sysParams, tx, txOutputsBeforeCount) {
-  const [[mainLrpUtxo, _], __] = (0, import_ts_pattern12.match)(redemptions).with(
-    [import_ts_pattern12.P._, ...import_ts_pattern12.P.array()],
+  const [[mainLrpUtxo, _], __] = (0, import_ts_pattern13.match)(redemptions).with(
+    [import_ts_pattern13.P._, ...import_ts_pattern13.P.array()],
     ([[firstLrp, _2], ...rest]) => [
       [firstLrp, _2],
       rest
@@ -5508,7 +5538,8 @@ function buildRedemptionsTx(redemptions, price, redemptionReimbursementPercentag
           redemptionReimbursementPercentage,
           lovelacesForRedemption
         );
-        const lrpDatum = parseLrpDatumOrThrow(getInlineDatumOrThrow(lrpUtxo));
+        const lrpRawInlineDatum = getInlineDatumOrThrow(lrpUtxo);
+        const lrpDatum = parseLrpDatumOrThrow(lrpRawInlineDatum);
         const resultVal = (0, import_lucid47.addAssets)(
           lrpUtxo.assets,
           mkLovelacesOf(-lovelacesForRedemption + reimburstmentLovelaces),
@@ -5543,10 +5574,13 @@ function buildRedemptionsTx(redemptions, price, redemptionReimbursementPercentag
           lrpUtxo.address,
           {
             kind: "inline",
-            value: serialiseLrpDatum({
-              ...lrpDatum,
-              lovelacesToSpend: lrpDatum.lovelacesToSpend - lovelacesForRedemption
-            })
+            value: serialiseLrpDatum(
+              {
+                ...lrpDatum,
+                lovelacesToSpend: lrpDatum.lovelacesToSpend - lovelacesForRedemption
+              },
+              { _tag: "adaptiveReplace", spentLrpDatum: lrpRawInlineDatum }
+            )
           },
           resultVal
         );

package/dist/index.mjs

@@ -177,6 +177,7 @@ var OCD_DECIMAL_UNIT = 1000000n;
 var OnChainDecimalSchema = Data2.Object({
   getOnChainInt: Data2.Integer()
 });
+var OnChainDecimal = OnChainDecimalSchema;
 function ocdCeil(a) {
   const whole = a.getOnChainInt / OCD_DECIMAL_UNIT;
   return a.getOnChainInt > whole * OCD_DECIMAL_UNIT ? whole + 1n : whole;
@@ -5210,6 +5211,7 @@ import { addAssets as addAssets8 } from "@lucid-evolution/lucid";
 // src/contracts/lrp/types.ts
 import { Data as Data26 } from "@lucid-evolution/lucid";
 import { option as O8, function as F9 } from "fp-ts";
+import { match as match12, P as P11 } from "ts-pattern";
 var LRPParamsSchema = Data26.Object({
   versionRecordToken: AssetClassSchema,
   iassetNft: AssetClassSchema,
@@ -5259,11 +5261,39 @@ function parseLrpDatumOrThrow(datum) {
     }, F9.identity)
   );
 }
-function serialiseLrpDatum(datum) {
-  return Data26.to(datum, LRPDatum);
+function serialiseLrpDatum(datum, serialisationOptions = { _tag: "noReplace" }) {
+  const d = Data26.to(datum, LRPDatum);
+  return match12(serialisationOptions).returnType().with({ _tag: "noReplace" }, () => d).with(
+    { _tag: "adaptiveReplace", spentLrpDatum: P11.select() },
+    (spentLrpDatum) => {
+      const isSpentDatumCanonical = spentLrpDatum.includes(
+        Data26.to(
+          parseLrpDatumOrThrow(spentLrpDatum).maxPrice,
+          OnChainDecimal,
+          {
+            canonical: true
+          }
+        )
+      );
+      if (isSpentDatumCanonical) {
+        const ocdSerialisedCanonical = Data26.to(
+          datum.maxPrice,
+          OnChainDecimal,
+          { canonical: true }
+        );
+        const ocdSerialisedNonCanonical = Data26.to(
+          datum.maxPrice,
+          OnChainDecimal,
+          { canonical: false }
+        );
+        return d.replace(ocdSerialisedNonCanonical, ocdSerialisedCanonical);
+      }
+      return d;
+    }
+  ).exhaustive();
 }
 function serialiseLrpRedeemer(redeemer) {
-  return Data26.to(redeemer, LRPRedeemer, { canonical: false });
+  return Data26.to(redeemer, LRPRedeemer);
 }
 function castLrpParams(params) {
   return Data26.castTo(params, LRPParams);
@@ -5303,7 +5333,7 @@ function insertSorted(arr, item, ord) {
 }
 
 // src/contracts/lrp/helpers.ts
-import { match as match12, P as P11 } from "ts-pattern";
+import { match as match13, P as P12 } from "ts-pattern";
 var MIN_LRP_COLLATERAL_AMT = 2000000n;
 function lrpRedeemableLovelacesInclReimb(lrp, lrpParams) {
   const datum = lrp[1];
@@ -5320,8 +5350,8 @@ function lrpRedeemableLovelacesInclReimb(lrp, lrpParams) {
   return res;
 }
 function buildRedemptionsTx(redemptions, price, redemptionReimbursementPercentage, sysParams, tx, txOutputsBeforeCount) {
-  const [[mainLrpUtxo, _], __] = match12(redemptions).with(
-    [P11._, ...P11.array()],
+  const [[mainLrpUtxo, _], __] = match13(redemptions).with(
+    [P12._, ...P12.array()],
     ([[firstLrp, _2], ...rest]) => [
       [firstLrp, _2],
       rest
@@ -5345,7 +5375,8 @@ function buildRedemptionsTx(redemptions, price, redemptionReimbursementPercentag
           redemptionReimbursementPercentage,
           lovelacesForRedemption
         );
-        const lrpDatum = parseLrpDatumOrThrow(getInlineDatumOrThrow(lrpUtxo));
+        const lrpRawInlineDatum = getInlineDatumOrThrow(lrpUtxo);
+        const lrpDatum = parseLrpDatumOrThrow(lrpRawInlineDatum);
         const resultVal = addAssets8(
           lrpUtxo.assets,
           mkLovelacesOf(-lovelacesForRedemption + reimburstmentLovelaces),
@@ -5380,10 +5411,13 @@ function buildRedemptionsTx(redemptions, price, redemptionReimbursementPercentag
           lrpUtxo.address,
           {
             kind: "inline",
-            value: serialiseLrpDatum({
-              ...lrpDatum,
-              lovelacesToSpend: lrpDatum.lovelacesToSpend - lovelacesForRedemption
-            })
+            value: serialiseLrpDatum(
+              {
+                ...lrpDatum,
+                lovelacesToSpend: lrpDatum.lovelacesToSpend - lovelacesForRedemption
+              },
+              { _tag: "adaptiveReplace", spentLrpDatum: lrpRawInlineDatum }
+            )
           },
           resultVal
         );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigo-labs/indigo-sdk",
-  "version": "0.2.32",
+  "version": "0.2.34",
   "description": "Indigo SDK for interacting with Indigo endpoints via lucid-evolution",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/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,
           );

package/src/contracts/lrp/types.ts

@@ -1,7 +1,11 @@
 import { Data, Datum, Redeemer, UTxO } from '@lucid-evolution/lucid';
 import { AssetClassSchema, OutputReferenceSchema } from '../../types/generic';
-import { OnChainDecimalSchema } from '../../types/on-chain-decimal';
+import {
+  OnChainDecimal,
+  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,
@@ -60,12 +64,64 @@ export function parseLrpDatumOrThrow(datum: Datum): LRPDatum {
   );
 }
 
-export function serialiseLrpDatum(datum: LRPDatum): Datum {
-  return Data.to<LRPDatum>(datum, LRPDatum);
+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);
+
+  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;
+      },
+    )
+    .exhaustive();
 }
 
 export function serialiseLrpRedeemer(redeemer: LRPRedeemer): Redeemer {
-  return Data.to<LRPRedeemer>(redeemer, LRPRedeemer, { canonical: false });
+  return Data.to<LRPRedeemer>(redeemer, LRPRedeemer);
 }
 
 export function castLrpParams(params: LRPParams): Data {

package/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,

package/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,

package/src/types/on-chain-decimal.ts

@@ -6,6 +6,7 @@ export const OnChainDecimalSchema = Data.Object({
   getOnChainInt: Data.Integer(),
 });
 export type OnChainDecimal = Data.Static<typeof OnChainDecimalSchema>;
+export const OnChainDecimal = OnChainDecimalSchema as unknown as OnChainDecimal;
 
 export function ocdCeil(a: OnChainDecimal): bigint {
   const whole = a.getOnChainInt / OCD_DECIMAL_UNIT;