@indigo-labs/indigo-sdk 0.2.33 → 0.2.35

package/dist/index.d.mts

@@ -2013,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

@@ -2013,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

@@ -3592,7 +3592,12 @@ async function vote(voteOption, pollShardOref, stakingPositionOref, sysParams, l
     BigInt(validityFrom),
     indyStakedAmt
   );
-  return lucid.newTx().validFrom(validityFrom).validTo(Number(pollShardDatum.votingEndTime) - ONE_SECOND).readFrom([stakingRefScriptUtxo, pollShardRefScriptUtxo]).collectFrom([stakingPosUtxo], serialiseStakingRedeemer("Lock")).collectFrom(
+  return lucid.newTx().validFrom(validityFrom).validTo(
+    Math.min(
+      Number(pollShardDatum.votingEndTime) - ONE_SECOND,
+      Number(currentTime) + Number(sysParams.govParams.gBiasTime) - ONE_SECOND
+    )
+  ).readFrom([stakingRefScriptUtxo, pollShardRefScriptUtxo]).collectFrom([stakingPosUtxo], serialiseStakingRedeemer("Lock")).collectFrom(
     [pollShardUtxo],
     serialisePollShardRedeemer({ Vote: { content: voteOption } })
   ).pay.ToContract(
@@ -5374,6 +5379,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,
@@ -5423,19 +5429,36 @@ function parseLrpDatumOrThrow(datum) {
     }, import_fp_ts11.function.identity)
   );
 }
-function serialiseLrpDatum(datum) {
+function serialiseLrpDatum(datum, serialisationOptions = { _tag: "noReplace" }) {
   const d = import_lucid46.Data.to(datum, LRPDatum);
-  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 (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);
@@ -5478,7 +5501,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];
@@ -5495,8 +5518,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
@@ -5520,7 +5543,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),
@@ -5555,10 +5579,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

@@ -3386,7 +3386,12 @@ async function vote(voteOption, pollShardOref, stakingPositionOref, sysParams, l
     BigInt(validityFrom),
     indyStakedAmt
   );
-  return lucid.newTx().validFrom(validityFrom).validTo(Number(pollShardDatum.votingEndTime) - ONE_SECOND).readFrom([stakingRefScriptUtxo, pollShardRefScriptUtxo]).collectFrom([stakingPosUtxo], serialiseStakingRedeemer("Lock")).collectFrom(
+  return lucid.newTx().validFrom(validityFrom).validTo(
+    Math.min(
+      Number(pollShardDatum.votingEndTime) - ONE_SECOND,
+      Number(currentTime) + Number(sysParams.govParams.gBiasTime) - ONE_SECOND
+    )
+  ).readFrom([stakingRefScriptUtxo, pollShardRefScriptUtxo]).collectFrom([stakingPosUtxo], serialiseStakingRedeemer("Lock")).collectFrom(
     [pollShardUtxo],
     serialisePollShardRedeemer({ Vote: { content: voteOption } })
   ).pay.ToContract(
@@ -5211,6 +5216,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,
@@ -5260,19 +5266,36 @@ function parseLrpDatumOrThrow(datum) {
     }, F9.identity)
   );
 }
-function serialiseLrpDatum(datum) {
+function serialiseLrpDatum(datum, serialisationOptions = { _tag: "noReplace" }) {
   const d = Data26.to(datum, LRPDatum);
-  const ocdSerialisedCanonical = Data26.to(
-    datum.maxPrice,
-    OnChainDecimal,
-    { canonical: true }
-  );
-  const ocdSerialisedNonCanonical = Data26.to(
-    datum.maxPrice,
-    OnChainDecimal,
-    { canonical: false }
-  );
-  return d.replace(ocdSerialisedNonCanonical, ocdSerialisedCanonical);
+  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);
@@ -5315,7 +5338,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];
@@ -5332,8 +5355,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
@@ -5357,7 +5380,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),
@@ -5392,10 +5416,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.33",
+  "version": "0.2.35",
   "description": "Indigo SDK for interacting with Indigo endpoints via lucid-evolution",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/contracts/gov/transactions.ts

@@ -465,7 +465,14 @@ export async function vote(
   return lucid
     .newTx()
     .validFrom(validityFrom)
-    .validTo(Number(pollShardDatum.votingEndTime) - ONE_SECOND)
+    .validTo(
+      Math.min(
+        Number(pollShardDatum.votingEndTime) - ONE_SECOND,
+        Number(currentTime) +
+          Number(sysParams.govParams.gBiasTime) -
+          ONE_SECOND,
+      ),
+    )
     .readFrom([stakingRefScriptUtxo, pollShardRefScriptUtxo])
     .collectFrom([stakingPosUtxo], serialiseStakingRedeemer('Lock'))
     .collectFrom(

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

@@ -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 {

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,