@indigo-labs/indigo-sdk 0.2.41 → 0.3.0

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

@@ -1,21 +1,31 @@
-import { Core as EvoCore } from '@evolution-sdk/evolution';
+import { TSchema, Data } from '@evolution-sdk/evolution';
 import { match, P } from 'ts-pattern';
-import { AddressSchema } from '@3rd-eye-labs/cardano-offchain-common';
+import { option as O, function as F } from 'fp-ts';
+
 import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
+import {
+  AddressSchema,
+  AssetClassSchema,
+  OutputReferenceSchema,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import {
+  divideOnChainCompatible,
+  zeroNegatives,
+} from '../../utils/bigint-utils';
 
-export const SPIntegerSchema = EvoCore.TSchema.Struct({
-  value: EvoCore.TSchema.Integer,
+export const SPIntegerSchema = TSchema.Struct({
+  value: TSchema.Integer,
 });
 
 export type SPInteger = typeof SPIntegerSchema.Type;
 
-const AccountActionSchema = EvoCore.TSchema.Union(
-  EvoCore.TSchema.Literal('Create', { flatInUnion: true }),
-  EvoCore.TSchema.Struct(
+const AccountActionSchema = TSchema.Union(
+  TSchema.Literal('Create', { flatInUnion: true }),
+  TSchema.Struct(
     {
-      Adjust: EvoCore.TSchema.Struct(
+      Adjust: TSchema.Struct(
         {
-          amount: EvoCore.TSchema.Integer,
+          amount: TSchema.Integer,
           outputAddress: AddressSchema,
         },
         { flatFields: true },
@@ -23,10 +33,10 @@ const AccountActionSchema = EvoCore.TSchema.Union(
     },
     { flatInUnion: true },
   ),
-  EvoCore.TSchema.Struct(
+  TSchema.Struct(
     {
-      Close: EvoCore.TSchema.Struct(
-        { outputAddress: AddressSchema },
+      Close: TSchema.Struct(
+        { outputAddress: AddressSchema, maxTxFee: TSchema.Integer },
         { flatFields: true },
       ),
     },
@@ -36,97 +46,184 @@ const AccountActionSchema = EvoCore.TSchema.Union(
 
 export type AccountAction = typeof AccountActionSchema.Type;
 
-export const EpochToScaleToSumSchema = EvoCore.TSchema.Map(
-  EvoCore.TSchema.Struct({
-    epoch: EvoCore.TSchema.Integer,
-    scale: EvoCore.TSchema.Integer,
-  }),
-  SPIntegerSchema,
-);
+const SumSnapshotSchema = TSchema.Struct({
+  sumVal: SPIntegerSchema,
+  isLastInEpoch: TSchema.Boolean,
+  isFirstSnapshot: TSchema.Boolean,
+});
+
+export type SumSnapshot = typeof SumSnapshotSchema.Type;
+
+const EpochToScaleKeySchema = TSchema.Struct({
+  epoch: TSchema.Integer,
+  scale: TSchema.Integer,
+});
+
+export type EpochToScaleKey = typeof EpochToScaleKeySchema.Type;
+
+const EpochToScaleToSumEntrySchema = TSchema.Tuple([
+  EpochToScaleKeySchema,
+  SumSnapshotSchema,
+]);
 
-export type EpochToScaleToSum = typeof EpochToScaleToSumSchema.Type;
+export type EpochToScaleToSumEntry = typeof EpochToScaleToSumEntrySchema.Type;
 
-const StabilityPoolSnapshotSchema = EvoCore.TSchema.Struct({
+const StateSnapshotSchema = TSchema.Struct({
   productVal: SPIntegerSchema,
   depositVal: SPIntegerSchema,
-  sumVal: SPIntegerSchema,
-  epoch: EvoCore.TSchema.Integer,
-  scale: EvoCore.TSchema.Integer,
+  epoch: TSchema.Integer,
+  scale: TSchema.Integer,
+});
+export type StateSnapshot = typeof StateSnapshotSchema.Type;
+
+const AssetSnapshotSchema = TSchema.Struct({
+  currentSumVal: SPIntegerSchema,
+  epoch2scale2sum: TSchema.Array(EpochToScaleToSumEntrySchema),
 });
+export type AssetSnapshot = typeof AssetSnapshotSchema.Type;
 
-export type StabilityPoolSnapshot = typeof StabilityPoolSnapshotSchema.Type;
+const AssetStateSchema = TSchema.Tuple([AssetClassSchema, AssetSnapshotSchema]);
+export type AssetState = typeof AssetStateSchema.Type;
 
-export const StabilityPoolContentSchema = EvoCore.TSchema.Struct({
-  asset: EvoCore.TSchema.ByteArray,
-  poolSnapshot: StabilityPoolSnapshotSchema,
-  epochToScaleToSum: EpochToScaleToSumSchema,
+export const StabilityPoolContentSchema = TSchema.Struct({
+  iasset: TSchema.ByteArray,
+  state: StateSnapshotSchema,
+  assetStates: TSchema.Array(AssetStateSchema),
 });
 
 export type StabilityPoolContent = typeof StabilityPoolContentSchema.Type;
 
-export const AccountContentSchema = EvoCore.TSchema.Struct({
-  owner: EvoCore.TSchema.ByteArray,
-  asset: EvoCore.TSchema.ByteArray,
-  accountSnapshot: StabilityPoolSnapshotSchema,
-  request: EvoCore.TSchema.NullOr(AccountActionSchema),
+export const AccountContentSchema = TSchema.Struct({
+  owner: TSchema.ByteArray,
+  iasset: TSchema.ByteArray,
+  state: StateSnapshotSchema,
+  assetSums: TSchema.Array(TSchema.Tuple([AssetClassSchema, SPIntegerSchema])),
+  request: TSchema.NullOr(AccountActionSchema),
+  lastRequestProcessingTime: TSchema.Integer,
 });
 
 export type AccountContent = typeof AccountContentSchema.Type;
 
-export const SnapshotEpochToScaleToSumContentSchema = EvoCore.TSchema.Struct({
-  snapshot: EpochToScaleToSumSchema,
-  asset: EvoCore.TSchema.ByteArray,
+export const SnapshotEpochToScaleToSumContentSchema = TSchema.Struct({
+  snapshot: TSchema.Array(EpochToScaleToSumEntrySchema),
+  iasset: TSchema.ByteArray,
+  collateralAsset: AssetClassSchema,
 });
 
 export type SnapshotEpochToScaleToSumContent =
   typeof SnapshotEpochToScaleToSumContentSchema.Type;
 
-export const StabilityPoolDatumSchema = EvoCore.TSchema.Union(
-  EvoCore.TSchema.Struct(
+export const StabilityPoolDatumSchema = TSchema.Union(
+  TSchema.Struct(
     { StabilityPool: StabilityPoolContentSchema },
     { flatInUnion: true },
   ),
-  EvoCore.TSchema.Struct(
-    { Account: AccountContentSchema },
+  TSchema.Struct({ Account: AccountContentSchema }, { flatInUnion: true }),
+  TSchema.Struct(
+    { SnapshotEpochToScaleToSum: SnapshotEpochToScaleToSumContentSchema },
     { flatInUnion: true },
   ),
-  EvoCore.TSchema.Struct(
-    { SnapshotEpochToScaleToSum: SnapshotEpochToScaleToSumContentSchema },
+);
+
+const E2S2SIndexSchema = TSchema.Union(
+  TSchema.Struct(
+    { StabilityPoolListIdx: TSchema.Integer },
     { flatInUnion: true },
   ),
+  TSchema.Struct(
+    {
+      RefInputIdx: TSchema.Struct(
+        {
+          refInputIdx: TSchema.Integer,
+          snapshotListIdx: TSchema.Integer,
+        },
+        { flatFields: true },
+      ),
+    },
+    { flatInUnion: true },
+  ),
+);
+
+export type E2S2SIndex = typeof E2S2SIndexSchema.Type;
+
+const E2S2SIndicesPerAssetSchema = TSchema.Array(
+  TSchema.Tuple([E2S2SIndexSchema, TSchema.NullOr(E2S2SIndexSchema)]),
+);
+
+export type E2S2SIndicesPerAsset = typeof E2S2SIndicesPerAssetSchema.Type;
+
+const ProcessRequestAccountContentSchema = TSchema.Struct(
+  {
+    poolInputIdx: TSchema.Integer,
+    accountInputIdx: TSchema.Integer,
+    e2s2sIdxs: E2S2SIndicesPerAssetSchema,
+    currentTime: TSchema.Integer,
+  },
+  { flatFields: true },
 );
 
-export const StabilityPoolRedeemerSchema = EvoCore.TSchema.Union(
-  EvoCore.TSchema.Struct(
-    { RequestAction: AccountActionSchema },
+export type ProcessRequestAccountContent =
+  typeof ProcessRequestAccountContentSchema.Type;
+
+export const StabilityPoolRedeemerSchema = TSchema.Union(
+  TSchema.Struct({ RequestAction: AccountActionSchema }, { flatInUnion: true }),
+  TSchema.Struct(
+    {
+      ProcessRequestPool: TSchema.Struct(
+        {
+          poolInputIdx: TSchema.Integer,
+          accountInputIdx: TSchema.Integer,
+        },
+        { flatFields: true },
+      ),
+    },
     { flatInUnion: true },
   ),
-  EvoCore.TSchema.Struct(
+  TSchema.Struct(
     {
-      ProcessRequest: EvoCore.TSchema.Struct({
-        txHash: EvoCore.TSchema.Struct({ hash: EvoCore.TSchema.ByteArray }),
-        outputIndex: EvoCore.TSchema.Integer,
-      }),
+      ProcessRequestAccount: ProcessRequestAccountContentSchema,
     },
     { flatInUnion: true },
   ),
-  EvoCore.TSchema.Literal('AnnulRequest', { flatInUnion: true }),
-  EvoCore.TSchema.Literal('LiquidateCDP', { flatInUnion: true }),
-  EvoCore.TSchema.Literal('RecordEpochToScaleToSum', { flatInUnion: true }),
-  EvoCore.TSchema.Literal('UpgradeVersion', { flatInUnion: true }),
+  TSchema.Literal('AnnulRequest', { flatInUnion: true }),
+  TSchema.Literal('LiquidateCDP', { flatInUnion: true }),
+  TSchema.Literal('RecordEpochToScaleToSum', { flatInUnion: true }),
+  TSchema.Literal('UpgradeVersion', { flatInUnion: true }),
 );
 
 export type StabilityPoolRedeemer = typeof StabilityPoolRedeemerSchema.Type;
 
+const ActionReturnDatumSchema = TSchema.Union(
+  TSchema.Struct(
+    {
+      IndigoStabilityPoolAccountAdjustment: OutputReferenceSchema,
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Struct(
+    {
+      IndigoStabilityPoolAccountClosure: OutputReferenceSchema,
+    },
+    { flatInUnion: true },
+  ),
+);
+
+export type ActionReturnDatum = typeof ActionReturnDatumSchema.Type;
+
+export function serialiseActionReturnDatum(d: ActionReturnDatum): string {
+  return Data.withSchema(
+    ActionReturnDatumSchema,
+    DEFAULT_SCHEMA_OPTIONS,
+  ).toCBORHex(d);
+}
+
 export function serialiseStabilityPoolRedeemer(
   r: StabilityPoolRedeemer,
 ): string {
-  const rdmr = EvoCore.Data.withSchema(
+  return Data.withSchema(
     StabilityPoolRedeemerSchema,
     DEFAULT_SCHEMA_OPTIONS,
   ).toCBORHex(r);
-
-  return rdmr;
 }
 
 export function serialiseStabilityPoolDatum(
@@ -136,63 +233,99 @@ export function serialiseStabilityPoolDatum(
    */
   useIndefiniteMaps: boolean = false,
 ): string {
-  const datum = EvoCore.Data.withSchema(StabilityPoolDatumSchema, {
+  return Data.withSchema(StabilityPoolDatumSchema, {
     ...DEFAULT_SCHEMA_OPTIONS,
     useIndefiniteMaps: useIndefiniteMaps,
   }).toCBORHex(d);
+}
+
+export function parseStabilityPoolDatum(
+  datum: string,
+): O.Option<StabilityPoolContent> {
+  try {
+    return match(
+      Data.withSchema(
+        StabilityPoolDatumSchema,
+        DEFAULT_SCHEMA_OPTIONS,
+      ).fromCBORHex(datum),
+    )
+      .with({ StabilityPool: P.select() }, (res) => O.some(res))
+      .otherwise(() => O.none);
+  } catch (_) {
+    return O.none;
+  }
+}
+export function parseStabilityPoolDatumOrThrow(
+  datum: string,
+): StabilityPoolContent {
+  return F.pipe(
+    parseStabilityPoolDatum(datum),
+    O.match(() => {
+      throw new Error('Expected stability pool datum.');
+    }, F.identity),
+  );
+}
 
-  return datum;
-}
-
-export function parseStabilityPoolDatum(datum: string): StabilityPoolContent {
-  return match(
-    EvoCore.Data.withSchema(
-      StabilityPoolDatumSchema,
-      DEFAULT_SCHEMA_OPTIONS,
-    ).fromCBORHex(datum),
-  )
-    .with({ StabilityPool: P.select() }, (res) => res)
-    .otherwise(() => {
-      throw new Error('Expected a Stability Pool datum.');
-    });
-}
-
-export function parseAccountDatum(datum: string): AccountContent {
-  return match(
-    EvoCore.Data.withSchema(
-      StabilityPoolDatumSchema,
-      DEFAULT_SCHEMA_OPTIONS,
-    ).fromCBORHex(datum),
-  )
-    .with({ Account: P.select() }, (res) => res)
-    .otherwise(() => {
-      throw new Error('Expected a Stability Pool datum.');
-    });
+export function parseAccountDatum(datum: string): O.Option<AccountContent> {
+  try {
+    return match(
+      Data.withSchema(
+        StabilityPoolDatumSchema,
+        DEFAULT_SCHEMA_OPTIONS,
+      ).fromCBORHex(datum),
+    )
+      .with({ Account: P.select() }, (res) => O.some(res))
+      .otherwise(() => O.none);
+  } catch (_) {
+    return O.none;
+  }
+}
+export function parseAccountDatumOrThrow(datum: string): AccountContent {
+  return F.pipe(
+    parseAccountDatum(datum),
+    O.match(() => {
+      throw new Error('Expected account datum.');
+    }, F.identity),
+  );
 }
+
 export function parseSnapshotEpochToScaleToSumDatum(
   datum: string,
+): O.Option<SnapshotEpochToScaleToSumContent> {
+  try {
+    return match(
+      Data.withSchema(
+        StabilityPoolDatumSchema,
+        DEFAULT_SCHEMA_OPTIONS,
+      ).fromCBORHex(datum),
+    )
+      .with({ SnapshotEpochToScaleToSum: P.select() }, (res) => O.some(res))
+      .otherwise(() => O.none);
+  } catch (_) {
+    return O.none;
+  }
+}
+
+export function parseSnapshotEpochToScaleToSumDatumOrThrow(
+  datum: string,
 ): SnapshotEpochToScaleToSumContent {
-  return match(
-    EvoCore.Data.withSchema(
-      StabilityPoolDatumSchema,
-      DEFAULT_SCHEMA_OPTIONS,
-    ).fromCBORHex(datum),
-  )
-    .with({ SnapshotEpochToScaleToSum: P.select() }, (res) => res)
-    .otherwise(() => {
-      throw new Error('Expected a Stability Pool datum.');
-    });
+  return F.pipe(
+    parseSnapshotEpochToScaleToSumDatum(datum),
+    O.match(() => {
+      throw new Error('Expected snapshot e2s2s datum.');
+    }, F.identity),
+  );
 }
 
 /** SP Integer */
-const spPrecision: bigint = 1000000000000000000n;
+const spPrecision: bigint = 1_000_000_000_000_000_000n;
 
 export function mkSPInteger(value: bigint): SPInteger {
   return { value: value * spPrecision };
 }
 
 export function fromSPInteger(value: SPInteger): bigint {
-  return value.value / spPrecision;
+  return divideOnChainCompatible(value.value, spPrecision);
 }
 
 export function spAdd(a: SPInteger, b: SPInteger): SPInteger {
@@ -204,9 +337,13 @@ export function spSub(a: SPInteger, b: SPInteger): SPInteger {
 }
 
 export function spMul(a: SPInteger, b: SPInteger): SPInteger {
-  return { value: (a.value * b.value) / spPrecision };
+  return { value: divideOnChainCompatible(a.value * b.value, spPrecision) };
 }
 
 export function spDiv(a: SPInteger, b: SPInteger): SPInteger {
-  return { value: (a.value * spPrecision) / b.value };
+  return { value: divideOnChainCompatible(a.value * spPrecision, b.value) };
+}
+
+export function spZeroNegatives(a: SPInteger): SPInteger {
+  return { value: zeroNegatives(a.value) };
 }

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

@@ -1,22 +1,5 @@
 import { Data } from '@lucid-evolution/lucid';
-import { AssetClassSchema, OutputReferenceSchema } from '../../types/generic';
-
-export const ActionReturnDatumSchema = Data.Enum([
-  Data.Object({
-    IndigoStabilityPoolAccountAdjustment: Data.Object({
-      spent_account: OutputReferenceSchema,
-    }),
-  }),
-  Data.Object({
-    IndigoStabilityPoolAccountClosure: Data.Object({
-      closed_account: OutputReferenceSchema,
-    }),
-  }),
-]);
-
-export type ActionReturnDatum = Data.Static<typeof ActionReturnDatumSchema>;
-export const ActionReturnDatum =
-  ActionReturnDatumSchema as unknown as ActionReturnDatum;
+import { AssetClassSchema, StakeCredentialSchema } from '../../types/generic';
 
 /** SP Parameters */
 const StabilityPoolParamsSchema = Data.Object({
@@ -27,11 +10,11 @@ const StabilityPoolParamsSchema = Data.Object({
   cdpToken: AssetClassSchema,
   iAssetAuthToken: AssetClassSchema,
   versionRecordToken: AssetClassSchema,
-  collectorValHash: Data.Bytes(),
-  govNFT: AssetClassSchema,
+  iassetValHash: Data.Bytes(),
   accountCreateFeeLovelaces: Data.Integer(),
-  accountAdjustmentFeeLovelaces: Data.Integer(),
-  requestCollateralLovelaces: Data.Integer(),
+  accountProcessingCooldownMs: Data.Integer(),
+  accountProcessingBiasMs: Data.Integer(),
+  stakeCredential: Data.Nullable(StakeCredentialSchema),
 });
 export type StabilityPoolParams = Data.Static<typeof StabilityPoolParamsSchema>;
 export const StabilityPoolParams =

package/src/contracts/stableswap/helpers.ts

@@ -0,0 +1,22 @@
+import { fromHex, fromText, OutRef } from '@lucid-evolution/lucid';
+import { serialiseStableswapOutputDatum } from './types-new';
+import { Data } from '@evolution-sdk/evolution';
+
+export const BASE_MAX_EXECUTION_FEE = 1_000_000n;
+
+export function createDestinationDatum(
+  datum: Data.Data | null,
+  outRef: OutRef,
+): string {
+  if (!datum) {
+    return serialiseStableswapOutputDatum([
+      fromHex(fromText('IndigoStableswap')),
+      {
+        txHash: fromHex(outRef.txHash),
+        outputIndex: BigInt(outRef.outputIndex),
+      },
+    ]);
+  }
+
+  return Data.toCBORHex(datum);
+}

package/src/contracts/stableswap/scripts.ts

@@ -0,0 +1,37 @@
+import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
+import { castStableswapParams, StableswapParams } from './types';
+import {
+  fromSystemParamsAssetLucid,
+  StableswapParamsSP,
+} from '../../types/system-params';
+import { _stableswapValidator } from '../../validators/stableswap-validator';
+
+export const mkStableswapValidator = (
+  params: StableswapParams,
+): SpendingValidator => {
+  return {
+    type: 'PlutusV3',
+    script: applyParamsToScript(_stableswapValidator.cborHex, [
+      castStableswapParams(params),
+    ]),
+  };
+};
+
+export const mkStableswapValidatorFromSP = (
+  params: StableswapParamsSP,
+): SpendingValidator => {
+  return {
+    type: 'PlutusV3',
+    script: applyParamsToScript(_stableswapValidator.cborHex, [
+      castStableswapParams({
+        iassetSymbol: params.iassetSymbol.unCurrencySymbol,
+        cdpToken: fromSystemParamsAssetLucid(params.cdpToken),
+        versionRecordToken: fromSystemParamsAssetLucid(
+          params.versionRecordToken,
+        ),
+        cdpValHash: params.cdpValHash,
+        treasuryValHash: params.treasuryValHash,
+      }),
+    ]),
+  };
+};