@indigo-labs/indigo-sdk 0.5.4 → 0.5.6

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

@@ -1,277 +0,0 @@
-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,
-  OutputReferenceSchema,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import { match, P } from 'ts-pattern';
-import { RationalSchema } from '../../types/rational';
-import { OracleIdxSchema } from '../price-oracle/types-new';
-
-// const CdpParamsSchema = Core.TSchema.Struct({
-//   cdp_auth_token: EvoCommon.AssetClassSchema,
-//   cdp_asset_symbol: Core.TSchema.ByteArray,
-//   iasset_auth_token: EvoCommon.AssetClassSchema,
-//   stability_pool_auth_token: EvoCommon.AssetClassSchema,
-//   version_record_token: EvoCommon.AssetClassSchema,
-//   upgrade_token: EvoCommon.AssetClassSchema,
-//   collector_val_hash: Core.TSchema.ByteArray,
-//   sp_val_hash: Core.TSchema.ByteArray,
-//   gov_nft: EvoCommon.AssetClassSchema,
-//   min_collateral_in_lovelace: Core.TSchema.Integer,
-//   partial_redemption_extra_fee_lovelace: Core.TSchema.Integer,
-//   bias_time: Core.TSchema.Integer,
-//   treasury_val_hash: Core.TSchema.ByteArray,
-// });
-
-// export type CdpParams = typeof CdpParamsSchema.Type;
-
-const CdpRedeemerSchema = TSchema.Union(
-  TSchema.Struct(
-    {
-      AdjustCdp: TSchema.Struct(
-        {
-          currentTime: TSchema.Integer,
-          debtAdjustment: TSchema.Integer,
-          collateralAdjustment: TSchema.Integer,
-          priceOracleIdx: OracleIdxSchema,
-        },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Struct(
-    {
-      CloseCdp: TSchema.Struct(
-        {
-          currentTime: TSchema.Integer,
-        },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Literal('RedeemCdp', { flatInUnion: true }),
-  TSchema.Struct(
-    {
-      FreezeCdp: TSchema.Struct(
-        {
-          currentTime: TSchema.Integer,
-          priceOracleIdx: OracleIdxSchema,
-        },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Literal('MergeCdps', { flatInUnion: true }),
-  TSchema.Struct(
-    {
-      MergeAuxiliary: TSchema.Struct(
-        {
-          mainMergeUtxo: OutputReferenceSchema,
-        },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Literal('Liquidate', { flatInUnion: true }),
-  TSchema.Struct(
-    {
-      SettleInterest: TSchema.Struct(
-        {
-          interestCollectorInputIndex: TSchema.Integer,
-        },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Struct(
-    {
-      Stableswap: TSchema.Struct(
-        {
-          forwardingInputIndex: TSchema.Integer,
-        },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Literal('UpgradeVersion', { flatInUnion: true }),
-);
-
-export type CdpRedeemer = typeof CdpRedeemerSchema.Type;
-
-const RedeemCdpWithdrawalRedeemerSchema = TSchema.Struct({
-  cdpOutReference: OutputReferenceSchema,
-  currentTime: TSchema.Integer,
-  priceOracleIdx: OracleIdxSchema,
-});
-
-export type RedeemCdpWithdrawalRedeemer =
-  typeof RedeemCdpWithdrawalRedeemerSchema.Type;
-
-const CDPFeesSchema = TSchema.Union(
-  TSchema.Struct(
-    {
-      ActiveCDPInterestTracking: TSchema.Struct(
-        {
-          lastSettled: TSchema.Integer,
-          unitaryInterestSnapshot: TSchema.Integer,
-        },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Struct(
-    {
-      FrozenCDPAccumulatedFees: TSchema.Struct(
-        {
-          iassetInterest: TSchema.Integer,
-          collateralTreasury: TSchema.Integer,
-        },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-);
-
-const CDPContentSchema = TSchema.Struct({
-  cdpOwner: TSchema.NullOr(TSchema.ByteArray),
-  iasset: TSchema.ByteArray,
-  collateralAsset: AssetClassSchema,
-  mintedAmt: TSchema.Integer,
-  cdpFees: CDPFeesSchema,
-});
-
-export type CDPContent = typeof CDPContentSchema.Type;
-
-const StableswapPoolContentSchema = TSchema.Struct({
-  /** Use the HEX encoding */
-  iasset: TSchema.ByteArray,
-  collateralAsset: AssetClassSchema,
-  collateralToIassetRatio: RationalSchema,
-  mintingFeeRatio: RationalSchema,
-  redemptionFeeRatio: RationalSchema,
-  mintingEnabled: TSchema.Boolean,
-  redemptionEnabled: TSchema.Boolean,
-  feeManager: TSchema.NullOr(TSchema.ByteArray),
-  minMintOrderAmount: TSchema.Integer,
-  minRedemptionOrderAmount: TSchema.Integer,
-  stableswapValHash: TSchema.ByteArray,
-});
-
-export type StableswapPoolContent = typeof StableswapPoolContentSchema.Type;
-
-const CDPDatumSchema = TSchema.Union(
-  TSchema.Struct({ CDP: CDPContentSchema }, { flatInUnion: true }),
-  TSchema.Struct(
-    { StableswapPool: StableswapPoolContentSchema },
-    { flatInUnion: true },
-  ),
-);
-export type CDPDatum = typeof CDPDatumSchema.Type;
-
-export function serialiseCdpRedeemer(r: CdpRedeemer): string {
-  return Data.withSchema(CdpRedeemerSchema, DEFAULT_SCHEMA_OPTIONS).toCBORHex(
-    r,
-  );
-}
-
-export function parseCdpRedeemer(datum: string): O.Option<CdpRedeemer> {
-  try {
-    return O.some(
-      Data.withSchema(CdpRedeemerSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
-        datum,
-      ),
-    );
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parseCdpRedeemerOrThrow(datum: string): CdpRedeemer {
-  return F.pipe(
-    parseCdpRedeemer(datum),
-    O.match(() => {
-      throw new Error('Expected a cdp redeemer.');
-    }, F.identity),
-  );
-}
-
-export function serialiseRedeemCdpWithdrawalRedeemer(
-  r: RedeemCdpWithdrawalRedeemer,
-): string {
-  return Data.withSchema(
-    RedeemCdpWithdrawalRedeemerSchema,
-    DEFAULT_SCHEMA_OPTIONS,
-  ).toCBORHex(r);
-}
-
-export function serialiseCdpDatum(d: CDPContent): string {
-  return Data.withSchema(CDPDatumSchema, DEFAULT_SCHEMA_OPTIONS).toCBORHex({
-    CDP: d,
-  });
-}
-
-export function serialiseStableswapPoolDatum(d: StableswapPoolContent): string {
-  return Data.withSchema(CDPDatumSchema, DEFAULT_SCHEMA_OPTIONS).toCBORHex({
-    StableswapPool: d,
-  });
-}
-
-export function parseCdpDatum(datum: string): O.Option<CDPContent> {
-  try {
-    return match(
-      Data.withSchema(CDPDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
-        datum,
-      ),
-    )
-      .with({ CDP: P.select() }, (res) => O.some(res))
-      .otherwise(() => O.none);
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parseCdpDatumOrThrow(datum: string): CDPContent {
-  return F.pipe(
-    parseCdpDatum(datum),
-    O.match(() => {
-      throw new Error('Expected a CDP datum.');
-    }, F.identity),
-  );
-}
-
-export function parseStableswapPoolDatum(
-  datum: string,
-): O.Option<StableswapPoolContent> {
-  try {
-    return match(
-      Data.withSchema(CDPDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
-        datum,
-      ),
-    )
-      .with({ StableswapPool: P.select() }, (res) => O.some(res))
-      .otherwise(() => O.none);
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parseStableswapPoolDatumOrThrow(
-  datum: string,
-): StableswapPoolContent {
-  return F.pipe(
-    parseStableswapPoolDatum(datum),
-    O.match(() => {
-      throw new Error('Expected a stableswap pool datum.');
-    }, F.identity),
-  );
-}

package/src/contracts/cdp/types.ts

@@ -1,43 +0,0 @@
-import { Data } from '@lucid-evolution/lucid';
-import { AssetClassSchema } from '../../types/generic';
-
-const CdpParamsSchema = Data.Object({
-  cdp_auth_token: AssetClassSchema,
-  cdp_asset_symbol: Data.Bytes(),
-  iasset_auth_token: AssetClassSchema,
-  collateral_asset_auth_token: AssetClassSchema,
-  stability_pool_auth_token: AssetClassSchema,
-  upgrade_token: AssetClassSchema,
-  version_record_token: AssetClassSchema,
-  interest_collector_val_hash: Data.Bytes(),
-  sp_val_hash: Data.Bytes(),
-  iasset_val_hash: Data.Bytes(),
-  treasury_val_hash: Data.Bytes(),
-  cdp_redeem_val_hash: Data.Bytes(),
-  bias_time: Data.Integer(),
-});
-export type CdpParams = Data.Static<typeof CdpParamsSchema>;
-const CdpParams = CdpParamsSchema as unknown as CdpParams;
-
-export function castCdpParams(params: CdpParams): Data {
-  return Data.castTo(params, CdpParams);
-}
-
-const CdpRedeemParamsSchema = Data.Object({
-  cdp_auth_token: AssetClassSchema,
-  cdp_asset_symbol: Data.Bytes(),
-  iasset_auth_token: AssetClassSchema,
-  collateral_asset_auth_token: AssetClassSchema,
-  interest_collector_val_hash: Data.Bytes(),
-  iasset_val_hash: Data.Bytes(),
-  treasury_val_hash: Data.Bytes(),
-  gov_nft: AssetClassSchema,
-  partial_redemption_extra_fee_lovelace: Data.Integer(),
-  bias_time: Data.Integer(),
-});
-export type CdpRedeemParams = Data.Static<typeof CdpRedeemParamsSchema>;
-const CdpRedeemParams = CdpRedeemParamsSchema as unknown as CdpRedeemParams;
-
-export function castCdpRedeemParams(params: CdpRedeemParams): Data {
-  return Data.castTo(params, CdpRedeemParams);
-}

package/src/contracts/cdp-creator/queries.ts

@@ -1,30 +0,0 @@
-import {
-  assetClassToUnit,
-  getRandomElement,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import { LucidEvolution, UTxO } from '@lucid-evolution/lucid';
-import { option as O, function as F } from 'fp-ts';
-import { createScriptAddress } from '../../utils/lucid-utils';
-import { fromSystemParamsAsset, SystemParams } from '../../types/system-params';
-
-export async function findRandomCdpCreator(
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-): Promise<UTxO> {
-  const cdpCreatorUtxos = await lucid.utxosAtWithUnit(
-    createScriptAddress(
-      lucid.config().network!,
-      sysParams.validatorHashes.cdpCreatorHash,
-    ),
-    assetClassToUnit(
-      fromSystemParamsAsset(sysParams.cdpCreatorParams.cdpCreatorNft),
-    ),
-  );
-
-  return F.pipe(
-    O.fromNullable(getRandomElement(cdpCreatorUtxos)),
-    O.match(() => {
-      throw new Error('Expected some cdp creator UTXOs.');
-    }, F.identity),
-  );
-}

package/src/contracts/cdp-creator/scripts.ts

@@ -1,45 +0,0 @@
-import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
-import { castCDPCreatorParams, CDPCreatorParams } from './types';
-import {
-  CDPCreatorParamsSP,
-  fromSystemParamsAssetLucid,
-} from '../../types/system-params';
-import { _cdpCreatorValidator } from '../../validators/cdp-creator-validator';
-
-export const mkCDPCreatorValidator = (
-  params: CDPCreatorParams,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV3',
-    script: applyParamsToScript(_cdpCreatorValidator.cborHex, [
-      castCDPCreatorParams(params),
-    ]),
-  };
-};
-
-export const mkCDPCreatorValidatorFromSP = (
-  params: CDPCreatorParamsSP,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV3',
-    script: applyParamsToScript(_cdpCreatorValidator.cborHex, [
-      castCDPCreatorParams({
-        cdpCreatorNft: fromSystemParamsAssetLucid(params.cdpCreatorNft),
-        cdpAssetCs: params.cdpAssetCs.unCurrencySymbol,
-        cdpAuthTk: fromSystemParamsAssetLucid(params.cdpAuthTk),
-        iAssetAuthTk: fromSystemParamsAssetLucid(params.iAssetAuthTk),
-        collateralAssetAuthTk: fromSystemParamsAssetLucid(
-          params.collateralAssetAuthTk,
-        ),
-        upgradeToken: fromSystemParamsAssetLucid(params.upgradeToken),
-        versionRecordToken: fromSystemParamsAssetLucid(
-          params.versionRecordToken,
-        ),
-        iassetValHash: params.iassetValHash,
-        cdpScriptHash: params.cdpScriptHash,
-        treasuryValHash: params.treasuryValHash,
-        biasTime: BigInt(params.biasTime),
-      }),
-    ]),
-  };
-};

package/src/contracts/cdp-creator/types-new.ts

@@ -1,50 +0,0 @@
-import { TSchema, Data } from '@evolution-sdk/evolution';
-import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
-import { OutputReferenceSchema } from '@3rd-eye-labs/cardano-offchain-common';
-import { OracleIdxSchema } from '../price-oracle/types-new';
-
-const CDPCreatorDatumSchema = TSchema.Struct({
-  creatorInputOref: OutputReferenceSchema,
-});
-
-const CreateCDPContentSchema = TSchema.Struct({
-  cdpOwner: TSchema.ByteArray,
-  minted: TSchema.Integer,
-  collateralAmt: TSchema.Integer,
-  currentTime: TSchema.Integer,
-  creatorInputIdx: TSchema.Integer,
-  creatorOutputIdx: TSchema.Integer,
-  cdpOutputIdx: TSchema.Integer,
-  iassetRefInputIdx: TSchema.Integer,
-  collateralAssetRefInputIdx: TSchema.Integer,
-  interestOracleRefInputIdx: TSchema.Integer,
-  priceOracleIdx: OracleIdxSchema,
-});
-
-const CDPCreatorRedeemerSchema = TSchema.Union(
-  TSchema.Struct(
-    {
-      CreateCDP: CreateCDPContentSchema,
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Literal('CreateStableswapPool', { flatInUnion: true }),
-  TSchema.Literal('UpgradeCreatorVersion', { flatInUnion: true }),
-);
-export type CDPCreatorRedeemer = typeof CDPCreatorRedeemerSchema.Type;
-
-export function serialiseCDPCreatorDatum(
-  r: typeof CDPCreatorDatumSchema.Type,
-): string {
-  return Data.withSchema(
-    CDPCreatorDatumSchema,
-    DEFAULT_SCHEMA_OPTIONS,
-  ).toCBORHex(r);
-}
-
-export function serialiseCDPCreatorRedeemer(r: CDPCreatorRedeemer): string {
-  return Data.withSchema(
-    CDPCreatorRedeemerSchema,
-    DEFAULT_SCHEMA_OPTIONS,
-  ).toCBORHex(r);
-}

package/src/contracts/cdp-creator/types.ts

@@ -1,24 +0,0 @@
-import { Data } from '@lucid-evolution/lucid';
-import { AssetClassSchema } from '../../types/generic';
-
-const CDPCreatorParamsSchema = Data.Object({
-  cdpCreatorNft: AssetClassSchema,
-  cdpAssetCs: Data.Bytes(),
-  cdpAuthTk: AssetClassSchema,
-  iAssetAuthTk: AssetClassSchema,
-  collateralAssetAuthTk: AssetClassSchema,
-  upgradeToken: AssetClassSchema,
-  versionRecordToken: AssetClassSchema,
-  cdpScriptHash: Data.Bytes(),
-  treasuryValHash: Data.Bytes(),
-  iassetValHash: Data.Bytes(),
-  biasTime: Data.Integer(),
-});
-
-export type CDPCreatorParams = Data.Static<typeof CDPCreatorParamsSchema>;
-export const CDPCreatorParams =
-  CDPCreatorParamsSchema as unknown as CDPCreatorParams;
-
-export function castCDPCreatorParams(params: CDPCreatorParams): Data {
-  return Data.castTo(params, CDPCreatorParams);
-}

package/src/contracts/collector/scripts.ts

@@ -1,32 +0,0 @@
-import {
-  applyParamsToScript,
-  Constr,
-  fromText,
-  SpendingValidator,
-} from '@lucid-evolution/lucid';
-import { CollectorParamsSP } from '../../types/system-params';
-import { _collectorValidator } from '../../validators/collector-validator';
-
-export const mkCollectorValidatorFromSP = (
-  params: CollectorParamsSP,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV3',
-    script: applyParamsToScript(_collectorValidator.cborHex, [
-      new Constr(0, [
-        new Constr(0, [
-          params.stakingManagerNFT[0].unCurrencySymbol,
-          fromText(params.stakingManagerNFT[1].unTokenName),
-        ]),
-        new Constr(0, [
-          params.stakingToken[0].unCurrencySymbol,
-          fromText(params.stakingToken[1].unTokenName),
-        ]),
-        new Constr(0, [
-          params.versionRecordToken[0].unCurrencySymbol,
-          fromText(params.versionRecordToken[1].unTokenName),
-        ]),
-      ]),
-    ]),
-  };
-};

package/src/contracts/collector/transactions.ts

@@ -1,50 +0,0 @@
-import {
-  addAssets,
-  Data,
-  LucidEvolution,
-  OutRef,
-  TxBuilder,
-  UTxO,
-} from '@lucid-evolution/lucid';
-import {
-  fromSystemParamsScriptRef,
-  SystemParams,
-} from '../../types/system-params';
-import { matchSingle } from '../../utils/utils';
-import { serialiseCollectorRedeemer } from './types-new';
-import { mkLovelacesOf } from '@3rd-eye-labs/cardano-offchain-common';
-
-/**
- * Returns the collector ref script UTXO that was added to ref inputs.
- *
- * No need to return the TxBuilder since it's stateful object.
- */
-export async function collectorFeeTx(
-  fee: bigint,
-  lucid: LucidEvolution,
-  params: SystemParams,
-  tx: TxBuilder,
-  collectorOref: OutRef,
-): Promise<UTxO> {
-  const collectorUtxo: UTxO = matchSingle(
-    await lucid.utxosByOutRef([collectorOref]),
-    (_) => new Error('Expected a single collector UTXO'),
-  );
-
-  const collectorRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(params.scriptReferences.collectorValidatorRef),
-    ]),
-    (_) => new Error('Expected a single collector Ref Script UTXO'),
-  );
-
-  tx.collectFrom([collectorUtxo], serialiseCollectorRedeemer('Collect'))
-    .pay.ToContract(
-      collectorUtxo.address,
-      { kind: 'inline', value: Data.void() },
-      addAssets(collectorUtxo.assets, mkLovelacesOf(fee)),
-    )
-    .readFrom([collectorRefScriptUtxo]);
-
-  return collectorRefScriptUtxo;
-}

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

@@ -1,17 +0,0 @@
-import { TSchema, Data } from '@evolution-sdk/evolution';
-import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
-
-export const CollectorRedeemerSchema = TSchema.Union(
-  TSchema.Literal('Collect', { flatInUnion: true }),
-  TSchema.Literal('DistributeToStakers', { flatInUnion: true }),
-  TSchema.Literal('UpgradeVersion', { flatInUnion: true }),
-);
-
-export type CollectorRedeemer = typeof CollectorRedeemerSchema.Type;
-
-export function serialiseCollectorRedeemer(r: CollectorRedeemer): string {
-  return Data.withSchema(
-    CollectorRedeemerSchema,
-    DEFAULT_SCHEMA_OPTIONS,
-  ).toCBORHex(r);
-}

package/src/contracts/execute/scripts.ts

@@ -1,57 +0,0 @@
-import {
-  applyParamsToScript,
-  applySingleCborEncoding,
-  SpendingValidator,
-} from '@lucid-evolution/lucid';
-import { castExecuteParams, ExecuteParams } from './types';
-import {
-  ExecuteParamsSP,
-  fromSystemParamsAssetLucid,
-} from '../../types/system-params';
-import { _executeValidator } from '../../validators/execute-validator';
-
-export const mkExecuteValidator = (
-  params: ExecuteParams,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV3',
-    script: applySingleCborEncoding(
-      applyParamsToScript(_executeValidator.cborHex, [
-        castExecuteParams(params),
-      ]),
-    ),
-  };
-};
-
-export const mkExecuteValidatorFromSP = (
-  params: ExecuteParamsSP,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV3',
-    script: applySingleCborEncoding(
-      applyParamsToScript(_executeValidator.cborHex, [
-        castExecuteParams({
-          govNFT: fromSystemParamsAssetLucid(params.govNFT),
-          upgradeToken: fromSystemParamsAssetLucid(params.upgradeToken),
-          iAssetToken: fromSystemParamsAssetLucid(params.iAssetToken),
-          collateralAssetToken: fromSystemParamsAssetLucid(
-            params.collateralAssetToken,
-          ),
-          stabilityPoolToken: fromSystemParamsAssetLucid(
-            params.stabilityPoolToken,
-          ),
-          cdpCreatorToken: fromSystemParamsAssetLucid(params.cdpCreatorToken),
-          cdpToken: fromSystemParamsAssetLucid(params.cdpToken),
-          versionRecordToken: fromSystemParamsAssetLucid(
-            params.versionRecordToken,
-          ),
-          iassetValHash: params.iassetValHash,
-          cdpValHash: params.cdpValHash,
-          sPoolValHash: params.sPoolValHash,
-          versionRegistryValHash: params.versionRegistryValHash,
-          treasuryValHash: params.treasuryValHash,
-        }),
-      ]),
-    ),
-  };
-};

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

@@ -1,44 +0,0 @@
-import { option as O, function as F } from 'fp-ts';
-import { TSchema, Data } from '@evolution-sdk/evolution';
-import {
-  ProposalContentSchema,
-  TreasuryWithdrawalSchema,
-} from '../gov/types-new';
-import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
-
-const ExecuteDatumSchema = TSchema.Struct({
-  id: TSchema.Integer,
-  content: ProposalContentSchema,
-  passedTime: TSchema.Integer,
-  votingEndTime: TSchema.Integer,
-  protocolVersion: TSchema.Integer,
-  /// Value proposed to be withdrawn from the treasury as part of the proposal.
-  treasuryWithdrawal: TSchema.NullOr(TreasuryWithdrawalSchema),
-});
-
-export type ExecuteDatum = typeof ExecuteDatumSchema.Type;
-
-export function serialiseExecuteDatum(d: ExecuteDatum): string {
-  return Data.withSchema(ExecuteDatumSchema).toCBORHex(d);
-}
-
-export function parseExecuteDatum(datum: string): O.Option<ExecuteDatum> {
-  try {
-    return O.some(
-      Data.withSchema(ExecuteDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
-        datum,
-      ),
-    );
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parseExecuteDatumOrThrow(datum: string): ExecuteDatum {
-  return F.pipe(
-    parseExecuteDatum(datum),
-    O.match(() => {
-      throw new Error('Expected an Execute datum.');
-    }, F.identity),
-  );
-}