@indigo-labs/indigo-sdk 0.2.42 → 0.3.0

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

@@ -0,0 +1,256 @@
+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 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,161 +1,43 @@
-import { Data, Datum, Redeemer, UTxO } from '@lucid-evolution/lucid';
-import { AssetClassSchema, OutputReferenceSchema } from '../../types/generic';
-import { OnChainDecimalSchema } from '../../types/on-chain-decimal';
-import { OracleAssetNftSchema } from '../price-oracle/types';
-import { match, P } from 'ts-pattern';
-import { option as O, function as F } from 'fp-ts';
+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,
-  version_record_token: AssetClassSchema,
   upgrade_token: AssetClassSchema,
-  collector_val_hash: Data.Bytes(),
+  version_record_token: AssetClassSchema,
+  interest_collector_val_hash: Data.Bytes(),
   sp_val_hash: Data.Bytes(),
-  gov_nft: AssetClassSchema,
-  min_collateral_in_lovelace: Data.Integer(),
-  partial_redemption_extra_fee_lovelace: Data.Integer(),
-  bias_time: Data.Integer(),
+  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 const CDPFeesSchema = Data.Enum([
-  Data.Object({
-    ActiveCDPInterestTracking: Data.Object({
-      lastSettled: Data.Integer(),
-      unitaryInterestSnapshot: Data.Integer(),
-    }),
-  }),
-  Data.Object({
-    FrozenCDPAccumulatedFees: Data.Object({
-      lovelacesTreasury: Data.Integer(),
-      lovelacesIndyStakers: Data.Integer(),
-    }),
-  }),
-]);
-
-export const CDPContentSchema = Data.Object({
-  cdpOwner: Data.Nullable(Data.Bytes()),
-  iasset: Data.Bytes(),
-  mintedAmt: Data.Integer(),
-  cdpFees: CDPFeesSchema,
-});
-
-export const IAssetPriceInfoSchema = Data.Enum([
-  Data.Object({
-    Delisted: Data.Object({ content: OnChainDecimalSchema }),
-  }),
-  Data.Object({
-    Oracle: Data.Object({ content: OracleAssetNftSchema }),
-  }),
-]);
-
-export const IAssetContentSchema = Data.Object({
-  /** Use the HEX encoding */
-  assetName: Data.Bytes(),
-  price: IAssetPriceInfoSchema,
-  interestOracleNft: AssetClassSchema,
-  redemptionRatio: OnChainDecimalSchema,
-  maintenanceRatio: OnChainDecimalSchema,
-  liquidationRatio: OnChainDecimalSchema,
-  debtMintingFeePercentage: OnChainDecimalSchema,
-  liquidationProcessingFeePercentage: OnChainDecimalSchema,
-  stabilityPoolWithdrawalFeePercentage: OnChainDecimalSchema,
-  redemptionReimbursementPercentage: OnChainDecimalSchema,
-  redemptionProcessingFeePercentage: OnChainDecimalSchema,
-  interestCollectorPortionPercentage: OnChainDecimalSchema,
-  firstIAsset: Data.Boolean(),
-  nextIAsset: Data.Nullable(Data.Bytes()),
-});
-
-export const CDPDatumSchema = Data.Enum([
-  Data.Object({ CDP: Data.Object({ content: CDPContentSchema }) }),
-  Data.Object({ IAsset: Data.Object({ content: IAssetContentSchema }) }),
-]);
-
-export type CDPFees = Data.Static<typeof CDPFeesSchema>;
-export type CDPDatum = Data.Static<typeof CDPDatumSchema>;
-const CDPDatum = CDPDatumSchema as unknown as CDPDatum;
-
-export type CDPContent = Data.Static<typeof CDPContentSchema>;
-const CDPContent = CDPContentSchema as unknown as CDPContent;
-export type IAssetContent = Data.Static<typeof IAssetContentSchema>;
-const IAssetContent = IAssetContentSchema as unknown as IAssetContent;
-
-const CDPRedeemerSchema = Data.Enum([
-  Data.Object({
-    AdjustCdp: Data.Object({
-      currentTime: Data.Integer(),
-      mintedAmtChange: Data.Integer(),
-      collateralAmtChange: Data.Integer(),
-    }),
-  }),
-  Data.Object({ CloseCdp: Data.Object({ currentTime: Data.Integer() }) }),
-  Data.Object({ RedeemCdp: Data.Object({ currentTime: Data.Integer() }) }),
-  Data.Object({ FreezeCdp: Data.Object({ currentTime: Data.Integer() }) }),
-  Data.Literal('MergeCdps'),
-  Data.Object({
-    MergeAuxiliary: Data.Object({ mainMergeUtxo: OutputReferenceSchema }),
-  }),
-  Data.Literal('Liquidate'),
-  Data.Literal('UpdateOrInsertAsset'),
-  Data.Literal('UpgradeVersion'),
-]);
-export type CDPRedeemer = Data.Static<typeof CDPRedeemerSchema>;
-const CDPRedeemer = CDPRedeemerSchema as unknown as CDPRedeemer;
-
-export function serialiseCdpRedeemer(r: CDPRedeemer): Redeemer {
-  return Data.to<CDPRedeemer>(r, CDPRedeemer, { canonical: false });
-}
-
-export function parseCdpDatum(datum: Datum): O.Option<CDPContent> {
-  return match(Data.from<CDPDatum>(datum, CDPDatum))
-    .with({ CDP: { content: P.select() } }, (res) => O.some(res))
-    .otherwise(() => O.none);
-}
-
-export function parseCdpDatumOrThrow(datum: Datum): CDPContent {
-  return F.pipe(
-    parseCdpDatum(datum),
-    O.match(() => {
-      throw new Error('Expected a CDP datum.');
-    }, F.identity),
-  );
-}
-
-export function serialiseCdpDatum(cdpDatum: CDPContent): Datum {
-  return Data.to<CDPDatum>({ CDP: { content: cdpDatum } }, CDPDatum);
-}
-
-export function parseIAssetDatum(datum: Datum): O.Option<IAssetContent> {
-  try {
-    return match(Data.from<CDPDatum>(datum, CDPDatum))
-      .with({ IAsset: { content: P.select() } }, (res) => O.some(res))
-      .otherwise(() => O.none);
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parseIAssetDatumOrThrow(datum: Datum): IAssetContent {
-  return F.pipe(
-    parseIAssetDatum(datum),
-    O.match(() => {
-      throw new Error('Expected an IAsset datum.');
-    }, F.identity),
-  );
-}
-
-export function serialiseIAssetDatum(iassetDatum: IAssetContent): Datum {
-  return Data.to<CDPDatum>({ IAsset: { content: iassetDatum } }, CDPDatum);
-}
-
 export function castCdpParams(params: CdpParams): Data {
   return Data.castTo(params, CdpParams);
 }
 
-export type IAssetOutput = { datum: IAssetContent; utxo: UTxO };
+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/scripts.ts

@@ -2,7 +2,7 @@ import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
 import { castCDPCreatorParams, CDPCreatorParams } from './types';
 import {
   CDPCreatorParamsSP,
-  fromSystemParamsAsset,
+  fromSystemParamsAssetLucid,
 } from '../../types/system-params';
 import { _cdpCreatorValidator } from '../../validators/cdp-creator-validator';
 
@@ -10,7 +10,7 @@ export const mkCDPCreatorValidator = (
   params: CDPCreatorParams,
 ): SpendingValidator => {
   return {
-    type: 'PlutusV2',
+    type: 'PlutusV3',
     script: applyParamsToScript(_cdpCreatorValidator.cborHex, [
       castCDPCreatorParams(params),
     ]),
@@ -21,17 +21,23 @@ export const mkCDPCreatorValidatorFromSP = (
   params: CDPCreatorParamsSP,
 ): SpendingValidator => {
   return {
-    type: 'PlutusV2',
+    type: 'PlutusV3',
     script: applyParamsToScript(_cdpCreatorValidator.cborHex, [
       castCDPCreatorParams({
-        cdpCreatorNft: fromSystemParamsAsset(params.cdpCreatorNft),
+        cdpCreatorNft: fromSystemParamsAssetLucid(params.cdpCreatorNft),
         cdpAssetCs: params.cdpAssetCs.unCurrencySymbol,
-        cdpAuthTk: fromSystemParamsAsset(params.cdpAuthTk),
-        iAssetAuthTk: fromSystemParamsAsset(params.iAssetAuthTk),
-        versionRecordToken: fromSystemParamsAsset(params.versionRecordToken),
+        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,
-        collectorValHash: params.collectorValHash,
-        minCollateralInLovelace: BigInt(params.minCollateralInLovelace),
+        treasuryValHash: params.treasuryValHash,
         biasTime: BigInt(params.biasTime),
       }),
     ]),

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

@@ -0,0 +1,50 @@
+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,4 +1,4 @@
-import { Data, Datum, Redeemer } from '@lucid-evolution/lucid';
+import { Data } from '@lucid-evolution/lucid';
 import { AssetClassSchema } from '../../types/generic';
 
 const CDPCreatorParamsSchema = Data.Object({
@@ -6,10 +6,12 @@ const CDPCreatorParamsSchema = Data.Object({
   cdpAssetCs: Data.Bytes(),
   cdpAuthTk: AssetClassSchema,
   iAssetAuthTk: AssetClassSchema,
+  collateralAssetAuthTk: AssetClassSchema,
+  upgradeToken: AssetClassSchema,
   versionRecordToken: AssetClassSchema,
   cdpScriptHash: Data.Bytes(),
-  collectorValHash: Data.Bytes(),
-  minCollateralInLovelace: Data.Integer(),
+  treasuryValHash: Data.Bytes(),
+  iassetValHash: Data.Bytes(),
   biasTime: Data.Integer(),
 });
 
@@ -20,31 +22,3 @@ export const CDPCreatorParams =
 export function castCDPCreatorParams(params: CDPCreatorParams): Data {
   return Data.castTo(params, CDPCreatorParams);
 }
-
-const CDPCreatorRedeemerSchema = Data.Enum([
-  Data.Object({
-    CreateCDP: Data.Object({
-      cdpOwner: Data.Bytes(),
-      minted: Data.Integer(),
-      collateral: Data.Integer(),
-      currentTime: Data.Integer(),
-    }),
-  }),
-  Data.Object({ UpgradeCreatorVersion: Data.Object({}) }),
-]);
-
-export type CDPCreatorRedeemer = Data.Static<typeof CDPCreatorRedeemerSchema>;
-export const CDPCreatorRedeemer =
-  CDPCreatorRedeemerSchema as unknown as CDPCreatorRedeemer;
-
-export function serialiseCDPCreatorRedeemer(
-  params: CDPCreatorRedeemer,
-): Redeemer {
-  return Data.to<CDPCreatorRedeemer>(params, CDPCreatorRedeemer, {
-    canonical: false,
-  });
-}
-
-export function serialiseCDPCreatorDatum(): Datum {
-  return Data.void();
-}

package/src/contracts/collector/scripts.ts

@@ -11,7 +11,7 @@ export const mkCollectorValidatorFromSP = (
   params: CollectorParamsSP,
 ): SpendingValidator => {
   return {
-    type: 'PlutusV2',
+    type: 'PlutusV3',
     script: applyParamsToScript(_collectorValidator.cborHex, [
       new Constr(0, [
         new Constr(0, [

package/src/contracts/collector/transactions.ts

@@ -1,23 +1,34 @@
-import { Data, LucidEvolution, TxBuilder, UTxO } from '@lucid-evolution/lucid';
+import {
+  addAssets,
+  Data,
+  LucidEvolution,
+  OutRef,
+  TxBuilder,
+  UTxO,
+} from '@lucid-evolution/lucid';
 import {
   fromSystemParamsScriptRef,
   SystemParams,
 } from '../../types/system-params';
 import { matchSingle } from '../../utils/utils';
-import { resolveUtxo, UtxoOrOutRef } from '../../utils/lucid-utils';
-import { serialiseCollectorRedeemer } from './types';
+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,
-  collector: UtxoOrOutRef,
-): Promise<void> {
-  const collectorUtxo: UTxO = await resolveUtxo(
-    collector,
-    lucid,
-    'Expected a single collector UTXO',
+  collectorOref: OutRef,
+): Promise<UTxO> {
+  const collectorUtxo: UTxO = matchSingle(
+    await lucid.utxosByOutRef([collectorOref]),
+    (_) => new Error('Expected a single collector UTXO'),
   );
 
   const collectorRefScriptUtxo = matchSingle(
@@ -31,10 +42,9 @@ export async function collectorFeeTx(
     .pay.ToContract(
       collectorUtxo.address,
       { kind: 'inline', value: Data.void() },
-      {
-        ...collectorUtxo.assets,
-        lovelace: collectorUtxo.assets.lovelace + fee,
-      },
+      addAssets(collectorUtxo.assets, mkLovelacesOf(fee)),
     )
     .readFrom([collectorRefScriptUtxo]);
+
+  return collectorRefScriptUtxo;
 }

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

@@ -0,0 +1,17 @@
+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);
+}