@indigo-labs/indigo-sdk 0.2.41 → 0.3.0

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

@@ -1,48 +1,84 @@
-import { Core as EvoCore } from '@evolution-sdk/evolution';
+import { TSchema, Data } from '@evolution-sdk/evolution';
 import { option as O, function as F } from 'fp-ts';
 import { match, P } from 'ts-pattern';
 import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
 
-const StakingPosLockedAmtSchema = EvoCore.TSchema.Map(
-  EvoCore.TSchema.Integer,
-  EvoCore.TSchema.Struct({
-    voteAmt: EvoCore.TSchema.Integer,
-    votingEnd: EvoCore.TSchema.Integer,
-  }),
+const StakingPosLockedAmtSchema = TSchema.Array(
+  TSchema.Tuple([
+    TSchema.Integer,
+    TSchema.Struct({
+      voteAmt: TSchema.Integer,
+      votingEnd: TSchema.Integer,
+    }),
+  ]),
 );
 
 export type StakingPosLockedAmt = typeof StakingPosLockedAmtSchema.Type;
 
-const RewardSnapshotSchema = EvoCore.TSchema.Struct({
-  snapshotAda: EvoCore.TSchema.Integer,
+const RewardSnapshotSchema = TSchema.Struct({
+  snapshotAda: TSchema.Integer,
 });
 
-const StakingPositionSchema = EvoCore.TSchema.Struct({
-  owner: EvoCore.TSchema.ByteArray,
+const StakingPositionSchema = TSchema.Struct({
+  owner: TSchema.ByteArray,
   lockedAmount: StakingPosLockedAmtSchema,
   positionSnapshot: RewardSnapshotSchema,
 });
 export type StakingPosition = typeof StakingPositionSchema.Type;
 
-const StakingManagerSchema = EvoCore.TSchema.Struct({
-  totalStake: EvoCore.TSchema.Integer,
+const StakingManagerSchema = TSchema.Struct({
+  totalStake: TSchema.Integer,
   managerSnapshot: RewardSnapshotSchema,
 });
 export type StakingManager = typeof StakingManagerSchema.Type;
 
-const StakingDatumSchema = EvoCore.TSchema.Union(
+const StakingDatumSchema = TSchema.Union(
   StakingManagerSchema,
   StakingPositionSchema,
 );
 type StakingDatum = typeof StakingDatumSchema.Type;
 
+const StakingRedeemerSchema = TSchema.Union(
+  TSchema.Struct(
+    {
+      CreateStakingPosition: TSchema.Struct(
+        { creatorPkh: TSchema.ByteArray },
+        { flatFields: true },
+      ),
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Literal('UpdateTotalStake', { flatInUnion: true }),
+  TSchema.Literal('Distribute', { flatInUnion: true }),
+  TSchema.Struct(
+    {
+      AdjustStakedAmount: TSchema.Struct(
+        { adjustAmount: TSchema.Integer },
+        { flatFields: true },
+      ),
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Literal('Unstake', { flatInUnion: true }),
+  TSchema.Literal('Lock', { flatInUnion: true }),
+  TSchema.Literal('UpgradeVersion', { flatInUnion: true }),
+);
+
+export type StakingRedeemer = typeof StakingRedeemerSchema.Type;
+
+export function serialiseStakingRedeemer(r: StakingRedeemer): string {
+  return Data.withSchema(
+    StakingRedeemerSchema,
+    DEFAULT_SCHEMA_OPTIONS,
+  ).toCBORHex(r);
+}
+
 export function parseStakingPosition(datum: string): O.Option<StakingPosition> {
   try {
     return match(
-      EvoCore.Data.withSchema(
-        StakingDatumSchema,
-        DEFAULT_SCHEMA_OPTIONS,
-      ).fromCBORHex(datum),
+      Data.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+        datum,
+      ),
     )
       .with({ owner: P.any }, (res) => O.some(res))
       .otherwise(() => O.none);
@@ -62,10 +98,9 @@ export function parseStakingPositionOrThrow(datum: string): StakingPosition {
 
 export function parseStakingManagerDatum(datum: string): StakingManager {
   return match(
-    EvoCore.Data.withSchema(
-      StakingDatumSchema,
-      DEFAULT_SCHEMA_OPTIONS,
-    ).fromCBORHex(datum),
+    Data.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+      datum,
+    ),
   )
     .with({ totalStake: P.any }, (res) => res)
     .otherwise(() => {
@@ -74,10 +109,7 @@ export function parseStakingManagerDatum(datum: string): StakingManager {
 }
 
 export function serialiseStakingDatum(d: StakingDatum): string {
-  const datum = EvoCore.Data.withSchema(
-    StakingDatumSchema,
-    DEFAULT_SCHEMA_OPTIONS,
-  ).toCBORHex(d);
-
-  return datum;
+  return Data.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).toCBORHex(
+    d,
+  );
 }

package/src/contracts/staking/types.ts

@@ -1,4 +1,4 @@
-import { Data, Redeemer } from '@lucid-evolution/lucid';
+import { Data } from '@lucid-evolution/lucid';
 import { AssetClassSchema } from '../../types/generic';
 
 const StakingParamsSchema = Data.Object({
@@ -12,33 +12,6 @@ const StakingParamsSchema = Data.Object({
 type StakingParams = Data.Static<typeof StakingParamsSchema>;
 const StakingParams = StakingParamsSchema as unknown as StakingParams;
 
-const StakingRedeemerSchema = Data.Enum([
-  Data.Object({
-    CreateStakingPosition: Data.Object({
-      creatorPkh: Data.Bytes(),
-    }),
-  }),
-  Data.Literal('UpdateTotalStake'),
-  Data.Literal('Distribute'),
-  Data.Object({
-    AdjustStakedAmount: Data.Object({
-      adjustAmount: Data.Integer(),
-    }),
-  }),
-  Data.Literal('Unstake'),
-  Data.Literal('Lock'),
-  Data.Literal('UpgradeVersion'),
-]);
-export type StakingRedeemer = Data.Static<typeof StakingRedeemerSchema>;
-const StakingRedeemer = StakingRedeemerSchema as unknown as StakingRedeemer;
-
-export function serialiseStakingRedeemer(redeemer: StakingRedeemer): Redeemer {
-  const rdmr = Data.to<StakingRedeemer>(redeemer, StakingRedeemer, {
-    canonical: false,
-  });
-  return rdmr;
-}
-
 export function castStakingParams(params: StakingParams): Data {
   return Data.castTo(params, StakingParams);
 }

package/src/contracts/treasury/helpers.ts

@@ -0,0 +1,21 @@
+import { Address, LucidEvolution } from '@lucid-evolution/lucid';
+import {
+  fromSysParamsCredential,
+  SystemParams,
+} from '../../types/system-params';
+import { createScriptAddress } from '../../utils/lucid-utils';
+
+export function mkTreasuryAddr(
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+): Address {
+  return createScriptAddress(
+    lucid.config().network!,
+    sysParams.validatorHashes.treasuryHash,
+    sysParams.treasuryParams.treasuryUtxosStakeCredential != null
+      ? fromSysParamsCredential(
+          sysParams.treasuryParams.treasuryUtxosStakeCredential,
+        )
+      : undefined,
+  );
+}

package/src/contracts/treasury/scripts.ts

@@ -1,37 +1,27 @@
+import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
 import {
-  applyParamsToScript,
-  Constr,
-  fromText,
-  SpendingValidator,
-} from '@lucid-evolution/lucid';
-import { TreasuryParamsSP } from '../../types/system-params';
+  fromSysParamsStakeCredential,
+  fromSystemParamsAssetLucid,
+  TreasuryParamsSP,
+} from '../../types/system-params';
 import { _treasuryValidator } from '../../validators/treasury-validator';
+import { castTreasuryParams } from './types';
 
 export const mkTreasuryValidatorFromSP = (
   params: TreasuryParamsSP,
 ): SpendingValidator => {
   return {
-    type: 'PlutusV2',
+    type: 'PlutusV3',
     script: applyParamsToScript(_treasuryValidator.cborHex, [
-      new Constr(0, [
-        new Constr(0, [
-          params.upgradeToken[0].unCurrencySymbol,
-          fromText(params.upgradeToken[1].unTokenName),
-        ]),
-        new Constr(0, [
-          params.versionRecordToken[0].unCurrencySymbol,
-          fromText(params.versionRecordToken[1].unTokenName),
-        ]),
-        params.treasuryUtxosStakeCredential
-          ? new Constr(0, [
-              new Constr(0, [
-                new Constr(1, [
-                  params.treasuryUtxosStakeCredential.contents.contents,
-                ]),
-              ]),
-            ])
-          : new Constr(1, []),
-      ]),
+      castTreasuryParams({
+        upgradeToken: fromSystemParamsAssetLucid(params.upgradeToken),
+        versionRecordToken: fromSystemParamsAssetLucid(
+          params.versionRecordToken,
+        ),
+        treasuryUtxosStakeCredential: params.treasuryUtxosStakeCredential
+          ? fromSysParamsStakeCredential(params.treasuryUtxosStakeCredential)
+          : null,
+      }),
     ]),
   };
 };

package/src/contracts/treasury/transactions.ts

@@ -1,36 +1,56 @@
 import {
   addAssets,
+  Assets,
   Data,
+  fromHex,
   LucidEvolution,
+  OutRef,
   TxBuilder,
+  UTxO,
 } from '@lucid-evolution/lucid';
 import {
-  fromSysParamsScriptCredential,
   fromSystemParamsScriptRef,
   SystemParams,
 } from '../../types/system-params';
 import { matchSingle } from '../../utils/utils';
-import { mkLovelacesOf } from '../../utils/value-helpers';
-import { serialiseTreasuryRedeemer } from './types';
 import {
-  createScriptAddress,
-  resolveUtxo,
-  UtxoOrOutRef,
-} from '../../utils/lucid-utils';
+  adaAssetClass,
+  AssetClass,
+  mkAssetsOf,
+  mkLovelacesOf,
+  negateAssets,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import { serialiseTreasuryDatum, serialiseTreasuryRedeemer } from './types-new';
+import { array as A, function as F } from 'fp-ts';
+import { parseExecuteDatumOrThrow } from '../execute/types-new';
+import { getInlineDatumOrThrow } from '../../utils/lucid-utils';
+import { createValueFromWithdrawal } from '../gov/helpers';
+import { mkTreasuryAddr } from './helpers';
 
 export async function treasuryFeeTx(
-  fee: bigint,
+  assetToPay: AssetClass,
+  amountToPay: bigint,
+  extraLovelaces: bigint,
   lucid: LucidEvolution,
   sysParams: SystemParams,
   tx: TxBuilder,
-  treasury: UtxoOrOutRef,
-): Promise<void> {
-  if (fee <= 0n) return;
+  actionOref: OutRef,
+  treasuryOref: OutRef,
+): Promise<UTxO | null> {
+  const [asset, amt, extraLov] = ((): [AssetClass, bigint, bigint] => {
+    if (amountToPay <= 0 && extraLovelaces > 0) {
+      return [adaAssetClass, extraLovelaces, 0n];
+    }
 
-  const treasuryUtxo = await resolveUtxo(
-    treasury,
-    lucid,
-    'Expected a single treasury UTXO',
+    return [assetToPay, amountToPay, extraLovelaces];
+  })();
+
+  // If no fee is to be collected, do not include treasury collection.
+  if (amt <= 0n) return null;
+
+  const treasuryUtxo = matchSingle(
+    await lucid.utxosByOutRef([treasuryOref]),
+    (_) => new Error('Expected a single treasury UTXO'),
   );
 
   const treasuryRefScriptUtxo = matchSingle(
@@ -42,21 +62,230 @@ export async function treasuryFeeTx(
     (_) => new Error('Expected a single treasury Ref Script UTXO'),
   );
 
-  const stakeCredential = sysParams.treasuryParams.treasuryUtxosStakeCredential
-    ? fromSysParamsScriptCredential(
-        sysParams.treasuryParams.treasuryUtxosStakeCredential,
-      )
-    : undefined;
-
   tx.readFrom([treasuryRefScriptUtxo])
-    .collectFrom([treasuryUtxo], serialiseTreasuryRedeemer('CollectAda'))
+    .collectFrom(
+      [treasuryUtxo],
+      serialiseTreasuryRedeemer({
+        Collect: {
+          assetToCollect: asset,
+          amountToCollect: amt,
+          extraLovelaces: extraLov,
+          actionInputOref: {
+            txHash: fromHex(actionOref.txHash),
+            outputIndex: BigInt(actionOref.outputIndex),
+          },
+        },
+      }),
+    )
+    .pay.ToContract(
+      mkTreasuryAddr(lucid, sysParams),
+      {
+        kind: 'inline',
+        value: serialiseTreasuryDatum({
+          treasuryInputOref: {
+            txHash: fromHex(treasuryOref.txHash),
+            outputIndex: BigInt(treasuryOref.outputIndex),
+          },
+          actionInputOref: {
+            txHash: fromHex(actionOref.txHash),
+            outputIndex: BigInt(actionOref.outputIndex),
+          },
+        }),
+      },
+      addAssets(
+        treasuryUtxo.assets,
+        mkAssetsOf(asset, amt),
+        mkLovelacesOf(extraLov),
+      ),
+    );
+
+  return treasuryRefScriptUtxo;
+}
+
+export async function treasuryCollect(
+  assetToPay: AssetClass,
+  amountToPay: bigint,
+  extraLovelaces: bigint,
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+  actionOref: OutRef,
+  treasuryOref: OutRef,
+): Promise<TxBuilder> {
+  const treasuryUtxo = matchSingle(
+    await lucid.utxosByOutRef([treasuryOref]),
+    (_) => new Error('Expected a single treasury UTXO'),
+  );
+
+  const treasuryRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.treasuryValidatorRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single treasury Ref Script UTXO'),
+  );
+
+  return lucid
+    .newTx()
+    .readFrom([treasuryRefScriptUtxo])
+    .collectFrom(
+      [treasuryUtxo],
+      serialiseTreasuryRedeemer({
+        Collect: {
+          assetToCollect: assetToPay,
+          amountToCollect: amountToPay,
+          extraLovelaces: extraLovelaces,
+          actionInputOref: {
+            txHash: fromHex(actionOref.txHash),
+            outputIndex: BigInt(actionOref.outputIndex),
+          },
+        },
+      }),
+    )
     .pay.ToContract(
-      createScriptAddress(
-        lucid.config().network!,
-        sysParams.validatorHashes.treasuryHash,
-        stakeCredential,
+      mkTreasuryAddr(lucid, sysParams),
+      {
+        kind: 'inline',
+        value: serialiseTreasuryDatum({
+          treasuryInputOref: {
+            txHash: fromHex(treasuryOref.txHash),
+            outputIndex: BigInt(treasuryOref.outputIndex),
+          },
+          actionInputOref: {
+            txHash: fromHex(actionOref.txHash),
+            outputIndex: BigInt(actionOref.outputIndex),
+          },
+        }),
+      },
+      addAssets(
+        treasuryUtxo.assets,
+        mkAssetsOf(assetToPay, amountToPay),
+        mkLovelacesOf(extraLovelaces),
+      ),
+    );
+}
+
+export async function treasuryMerge(
+  treasuryOutRefs: OutRef[],
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+): Promise<TxBuilder> {
+  const treasuryScriptRefUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.treasuryValidatorRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single treasury Ref Script UTXO'),
+  );
+
+  const treasuryUtxos = await lucid.utxosByOutRef(treasuryOutRefs);
+
+  const totalAssets = F.pipe(
+    treasuryUtxos,
+    A.reduce<UTxO, Assets>({}, (acc, utxo) => addAssets(acc, utxo.assets)),
+  );
+
+  return lucid
+    .newTx()
+    .readFrom([treasuryScriptRefUtxo])
+    .collectFrom(treasuryUtxos, serialiseTreasuryRedeemer('Merge'))
+    .pay.ToContract(
+      mkTreasuryAddr(lucid, sysParams),
+      { kind: 'inline', value: Data.void() },
+      totalAssets,
+    );
+}
+
+export async function treasurySplit(
+  treasuryOutRef: OutRef,
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+): Promise<TxBuilder> {
+  const treasuryScriptRefUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.treasuryValidatorRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single treasury Ref Script UTXO'),
+  );
+
+  const treasuryUtxo = matchSingle(
+    await lucid.utxosByOutRef([treasuryOutRef]),
+    (_) => new Error('Expected a single treasury UTXO'),
+  );
+
+  const assets = Object.keys(treasuryUtxo.assets);
+
+  const tx = lucid
+    .newTx()
+    .collectFrom([treasuryUtxo], serialiseTreasuryRedeemer('Split'))
+    .readFrom([treasuryScriptRefUtxo]);
+
+  for (const asset of assets) {
+    tx.pay.ToContract(
+      mkTreasuryAddr(lucid, sysParams),
+      { kind: 'inline', value: Data.void() },
+      { [asset]: treasuryUtxo.assets[asset] },
+    );
+  }
+
+  return tx;
+}
+
+export async function treasuryPrepareWithdrawal(
+  treasuryOutRefs: OutRef[],
+  upgradeOutRef: OutRef,
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+): Promise<TxBuilder> {
+  const treasuryScriptRefUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.treasuryValidatorRef,
       ),
+    ]),
+    (_) => new Error('Expected a single treasury Ref Script UTXO'),
+  );
+
+  const treasuryUtxos = await lucid.utxosByOutRef(treasuryOutRefs);
+
+  const upgradeUtxo = matchSingle(
+    await lucid.utxosByOutRef([upgradeOutRef]),
+    (_) => new Error('Expected a single upgrade UTXO'),
+  );
+
+  const treasuryAddress = mkTreasuryAddr(lucid, sysParams);
+
+  const totalAssets = F.pipe(
+    treasuryUtxos,
+    A.reduce<UTxO, Assets>({}, (acc, utxo) => addAssets(acc, utxo.assets)),
+  );
+  const executeDatum = parseExecuteDatumOrThrow(
+    getInlineDatumOrThrow(upgradeUtxo),
+  );
+  if (!executeDatum.treasuryWithdrawal)
+    throw new Error('Expected a treasury withdrawal in the execute datum');
+  const withdrawalVal = createValueFromWithdrawal(
+    executeDatum.treasuryWithdrawal,
+  );
+  const change = addAssets(totalAssets, negateAssets(withdrawalVal));
+
+  const tx = lucid
+    .newTx()
+    .collectFrom(treasuryUtxos, serialiseTreasuryRedeemer('PrepareWithdraw'))
+    .readFrom([treasuryScriptRefUtxo, upgradeUtxo])
+    .pay.ToContract(
+      treasuryAddress,
       { kind: 'inline', value: Data.void() },
-      addAssets(treasuryUtxo.assets, mkLovelacesOf(fee)),
+      withdrawalVal,
+    )
+    .pay.ToContract(
+      treasuryAddress,
+      { kind: 'inline', value: Data.void() },
+      change,
     );
+
+  return tx;
 }

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

@@ -0,0 +1,69 @@
+import { TSchema, Data } from '@evolution-sdk/evolution';
+import {
+  AssetClassSchema,
+  OutputReferenceSchema,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
+
+const WithdrawalOutputDatumSchema = TSchema.Tuple([
+  TSchema.ByteArray,
+  OutputReferenceSchema,
+]);
+
+export type WithdrawalOutputDatum = typeof WithdrawalOutputDatumSchema.Type;
+
+const TreasuryDatumSchema = TSchema.Struct(
+  {
+    treasuryInputOref: OutputReferenceSchema,
+    actionInputOref: OutputReferenceSchema,
+  },
+  { flatFields: true },
+);
+
+export type TreasuryDatum = typeof TreasuryDatumSchema.Type;
+
+const TreasuryRedeemerSchema = TSchema.Union(
+  TSchema.Literal('Withdraw', { flatInUnion: true }),
+  TSchema.Literal('PrepareWithdraw', { flatInUnion: true }),
+  TSchema.Literal('Split', { flatInUnion: true }),
+  TSchema.Literal('Merge', { flatInUnion: true }),
+  TSchema.Struct(
+    {
+      Collect: TSchema.Struct(
+        {
+          assetToCollect: AssetClassSchema,
+          amountToCollect: TSchema.Integer,
+          extraLovelaces: TSchema.Integer,
+          actionInputOref: OutputReferenceSchema,
+        },
+        { flatFields: true },
+      ),
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Literal('UpgradeVersion', { flatInUnion: true }),
+);
+
+export type TreasuryRedeemer = typeof TreasuryRedeemerSchema.Type;
+
+export function serialiseTreasuryRedeemer(r: TreasuryRedeemer): string {
+  return Data.withSchema(
+    TreasuryRedeemerSchema,
+    DEFAULT_SCHEMA_OPTIONS,
+  ).toCBORHex(r);
+}
+
+export function serialiseWithdrawalOutputDatum(
+  d: WithdrawalOutputDatum,
+): string {
+  return Data.withSchema(
+    WithdrawalOutputDatumSchema,
+    DEFAULT_SCHEMA_OPTIONS,
+  ).toCBORHex(d);
+}
+
+export function serialiseTreasuryDatum(d: TreasuryDatum): string {
+  return Data.withSchema(TreasuryDatumSchema, DEFAULT_SCHEMA_OPTIONS).toCBORHex(
+    d,
+  );
+}

package/src/contracts/treasury/types.ts

@@ -1,9 +1,5 @@
-import { Data, Datum, Redeemer } from '@lucid-evolution/lucid';
-import {
-  AssetClassSchema,
-  OutputReferenceSchema,
-  StakeCredentialSchema,
-} from '../../types/generic';
+import { Data } from '@lucid-evolution/lucid';
+import { AssetClassSchema, StakeCredentialSchema } from '../../types/generic';
 
 export const TreasuryParamsSchema = Data.Object({
   upgradeToken: AssetClassSchema,
@@ -13,43 +9,6 @@ export const TreasuryParamsSchema = Data.Object({
 export type TreasuryParams = Data.Static<typeof TreasuryParamsSchema>;
 export const TreasuryParams = TreasuryParamsSchema as unknown as TreasuryParams;
 
-const TreasuryRedeemerSchema = Data.Enum([
-  Data.Literal('Withdraw'),
-  Data.Literal('PrepareWithdraw'),
-  Data.Literal('Split'),
-  Data.Literal('Merge'),
-  Data.Literal('CollectAda'),
-  Data.Literal('UpgradeVersion'),
-]);
-export type TreasuryRedeemer = Data.Static<typeof TreasuryRedeemerSchema>;
-const TreasuryRedeemer = TreasuryRedeemerSchema as unknown as TreasuryRedeemer;
-
-const WithdrawalOutputDatumSchema = Data.Tuple([
-  Data.Bytes(),
-  OutputReferenceSchema,
-]);
-export type WithdrawalOutputDatum = Data.Static<
-  typeof WithdrawalOutputDatumSchema
->;
-const WithdrawalOutputDatum =
-  WithdrawalOutputDatumSchema as unknown as WithdrawalOutputDatum;
-
-export function serialiseWithdrawalOutputDatum(
-  d: WithdrawalOutputDatum,
-): Datum {
-  return Data.to<WithdrawalOutputDatum>(d, WithdrawalOutputDatum);
-}
-
-export function serialiseTreasuryRedeemer(
-  redeemer: TreasuryRedeemer,
-): Redeemer {
-  return Data.to<TreasuryRedeemer>(redeemer, TreasuryRedeemer);
-}
-
-export function serialiseTreasuryDatum(): Datum {
-  return Data.void();
-}
-
 export function castTreasuryParams(params: TreasuryParams): Data {
   return Data.castTo(params, TreasuryParams);
 }