Cody/leverage canonical

package.json

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

src/contracts/cdp-creator/types.ts

@@ -40,7 +40,9 @@ export const CDPCreatorRedeemer =
 export function serialiseCDPCreatorRedeemer(
   params: CDPCreatorRedeemer,
 ): Redeemer {
-  return Data.to<CDPCreatorRedeemer>(params, CDPCreatorRedeemer);
+  return Data.to<CDPCreatorRedeemer>(params, CDPCreatorRedeemer, {
+    canonical: true,
+  });
 }
 
 export function serialiseCDPCreatorDatum(): Datum {

src/contracts/cdp/types.ts

@@ -109,7 +109,7 @@ export type CDPRedeemer = Data.Static<typeof CDPRedeemerSchema>;
 const CDPRedeemer = CDPRedeemerSchema as unknown as CDPRedeemer;
 
 export function serialiseCdpRedeemer(r: CDPRedeemer): Redeemer {
-  return Data.to<CDPRedeemer>(r, CDPRedeemer);
+  return Data.to<CDPRedeemer>(r, CDPRedeemer, { canonical: true });
 }
 
 export function parseCdpDatum(datum: Datum): O.Option<CDPContent> {

src/contracts/collector/types.ts

@@ -12,5 +12,7 @@ const CollectorRedeemer =
 export function serialiseCollectorRedeemer(
   redeemer: CollectorRedeemer,
 ): Redeemer {
-  return Data.to<CollectorRedeemer>(redeemer, CollectorRedeemer);
+  return Data.to<CollectorRedeemer>(redeemer, CollectorRedeemer, {
+    canonical: true,
+  });
 }

src/contracts/leverage/helpers.ts

@@ -66,7 +66,7 @@ import {
   calculateTotalAdaForRedemption,
   lrpRedeemableLovelacesInclReimb,
 } from '../lrp/helpers';
-import { LRPDatum } from '../lrp/types';
+import { LRPDatum } from '../lrp/types-new';
 
 /**
  * How many LRP redemptions can we fit into a TX with CDP open.

src/contracts/leverage/transactions.ts

@@ -34,7 +34,7 @@ import {
   calculateLeverageFromCollateralRatio,
   MAX_REDEMPTIONS_WITH_CDP_OPEN,
 } from './helpers';
-import { LRPDatum } from '../lrp/types';
+import { LRPDatum } from '../lrp/types-new';
 import {
   buildRedemptionsTx,
   randomLrpsSubsetSatisfyingTargetLovelaces,

src/contracts/lrp/helpers.ts

@@ -1,10 +1,11 @@
-import { addAssets, TxBuilder, UTxO } from '@lucid-evolution/lucid';
 import {
-  LRPDatum,
-  parseLrpDatumOrThrow,
-  serialiseLrpDatum,
-  serialiseLrpRedeemer,
-} from './types';
+  addAssets,
+  fromHex,
+  toHex,
+  TxBuilder,
+  UTxO,
+} from '@lucid-evolution/lucid';
+import { LRPDatum, parseLrpDatumOrThrow, serialiseLrpDatum } from './types-new';
 import { ocdMul, OnChainDecimal } from '../../types/on-chain-decimal';
 import {
   lovelacesAmt,
@@ -18,6 +19,7 @@ import { insertSorted, shuffle } from '../../utils/array-utils';
 import { LrpParamsSP, SystemParams } from '../../types/system-params';
 import { match, P } from 'ts-pattern';
 import { getInlineDatumOrThrow } from '../../utils/lucid-utils';
+import { serialiseLrpRedeemer } from './types-new';
 
 export const MIN_LRP_COLLATERAL_AMT = 2_000_000n;
 
@@ -102,7 +104,7 @@ export function buildRedemptionsTx(
             {
               currencySymbol:
                 sysParams.lrpParams.iassetPolicyId.unCurrencySymbol,
-              tokenName: mainLrpDatum.iasset,
+              tokenName: toHex(mainLrpDatum.iasset),
             },
             redeemIAssetAmt,
           ),
@@ -122,7 +124,7 @@ export function buildRedemptionsTx(
                     RedeemAuxiliary: {
                       continuingOutputIdx: txOutputsBeforeCount + BigInt(idx),
                       mainRedeemOutRef: {
-                        txHash: { hash: mainLrpUtxo.txHash },
+                        txHash: { hash: fromHex(mainLrpUtxo.txHash) },
                         outputIndex: BigInt(mainLrpUtxo.outputIndex),
                       },
                       asset: mainLrpDatum.iasset,
@@ -168,7 +170,7 @@ export function calculateTotalAdaForRedemption(
     allLrps,
     A.filterMap(([utxo, datum]) => {
       if (
-        datum.iasset !== iasset ||
+        toHex(datum.iasset) !== iasset ||
         datum.maxPrice.getOnChainInt < iassetPrice.getOnChainInt
       ) {
         return O.none;
@@ -216,7 +218,7 @@ export function randomLrpsSubsetSatisfyingTargetLovelaces(
       allLrps,
       A.filter(
         ([_, datum]) =>
-          datum.iasset === iasset &&
+          toHex(datum.iasset) === iasset &&
           datum.maxPrice.getOnChainInt >= iassetPrice.getOnChainInt,
       ),
     ),

src/contracts/lrp/transactions.ts

@@ -6,19 +6,18 @@
   addAssets,
   unixTimeToSlot,
   slotToUnixTime,
+  fromHex,
+  fromText,
+  toHex,
+  toText,
 } from '@lucid-evolution/lucid';
 import {
   addrDetails,
   createScriptAddress,
   getInlineDatumOrThrow,
 } from '../../utils/lucid-utils';
 import { unzip, zip } from 'fp-ts/lib/Array';
-import {
-  LRPDatum,
-  parseLrpDatumOrThrow,
-  serialiseLrpDatum,
-  serialiseLrpRedeemer,
-} from './types';
+import { LRPDatum, parseLrpDatumOrThrow, serialiseLrpDatum } from './types-new';
 import { parsePriceOracleDatum } from '../price-oracle/types';
 import { OnChainDecimal } from '../../types/on-chain-decimal';
 import { parseIAssetDatumOrThrow } from '../cdp/types';
@@ -34,6 +33,7 @@
   SystemParams,
 } from '../../types/system-params';
 import { buildRedemptionsTx, MIN_LRP_COLLATERAL_AMT } from './helpers';
+import { serialiseLrpRedeemer } from './types-new';
 
 export async function openLrp(
   assetTokenName: string,
@@ -48,8 +48,8 @@
   const [ownPkh, _] = await addrDetails(lucid);
 
   const newDatum: LRPDatum = {
-    owner: ownPkh.hash,
-    iasset: assetTokenName,
+    owner: fromHex(ownPkh.hash),
+    iasset: fromHex(assetTokenName),
     maxPrice: maxPrice,
     lovelacesToSpend: lovelacesAmt,
   };
@@ -91,7 +91,7 @@
     .newTx()
     .readFrom([lrpScriptRefUtxo])
     .collectFrom([lrpUtxo], serialiseLrpRedeemer('Cancel'))
-    .addSignerKey(lrpDatum.owner);
+    .addSignerKey(toHex(lrpDatum.owner));
 }
 
 export async function redeemLrp(
@@ -192,7 +192,7 @@
 
   const rewardAssetClass: AssetClass = {
     currencySymbol: sysParams.lrpParams.iassetPolicyId.unCurrencySymbol,
-    tokenName: lrpDatum.iasset,
+    tokenName: toHex(lrpDatum.iasset),
   };
   const rewardAssetsAmt = assetClassValueOf(lrpUtxo.assets, rewardAssetClass);
 
@@ -237,7 +237,7 @@
         mkLovelacesOf(lovelacesAdjustAmt),
       ),
     )
-    .addSignerKey(lrpDatum.owner);
+    .addSignerKey(toHex(lrpDatum.owner));
 }
 
 /**

src/contracts/lrp/types-new.ts

@@ -0,0 +1,100 @@
+import { Core } from '@evolution-sdk/evolution';
+import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
+import { option as O, function as F } from 'fp-ts';
+import { AIKEN_DEFAULT_OPTIONS } from '@evolution-sdk/evolution/core/CBOR';
+
+const TSchema = Core.TSchema;
+
+const LRPDatumSchema = TSchema.Struct({
+  owner: TSchema.ByteArray,
+  iasset: TSchema.ByteArray,
+  maxPrice: Core.TSchema.Struct({
+    getOnChainInt: Core.TSchema.Integer,
+  }),
+  /**
+   * The amount of lovelaces that is available to be spent.
+   * This doesn't correspond to the lovelaces in UTXO's value,
+   * since that can contain fees, too.
+   */
+  lovelacesToSpend: TSchema.Integer,
+});
+
+export type LRPDatum = typeof LRPDatumSchema.Type;
+
+const LRPRedeemerSchema = TSchema.Union(
+  TSchema.Struct(
+    {
+      Redeem: TSchema.Struct(
+        { continuingOutputIdx: TSchema.Integer },
+        { flatFields: true },
+      ),
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Struct(
+    {
+      RedeemAuxiliary: TSchema.Struct(
+        {
+          continuingOutputIdx: TSchema.Integer,
+          mainRedeemOutRef: TSchema.Struct({
+            txHash: TSchema.Struct({ hash: TSchema.ByteArray }),
+            outputIndex: TSchema.Integer,
+          }),
+          asset: TSchema.ByteArray,
+          assetPrice: Core.TSchema.Struct({
+            getOnChainInt: Core.TSchema.Integer,
+          }),
+          redemptionReimbursementPercentage: Core.TSchema.Struct({
+            getOnChainInt: Core.TSchema.Integer,
+          }),
+        },
+        { flatFields: true },
+      ),
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Literal('Cancel', { flatInUnion: true }),
+  TSchema.Literal('UpgradeVersion', { flatInUnion: true }),
+);
+
+export type LRPRedeemer = typeof LRPRedeemerSchema.Type;
+
+export function parseLrpDatum(datum: string): O.Option<LRPDatum> {
+  try {
+    return O.some(
+      Core.Data.withSchema(LRPDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+        datum,
+      ),
+    );
+  } catch (_) {
+    return O.none;
+  }
+}
+
+export function parseLrpDatumOrThrow(datum: string): LRPDatum {
+  return F.pipe(
+    parseLrpDatum(datum),
+    O.match(() => {
+      throw new Error('Expected an LRP datum.');
+    }, F.identity),
+  );
+}
+
+export function serialiseLrpDatum(d: LRPDatum): string {
+  let datum = Core.Data.withSchema(LRPDatumSchema, {
+    mode: 'canonical',
+  }).toCBORHex(d);
+
+  datum = datum.replace('d87984', 'd8799f');
+  datum = datum + 'ff';
+
+  return datum;
+}
+
+export function serialiseLrpRedeemer(r: LRPRedeemer): string {
+  const redeemer = Core.Data.withSchema(LRPRedeemerSchema, {
+    mode: 'canonical',
+  }).toCBORHex(r);
+
+  return redeemer;
+}

src/contracts/lrp/types.ts

@@ -1,5 +1,5 @@
-import { Data, Datum, Redeemer, UTxO } from '@lucid-evolution/lucid';
-import { AssetClassSchema, OutputReferenceSchema } from '../../types/generic';
+import { Data, Datum, UTxO } from '@lucid-evolution/lucid';
+import { AssetClassSchema } from '../../types/generic';
 import { OnChainDecimalSchema } from '../../types/on-chain-decimal';
 import { option as O, function as F } from 'fp-ts';
 
@@ -12,64 +12,6 @@
 export type LRPParams = Data.Static<typeof LRPParamsSchema>;
 const LRPParams = LRPParamsSchema as unknown as LRPParams;
 
-export const LRPDatumSchema = Data.Object({
-  owner: Data.Bytes(),
-  iasset: Data.Bytes(),
-  maxPrice: OnChainDecimalSchema,
-  /**
-   * The amount of lovelaces that is available to be spent.
-   * This doesn't correspond to the lovelaces in UTXO's value,
-   * since that can contain fees, too.
-   */
-  lovelacesToSpend: Data.Integer(),
-});
-export type LRPDatum = Data.Static<typeof LRPDatumSchema>;
-const LRPDatum = LRPDatumSchema as unknown as LRPDatum;
-
-export const LRPRedeemerSchema = Data.Enum([
-  Data.Object({ Redeem: Data.Object({ continuingOutputIdx: Data.Integer() }) }),
-  Data.Object({
-    RedeemAuxiliary: Data.Object({
-      continuingOutputIdx: Data.Integer(),
-      mainRedeemOutRef: OutputReferenceSchema,
-      asset: Data.Bytes(),
-      assetPrice: OnChainDecimalSchema,
-      redemptionReimbursementPercentage: OnChainDecimalSchema,
-    }),
-  }),
-  Data.Literal('Cancel'),
-  Data.Literal('UpgradeVersion'),
-]);
-export type LRPRedeemer = Data.Static<typeof LRPRedeemerSchema>;
-const LRPRedeemer = LRPRedeemerSchema as unknown as LRPRedeemer;
-
-export function parseLrpDatum(datum: Datum): O.Option<LRPDatum> {
-  try {
-    return O.some(Data.from<LRPDatum>(datum, LRPDatum));
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parseLrpDatumOrThrow(datum: Datum): LRPDatum {
-  return F.pipe(
-    parseLrpDatum(datum),
-    O.match(() => {
-      throw new Error('Expected an LRP datum.');
-    }, F.identity),
-  );
-}
-
-export function serialiseLrpDatum(datum: LRPDatum): Datum {
-  return Data.to<LRPDatum>(datum, LRPDatum);
-}
-
-export function serialiseLrpRedeemer(redeemer: LRPRedeemer): Redeemer {
-  return Data.to<LRPRedeemer>(redeemer, LRPRedeemer);
-}
-
 export function castLrpParams(params: LRPParams): Data {
   return Data.castTo(params, LRPParams);
 }
-
-export type LrpOutput = { datum: LRPDatum; utxo: UTxO };

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

@@ -1,7 +1,10 @@
 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 {
+  DEFAULT_SCHEMA_OPTIONS,
+  STABILITY_POOL_SCHEMA_OPTIONS,
+} from '../../types/evolution-schema-options';
 
 export const SPIntegerSchema = EvoCore.TSchema.Struct({
   value: EvoCore.TSchema.Integer,
@@ -123,7 +126,7 @@ export function serialiseStabilityPoolRedeemer(
 ): string {
   return EvoCore.Data.withSchema(
     StabilityPoolRedeemerSchema,
-    DEFAULT_SCHEMA_OPTIONS,
+    STABILITY_POOL_SCHEMA_OPTIONS,
   ).toCBORHex(r);
 }
 
@@ -135,7 +138,7 @@ export function serialiseStabilityPoolDatum(
   useIndefiniteMaps: boolean = false,
 ): string {
   return EvoCore.Data.withSchema(StabilityPoolDatumSchema, {
-    ...DEFAULT_SCHEMA_OPTIONS,
+    ...STABILITY_POOL_SCHEMA_OPTIONS,
     useIndefiniteMaps: useIndefiniteMaps,
   }).toCBORHex(d);
 }