@indigo-labs/indigo-sdk 0.2.42 → 0.3.1

package/src/contracts/iasset/types.ts

@@ -0,0 +1,154 @@
+import { TSchema, Data } from '@evolution-sdk/evolution';
+import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
+import { option as O, function as F } from 'fp-ts';
+import { AssetClassSchema } from '@3rd-eye-labs/cardano-offchain-common';
+import { match, P } from 'ts-pattern';
+import { ParsedOutput } from '../../types/generic';
+import { RationalSchema } from '../../types/rational';
+
+export const IAssetPriceInfoSchema = TSchema.Union(
+  TSchema.Struct(
+    {
+      Delisted: TSchema.Struct({ price: RationalSchema }, { flatFields: true }),
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Struct(
+    {
+      OracleNft: AssetClassSchema,
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Struct(
+    {
+      DeferredValidation: TSchema.Struct(
+        { feedValHash: TSchema.ByteArray },
+        { flatFields: true },
+      ),
+    },
+    { flatInUnion: true },
+  ),
+);
+
+export type IAssetPriceInfo = typeof IAssetPriceInfoSchema.Type;
+
+const IAssetContentSchema = TSchema.Struct({
+  assetName: TSchema.ByteArray,
+  collateralAssetsCount: TSchema.Integer,
+  debtMintingFeeRatio: RationalSchema,
+  liquidationProcessingFeeRatio: RationalSchema,
+  stabilityPoolWithdrawalFeeRatio: RationalSchema,
+  redemptionReimbursementRatio: RationalSchema,
+  redemptionProcessingFeeRatio: RationalSchema,
+  firstIAsset: TSchema.Boolean,
+  nextIAsset: TSchema.NullOr(TSchema.ByteArray),
+});
+
+export type IAssetContent = typeof IAssetContentSchema.Type;
+
+const CollateralAssetContentSchema = TSchema.Struct({
+  iasset: TSchema.ByteArray,
+  collateralAsset: AssetClassSchema,
+  extraDecimals: TSchema.Integer,
+  priceInfo: IAssetPriceInfoSchema,
+  interestOracleNft: AssetClassSchema,
+  redemptionRatio: RationalSchema,
+  maintenanceRatio: RationalSchema,
+  liquidationRatio: RationalSchema,
+  minCollateralAmt: TSchema.Integer,
+  firstCollateralAsset: TSchema.Boolean,
+  nextCollateralAsset: TSchema.NullOr(AssetClassSchema),
+});
+
+export type CollateralAssetContent = typeof CollateralAssetContentSchema.Type;
+
+const IAssetDatumSchema = TSchema.Union(
+  TSchema.Struct({ IAssetContent: IAssetContentSchema }, { flatInUnion: true }),
+  TSchema.Struct(
+    { CollateralAssetContent: CollateralAssetContentSchema },
+    { flatInUnion: true },
+  ),
+);
+
+export type IAssetDatum = typeof IAssetDatumSchema.Type;
+
+const IAssetRedeemerSchema = TSchema.Union(
+  TSchema.Struct(
+    {
+      UpdateOrInsertAsset: TSchema.Struct(
+        { executeInputIdx: TSchema.Integer },
+        { flatFields: true },
+      ),
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Literal('UpgradeVersion', { flatInUnion: true }),
+);
+
+export type IAssetRedeemer = typeof IAssetRedeemerSchema.Type;
+
+export function serialiseIAssetRedeemer(r: IAssetRedeemer): string {
+  return Data.withSchema(
+    IAssetRedeemerSchema,
+    DEFAULT_SCHEMA_OPTIONS,
+  ).toCBORHex(r);
+}
+
+export function serialiseIAssetDatum(d: IAssetDatum): string {
+  return Data.withSchema(IAssetDatumSchema).toCBORHex(d);
+}
+
+export function parseIAssetDatum(datum: string): O.Option<IAssetContent> {
+  try {
+    return match(
+      Data.withSchema(IAssetDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+        datum,
+      ),
+    )
+      .with({ IAssetContent: P.select() }, (content) => O.some(content))
+      .otherwise(() => O.none);
+  } catch (_) {
+    return O.none;
+  }
+}
+
+export function parseIAssetDatumOrThrow(datum: string): IAssetContent {
+  return F.pipe(
+    parseIAssetDatum(datum),
+    O.match(() => {
+      throw new Error('Expected a Iasset datum.');
+    }, F.identity),
+  );
+}
+
+export function parseCollateralAssetDatum(
+  datum: string,
+): O.Option<CollateralAssetContent> {
+  try {
+    return match(
+      Data.withSchema(IAssetDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+        datum,
+      ),
+    )
+      .with({ CollateralAssetContent: P.select() }, (content) =>
+        O.some(content),
+      )
+      .otherwise(() => O.none);
+  } catch (_) {
+    return O.none;
+  }
+}
+
+export function parseCollateralAssetDatumOrThrow(
+  datum: string,
+): CollateralAssetContent {
+  return F.pipe(
+    parseCollateralAssetDatum(datum),
+    O.match(() => {
+      throw new Error('Expected a collateral asset datum.');
+    }, F.identity),
+  );
+}
+
+export type IAssetOutput = ParsedOutput<IAssetContent>;
+export type CollateralAssetOutput = ParsedOutput<CollateralAssetContent>;