@indigo-labs/indigo-sdk 0.5.4 → 0.5.6

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

@@ -1,385 +0,0 @@
-import { TSchema, Data } from '@evolution-sdk/evolution';
-import { match, P } from 'ts-pattern';
-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 = TSchema.Struct({
-  value: TSchema.Integer,
-});
-
-export type SPInteger = typeof SPIntegerSchema.Type;
-
-const AccountActionSchema = TSchema.Union(
-  TSchema.Literal('Create', { flatInUnion: true }),
-  TSchema.Struct(
-    {
-      Adjust: TSchema.Struct(
-        {
-          amount: TSchema.Integer,
-          outputAddress: AddressSchema,
-        },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Struct(
-    {
-      Close: TSchema.Struct(
-        { outputAddress: AddressSchema, maxTxFee: TSchema.Integer },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-);
-
-export type AccountAction = typeof AccountActionSchema.Type;
-
-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 EpochToScaleToSumEntry = typeof EpochToScaleToSumEntrySchema.Type;
-
-const StateSnapshotSchema = TSchema.Struct({
-  productVal: SPIntegerSchema,
-  depositVal: SPIntegerSchema,
-  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;
-
-const AssetStateSchema = TSchema.Tuple([AssetClassSchema, AssetSnapshotSchema]);
-export type AssetState = typeof AssetStateSchema.Type;
-
-export const StabilityPoolContentSchema = TSchema.Struct({
-  iasset: TSchema.ByteArray,
-  state: StateSnapshotSchema,
-  assetStates: TSchema.Array(AssetStateSchema),
-});
-
-export type StabilityPoolContent = typeof StabilityPoolContentSchema.Type;
-
-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 = TSchema.Struct({
-  snapshot: TSchema.Array(EpochToScaleToSumEntrySchema),
-  iasset: TSchema.ByteArray,
-  collateralAsset: AssetClassSchema,
-});
-
-export type SnapshotEpochToScaleToSumContent =
-  typeof SnapshotEpochToScaleToSumContentSchema.Type;
-
-export const StabilityPoolDatumSchema = TSchema.Union(
-  TSchema.Struct(
-    { StabilityPool: StabilityPoolContentSchema },
-    { flatInUnion: true },
-  ),
-  TSchema.Struct({ Account: AccountContentSchema }, { flatInUnion: true }),
-  TSchema.Struct(
-    { SnapshotEpochToScaleToSum: SnapshotEpochToScaleToSumContentSchema },
-    { flatInUnion: true },
-  ),
-);
-
-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 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 },
-  ),
-  TSchema.Struct(
-    {
-      ProcessRequestAccount: ProcessRequestAccountContentSchema,
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Literal('AnnulRequest', { flatInUnion: true }),
-  TSchema.Struct(
-    {
-      LiquidateCDP: TSchema.Struct(
-        {
-          cdpIdx: TSchema.Integer,
-        },
-        { flatFields: true },
-      ),
-    },
-    { 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 {
-  return Data.withSchema(
-    StabilityPoolRedeemerSchema,
-    DEFAULT_SCHEMA_OPTIONS,
-  ).toCBORHex(r);
-}
-
-export function parseStabilityPoolRedeemer(
-  datum: string,
-): O.Option<StabilityPoolRedeemer> {
-  try {
-    return O.some(
-      Data.withSchema(
-        StabilityPoolRedeemerSchema,
-        DEFAULT_SCHEMA_OPTIONS,
-      ).fromCBORHex(datum),
-    );
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parseStabilityPoolRedeemerOrThrow(
-  datum: string,
-): StabilityPoolRedeemer {
-  return F.pipe(
-    parseStabilityPoolRedeemer(datum),
-    O.match(() => {
-      throw new Error('Expected a StabilityPoolRedeemer datum.');
-    }, F.identity),
-  );
-}
-
-export function serialiseStabilityPoolDatum(
-  d: typeof StabilityPoolDatumSchema.Type,
-  /**
-   * This is necessary to change only in case of execute propose asset.
-   */
-  useIndefiniteMaps: boolean = false,
-): string {
-  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),
-  );
-}
-
-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 F.pipe(
-    parseSnapshotEpochToScaleToSumDatum(datum),
-    O.match(() => {
-      throw new Error('Expected snapshot e2s2s datum.');
-    }, F.identity),
-  );
-}
-
-/** SP Integer */
-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 divideOnChainCompatible(value.value, spPrecision);
-}
-
-export function spAdd(a: SPInteger, b: SPInteger): SPInteger {
-  return { value: a.value + b.value };
-}
-
-export function spSub(a: SPInteger, b: SPInteger): SPInteger {
-  return { value: a.value - b.value };
-}
-
-export function spMul(a: SPInteger, b: SPInteger): SPInteger {
-  return { value: divideOnChainCompatible(a.value * b.value, spPrecision) };
-}
-
-export function spDiv(a: SPInteger, b: SPInteger): SPInteger {
-  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,25 +0,0 @@
-import { Data } from '@lucid-evolution/lucid';
-import { AssetClassSchema, StakeCredentialSchema } from '../../types/generic';
-
-/** SP Parameters */
-const StabilityPoolParamsSchema = Data.Object({
-  assetSymbol: Data.Bytes(),
-  stabilityPoolToken: AssetClassSchema,
-  snapshotEpochToScaleToSumToken: AssetClassSchema,
-  accountToken: AssetClassSchema,
-  cdpToken: AssetClassSchema,
-  iAssetAuthToken: AssetClassSchema,
-  versionRecordToken: AssetClassSchema,
-  iassetValHash: Data.Bytes(),
-  accountCreateFeeLovelaces: Data.Integer(),
-  accountProcessingCooldownMs: Data.Integer(),
-  accountProcessingBiasMs: Data.Integer(),
-  stakeCredential: Data.Nullable(StakeCredentialSchema),
-});
-export type StabilityPoolParams = Data.Static<typeof StabilityPoolParamsSchema>;
-export const StabilityPoolParams =
-  StabilityPoolParamsSchema as unknown as StabilityPoolParams;
-
-export function castStabilityPoolParams(params: StabilityPoolParams): Data {
-  return Data.castTo(params, StabilityPoolParams);
-}