@indigo-labs/indigo-sdk 0.5.5 → 0.5.6

package/src/contracts/gov/types-new.ts

@@ -1,268 +0,0 @@
-import { TSchema, Data } from '@evolution-sdk/evolution';
-import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
-import {
-  AddressSchema,
-  AssetClassSchema,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import { option as O, function as F } from 'fp-ts';
-import { IAssetPriceInfoSchema } from '../iasset/types';
-import { MultisigSchema } from '../../types/multisig';
-import { RationalSchema } from '../../types/rational';
-
-export const ProtocolParamsSchema = TSchema.Struct({
-  proposalDeposit: TSchema.Integer,
-  votingPeriod: TSchema.Integer,
-  effectiveDelay: TSchema.Integer,
-  expirationPeriod: TSchema.Integer,
-  proposingPeriod: TSchema.Integer,
-  totalShards: TSchema.Integer,
-  minimumQuorum: TSchema.Integer,
-  maxTreasuryLovelaceSpend: TSchema.Integer,
-  maxTreasuryIndySpend: TSchema.Integer,
-  cdpRedemptionRequiredSignature: TSchema.NullOr(TSchema.ByteArray),
-  electorate: TSchema.Integer,
-  foundationMultisig: MultisigSchema,
-});
-
-export type ProtocolParams = typeof ProtocolParamsSchema.Type;
-
-const UpgradePathSchema = TSchema.Struct({
-  upgradeSymbol: TSchema.ByteArray,
-});
-
-const UpgradePathsSchema = TSchema.Struct({
-  upgradeId: TSchema.Integer,
-  /// Underlying representation of the following mapping: ValidatorHash -> UpgradePath
-  upgradePaths: TSchema.Array(
-    TSchema.Tuple([TSchema.ByteArray, UpgradePathSchema]),
-  ),
-});
-export type UpgradePaths = typeof UpgradePathsSchema.Type;
-
-const ProposeIAssetContentSchema = TSchema.Struct({
-  asset: TSchema.ByteArray,
-  debtMintingFeeRatio: RationalSchema,
-  liquidationProcessingFeeRatio: RationalSchema,
-  stabilityPoolWithdrawalFeeRatio: RationalSchema,
-  redemptionReimbursementRatio: RationalSchema,
-  redemptionProcessingFeeRatio: RationalSchema,
-});
-export type ProposeAssetContent = typeof ProposeIAssetContentSchema.Type;
-
-const ModifyIAssetContentSchema = TSchema.Struct({
-  asset: TSchema.ByteArray,
-  newDebtMintingFeeRatio: RationalSchema,
-  newLiquidationProcessingFeeRatio: RationalSchema,
-  newStabilityPoolWithdrawalFeeRatio: RationalSchema,
-  newRedemptionReimbursementRatio: RationalSchema,
-  newRedemptionProcessingFeeRatio: RationalSchema,
-});
-
-const AddCollateralAssetContentSchema = TSchema.Struct({
-  correspondingIAsset: TSchema.ByteArray,
-  collateralAsset: AssetClassSchema,
-  assetExtraDecimals: TSchema.Integer,
-  assetPriceInfo: IAssetPriceInfoSchema,
-  interestOracleNft: AssetClassSchema,
-  redemptionRatio: RationalSchema,
-  maintenanceRatio: RationalSchema,
-  liquidationRatio: RationalSchema,
-  minCollateralAmt: TSchema.Integer,
-});
-
-export type AddCollateralAsssetContent =
-  typeof AddCollateralAssetContentSchema.Type;
-
-const UpdateCollateralAssetContentSchema = TSchema.Struct({
-  correspondingIAsset: TSchema.ByteArray,
-  collateralAsset: AssetClassSchema,
-  newAssetExtraDecimals: TSchema.Integer,
-  newAssetPriceInfo: IAssetPriceInfoSchema,
-  newInterestOracleNft: AssetClassSchema,
-  newRedemptionRatio: RationalSchema,
-  newMaintenanceRatio: RationalSchema,
-  newLiquidationRatio: RationalSchema,
-  newMinCollateralAmt: TSchema.Integer,
-});
-
-const ProposeStableswapPoolContentSchema = TSchema.Struct({
-  iasset: TSchema.ByteArray,
-  collateralAsset: AssetClassSchema,
-  collateralToIassetRatio: RationalSchema,
-  mintingFeeRatio: RationalSchema,
-  redemptionFeeRatio: RationalSchema,
-  feeManager: TSchema.NullOr(TSchema.ByteArray),
-  minMintingAmount: TSchema.Integer,
-  minRedemptionAmount: TSchema.Integer,
-  stableswapValHash: TSchema.ByteArray,
-});
-
-export type ProposeStableswapPoolContent =
-  typeof ProposeStableswapPoolContentSchema.Type;
-
-const ModifyStableswapPoolContentSchema = TSchema.Struct({
-  iasset: TSchema.ByteArray,
-  collateralAsset: AssetClassSchema,
-  newCollateralToIassetRatio: RationalSchema,
-  newMintingFeeRatio: RationalSchema,
-  newRedemptionFeeRatio: RationalSchema,
-  newMintingEnabled: TSchema.Boolean,
-  newRedemptionEnabled: TSchema.Boolean,
-  newFeeManager: TSchema.NullOr(TSchema.ByteArray),
-  newMinMintingAmount: TSchema.Integer,
-  newMinRedemptionAmount: TSchema.Integer,
-  newStableswapValHash: TSchema.ByteArray,
-});
-
-export type ModifyStableswapPoolContent =
-  typeof ModifyStableswapPoolContentSchema.Type;
-
-export const ProposalContentSchema = TSchema.Union(
-  TSchema.Struct(
-    {
-      ProposeIAsset: ProposeIAssetContentSchema,
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Struct(
-    {
-      ModifyIAsset: ModifyIAssetContentSchema,
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Struct(
-    {
-      AddCollateralAsset: AddCollateralAssetContentSchema,
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Struct(
-    {
-      UpdateCollateralAsset: UpdateCollateralAssetContentSchema,
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Struct(
-    {
-      ProposeStableswapPool: ProposeStableswapPoolContentSchema,
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Struct(
-    {
-      ModifyStableswapPool: ModifyStableswapPoolContentSchema,
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Struct(
-    {
-      ModifyProtocolParams: TSchema.Struct(
-        {
-          newParams: ProtocolParamsSchema,
-        },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Struct(
-    {
-      UpgradeProtocol: TSchema.Struct(
-        {
-          content: UpgradePathsSchema,
-        },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Struct(
-    {
-      TextProposal: TSchema.ByteArray,
-    },
-    { flatInUnion: true },
-  ),
-);
-export type ProposalContent = typeof ProposalContentSchema.Type;
-
-const TreasuryWithdrawalItemSchema = TSchema.Struct({
-  currencySymbol: TSchema.ByteArray,
-  tokenName: TSchema.ByteArray,
-  amount: TSchema.Integer,
-});
-export type TreasuryWithdrawalItem = typeof TreasuryWithdrawalItemSchema.Type;
-
-export const TreasuryWithdrawalSchema = TSchema.Struct({
-  destination: AddressSchema,
-  value: TSchema.Array(TreasuryWithdrawalItemSchema),
-});
-export type TreasuryWithdrawal = typeof TreasuryWithdrawalSchema.Type;
-
-const GovRedeemerSchema = TSchema.Union(
-  TSchema.Struct(
-    {
-      CreatePoll: TSchema.Struct(
-        {
-          currentTime: TSchema.Integer,
-          proposalOwner: TSchema.ByteArray,
-          content: ProposalContentSchema,
-          treasuryWithdrawal: TSchema.NullOr(TreasuryWithdrawalSchema),
-        },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Struct(
-    {
-      WitnessEndPoll: TSchema.Struct(
-        {
-          currentTime: TSchema.Integer,
-        },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Literal('UpgradeGov', { flatInUnion: true }),
-  TSchema.Literal('UpgradeVersion', { flatInUnion: true }),
-);
-export type GovRedeemer = typeof GovRedeemerSchema.Type;
-
-const GovDatumSchema = TSchema.Struct({
-  currentProposal: TSchema.Integer,
-  protocolParams: ProtocolParamsSchema,
-  currentVersion: TSchema.Integer,
-  iassetsCount: TSchema.Integer,
-  activeProposals: TSchema.Integer,
-});
-export type GovDatum = typeof GovDatumSchema.Type;
-
-export function serialiseGovRedeemer(r: GovRedeemer): string {
-  return Data.withSchema(GovRedeemerSchema).toCBORHex(r);
-}
-
-export function serialiseGovDatum(d: GovDatum): string {
-  return Data.withSchema(GovDatumSchema).toCBORHex(d);
-}
-
-export function parseGovDatum(datum: string): O.Option<GovDatum> {
-  try {
-    return O.some(
-      Data.withSchema(GovDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
-        datum,
-      ),
-    );
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parseGovDatumOrThrow(datum: string): GovDatum {
-  return F.pipe(
-    parseGovDatum(datum),
-    O.match(() => {
-      throw new Error('Expected a Gov datum.');
-    }, F.identity),
-  );
-}

package/src/contracts/gov/types.ts

@@ -1,22 +0,0 @@
-import { Data } from '@lucid-evolution/lucid';
-import { AssetClassSchema } from '../../types/generic';
-
-const GovParamsSchema = Data.Object({
-  govNFT: AssetClassSchema,
-  pollToken: AssetClassSchema,
-  upgradeToken: AssetClassSchema,
-  indyAsset: AssetClassSchema,
-  versionRecordToken: AssetClassSchema,
-  iassetSymbol: Data.Bytes(),
-  pollManagerValHash: Data.Bytes(),
-  iassetValHash: Data.Bytes(),
-  gBiasTime: Data.Integer(),
-  daoIdentityToken: AssetClassSchema,
-  iAssetAuthToken: AssetClassSchema,
-});
-export type GovParams = Data.Static<typeof GovParamsSchema>;
-export const GovParams = GovParamsSchema as unknown as GovParams;
-
-export function castGovParams(params: GovParams): Data {
-  return Data.castTo(params, GovParams);
-}

package/src/contracts/iasset/helpers.ts

@@ -1,170 +0,0 @@
-import {
-  credentialToRewardAddress,
-  Data,
-  fromHex,
-  LucidEvolution,
-  OutRef,
-  scriptHashToCredential,
-  toHex,
-  TxBuilder,
-  UTxO,
-} from '@lucid-evolution/lucid';
-import { IAssetPriceInfo } from './types';
-import { matchSingle } from '../../utils/utils';
-import { parsePriceOracleDatum } from '../price-oracle/types-new';
-import { getInlineDatumOrThrow } from '../../utils/lucid-utils';
-import { oracleExpirationAwareValidity } from '../price-oracle/helpers';
-import {
-  fromSysParamsDerivedPythPrice,
-  fromSystemParamsScriptRef,
-  getPythFeedConfig,
-  PythConfig,
-} from '../../types/system-params';
-import {
-  parsePythStateDatum,
-  serialisePythFeedRedeemer,
-  serialisePythUpdatesRedeemer,
-} from '../pyth-feed/types';
-import { match, P } from 'ts-pattern';
-import { derivePythPrice } from '../pyth-feed/helpers';
-import { AssetClass } from '@3rd-eye-labs/cardano-offchain-common';
-import * as Core from '@evolution-sdk/evolution';
-import { decodePriceUpdate, decodePythMessage } from '../../utils/pyth';
-
-export const MAX_COLLATERAL_ASSETS_COUNT_PER_IASSET = 9;
-
-type Interval = {
-  validFrom: number;
-  validTo: number;
-};
-
-export function attachOracle(
-  iasset: Uint8Array<ArrayBufferLike>,
-  collateralAsset: AssetClass,
-  priceInfo: IAssetPriceInfo,
-  priceOracleOref: OutRef | undefined,
-  pythStateOref: OutRef | undefined,
-  pythMessage: string | undefined,
-  pythConfig: PythConfig,
-  biasTime: bigint,
-  lucid: LucidEvolution,
-  tx: TxBuilder,
-): Promise<{ interval: Interval; referenceInputs: UTxO[] }> {
-  return match(priceInfo)
-    .returnType<Promise<{ interval: Interval; referenceInputs: UTxO[] }>>()
-    .with({ Delisted: P.any }, () => {
-      const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
-
-      // We want to make sure the transaction is valid within the bias time for interest tracking AND Pyth
-      // For validFrom, we take the higher of the two bias times
-      const validFrom = Number(currentTime - BigInt(biasTime / 2n));
-      // For validTo, we take the lower of the two bias times
-      const validTo = Number(currentTime + BigInt(biasTime / 2n));
-
-      return Promise.resolve({
-        interval: {
-          validFrom,
-          validTo,
-        },
-        referenceInputs: [],
-      });
-    })
-    .with({ OracleNft: P.any }, async () => {
-      if (!priceOracleOref) throw new Error('Missing price oracle');
-
-      const priceOracleUtxo = matchSingle<UTxO>(
-        await lucid.utxosByOutRef([priceOracleOref]),
-        (_) => new Error('Expected a single price oracle UTXO'),
-      );
-      const priceOracleDatum = parsePriceOracleDatum(
-        getInlineDatumOrThrow(priceOracleUtxo),
-      );
-
-      return {
-        interval: oracleExpirationAwareValidity(
-          lucid,
-          Number(biasTime),
-          Number(priceOracleDatum.expirationTime),
-        ),
-        referenceInputs: [priceOracleUtxo],
-      };
-    })
-    .with(
-      { DeferredValidation: { feedValHash: P.select() } },
-      async (feedValHash) => {
-        if (priceOracleOref) throw new Error('Cannot pass price oracle oref');
-        if (!pythMessage) throw new Error('Missing Pyth message');
-        if (!pythStateOref) throw new Error('Missing pyth state out ref');
-
-        const pythStateUtxo = matchSingle(
-          await lucid.utxosByOutRef([pythStateOref]),
-          (_) => new Error('Expected a single pyth state UTXO'),
-        );
-
-        const pythStateDatum = parsePythStateDatum(
-          getInlineDatumOrThrow(pythStateUtxo),
-        );
-
-        const pythFeedCfg = getPythFeedConfig(
-          pythConfig,
-          iasset,
-          collateralAsset,
-        );
-
-        // Lookup PFV Validator
-        const pfvScriptRefUtxo = matchSingle(
-          await lucid.utxosByOutRef([
-            fromSystemParamsScriptRef(pythFeedCfg.pythFeedValScriptRef),
-          ]),
-          (_) =>
-            new Error('Expected a single pyth feed validator Ref Script UTXO'),
-        );
-
-        const derivedPythPrice = fromSysParamsDerivedPythPrice(
-          pythFeedCfg.params.config,
-        );
-
-        const price = derivePythPrice(derivedPythPrice, pythMessage);
-
-        const decodedMessage = decodePythMessage(fromHex(pythMessage));
-        const pricePayload = decodePriceUpdate(decodedMessage.payload);
-        const pythTimestamp = Number(pricePayload.timestampUs) / 1_000;
-
-        tx.withdraw(
-          credentialToRewardAddress(
-            lucid.config().network!,
-            scriptHashToCredential(toHex(pythStateDatum.withdraw_script)),
-          ),
-          0n,
-          serialisePythUpdatesRedeemer([fromHex(pythMessage)]),
-        );
-
-        tx.withdraw(
-          credentialToRewardAddress(
-            lucid.config().network!,
-            scriptHashToCredential(toHex(feedValHash)),
-          ),
-          0n,
-          serialisePythFeedRedeemer({
-            price: price,
-            auxiliaryData: Core.Data.fromCBORHex(Data.void()),
-          }),
-        );
-
-        // 5 minutes - 20 seconds
-        const pythMaxDelay = 280 * 1000;
-
-        const validFrom = Number(pythTimestamp);
-        const validTo = Number(pythTimestamp + pythMaxDelay);
-
-        return {
-          interval: {
-            validFrom: validFrom,
-            validTo: validTo,
-          },
-          referenceInputs: [pythStateUtxo, pfvScriptRefUtxo],
-        };
-      },
-    )
-    .exhaustive();
-}

package/src/contracts/iasset/queries.ts

@@ -1,102 +0,0 @@
-import { LucidEvolution, toHex } from '@lucid-evolution/lucid';
-import { fromSystemParamsAsset, SystemParams } from '../../types/system-params';
-import {
-  AssetClass,
-  assetClassToUnit,
-  isSameAssetClass,
-  matchSingle,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import {
-  CollateralAssetOutput,
-  IAssetOutput,
-  parseCollateralAssetDatum,
-  parseIAssetDatum,
-} from './types';
-import { createScriptAddress } from '../../utils/lucid-utils';
-import { option as O, array as A, function as F } from 'fp-ts';
-
-export async function findIAsset(
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-  /**
-   * For conversion from hex use the `fromHex` function from lucid-evolution.
-   */
-  iassetName: Uint8Array<ArrayBufferLike>,
-): Promise<IAssetOutput> {
-  const iassetUtxos = await lucid.utxosAtWithUnit(
-    createScriptAddress(
-      lucid.config().network!,
-      sysParams.validatorHashes.iassetHash,
-    ),
-    assetClassToUnit(
-      fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
-    ),
-  );
-
-  return matchSingle(
-    F.pipe(
-      iassetUtxos.map((utxo) =>
-        F.pipe(
-          O.fromNullable(utxo.datum),
-          O.flatMap(parseIAssetDatum),
-          O.flatMap((datum) => {
-            if (toHex(datum.assetName) === toHex(iassetName)) {
-              return O.some({ utxo, datum: datum });
-            } else {
-              return O.none;
-            }
-          }),
-        ),
-      ),
-      A.compact,
-    ),
-    (res) =>
-      new Error('Expected a single IAsset UTXO.: ' + JSON.stringify(res)),
-  );
-}
-
-export async function findCollateralAsset(
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-  /**
-   * For conversion from hex use the `fromHex` function from lucid-evolution.
-   */
-  iassetName: Uint8Array<ArrayBufferLike>,
-  collateralAsset: AssetClass,
-): Promise<CollateralAssetOutput> {
-  const collateralAssetUtxos = await lucid.utxosAtWithUnit(
-    createScriptAddress(
-      lucid.config().network!,
-      sysParams.validatorHashes.iassetHash,
-    ),
-    assetClassToUnit(
-      fromSystemParamsAsset(sysParams.cdpParams.collateralAssetAuthToken),
-    ),
-  );
-
-  return matchSingle(
-    F.pipe(
-      collateralAssetUtxos.map((utxo) =>
-        F.pipe(
-          O.fromNullable(utxo.datum),
-          O.flatMap(parseCollateralAssetDatum),
-          O.flatMap((datum) => {
-            if (
-              isSameAssetClass(datum.collateralAsset, collateralAsset) &&
-              toHex(iassetName) === toHex(datum.iasset)
-            ) {
-              return O.some({ utxo, datum: datum });
-            } else {
-              return O.none;
-            }
-          }),
-        ),
-      ),
-      A.compact,
-    ),
-    (res) =>
-      new Error(
-        'Expected a single Collateral Asset UTXO.: ' + JSON.stringify(res),
-      ),
-  );
-}

package/src/contracts/iasset/scripts.ts

@@ -1,38 +0,0 @@
-import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
-import {
-  fromSystemParamsAssetLucid,
-  IAssetParamsSP,
-} from '../../types/system-params';
-import { _cdpValidator } from '../../validators/cdp-validator';
-import { _iassetValidator } from '../../validators/iasset-validator';
-
-import { Data } from '@lucid-evolution/lucid';
-import { AssetClassSchema } from '../../types/generic';
-
-const IAssetScriptParamsSchema = Data.Object({
-  upgradeToken: AssetClassSchema,
-  versionRecordToken: AssetClassSchema,
-});
-
-export type IAssetScriptParams = Data.Static<typeof IAssetScriptParamsSchema>;
-export const IAssetScriptParams =
-  IAssetScriptParamsSchema as unknown as IAssetScriptParams;
-
-export const mkIAssetValidatorFromSP = (
-  params: IAssetParamsSP,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV3',
-    script: applyParamsToScript(_iassetValidator.cborHex, [
-      Data.castTo(
-        {
-          upgradeToken: fromSystemParamsAssetLucid(params.upgradeToken),
-          versionRecordToken: fromSystemParamsAssetLucid(
-            params.versionRecordToken,
-          ),
-        },
-        IAssetScriptParams,
-      ),
-    ]),
-  };
-};