@indigo-labs/indigo-sdk 0.2.42 → 0.3.1

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

@@ -0,0 +1,131 @@
+import {
+  AddressSchema,
+  AssetClassSchema,
+  OutputReferenceSchema,
+} from '@3rd-eye-labs/cardano-offchain-common';
+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 { Schema } from 'effect';
+import { RationalSchema } from '../../types/rational';
+
+const OpaqueData = Schema.typeSchema(Data.DataSchema);
+
+export const StableswapOrderDatumSchema = TSchema.Struct({
+  iasset: TSchema.ByteArray,
+  collateralAsset: AssetClassSchema,
+  owner: TSchema.ByteArray,
+  destination: AddressSchema,
+  destinationInlineDatum: TSchema.NullOr(OpaqueData),
+  maxExecutionFee: TSchema.Integer,
+  maxFeeRatio: RationalSchema,
+});
+export type StableswapOrderDatum = typeof StableswapOrderDatumSchema.Type;
+
+const StableswapOrderRedeemerSchema = TSchema.Union(
+  TSchema.Literal('BatchProcessStableswapOrders', { flatInUnion: true }),
+  TSchema.Struct(
+    {
+      BatchAuxiliary: TSchema.Struct(
+        {
+          ownInputIndex: TSchema.Integer,
+          mainOrderInputIndex: TSchema.Integer,
+        },
+        { flatFields: true },
+      ),
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Literal('CancelStableswapOrder', { flatInUnion: true }),
+  TSchema.Literal('UpdateFees', { flatInUnion: true }),
+  TSchema.Literal('UpgradeVersion', { flatInUnion: true }),
+);
+
+export type StableswapOrderRedeemer = typeof StableswapOrderRedeemerSchema.Type;
+
+/**
+ * This is used when order does not require any specific output datum.
+ */
+const StableswapOutputDatumSchema = TSchema.Tuple([
+  TSchema.ByteArray,
+  OutputReferenceSchema,
+]);
+
+export type StableswapOutputDatum = typeof StableswapOutputDatumSchema.Type;
+
+export function serialiseStableswapOrderDatum(d: StableswapOrderDatum): string {
+  return Data.withSchema(
+    StableswapOrderDatumSchema,
+    DEFAULT_SCHEMA_OPTIONS,
+  ).toCBORHex(d);
+}
+
+export function parseStableswapOrderDatum(
+  datum: string,
+): O.Option<StableswapOrderDatum> {
+  try {
+    return O.some(
+      Data.withSchema(
+        StableswapOrderDatumSchema,
+        DEFAULT_SCHEMA_OPTIONS,
+      ).fromCBORHex(datum),
+    );
+  } catch (_) {
+    return O.none;
+  }
+}
+
+export function parseStableswapOrderDatumOrThrow(
+  datum: string,
+): StableswapOrderDatum {
+  return F.pipe(
+    parseStableswapOrderDatum(datum),
+    O.match(() => {
+      throw new Error('Expected a Stableswap Order datum.');
+    }, F.identity),
+  );
+}
+
+export function serialiseStableswapOutputDatum(
+  d: StableswapOutputDatum,
+): string {
+  return Data.withSchema(
+    StableswapOutputDatumSchema,
+    DEFAULT_SCHEMA_OPTIONS,
+  ).toCBORHex(d);
+}
+
+export function serialiseStableswapOrderRedeemer(
+  r: StableswapOrderRedeemer,
+): string {
+  return Data.withSchema(
+    StableswapOrderRedeemerSchema,
+    DEFAULT_SCHEMA_OPTIONS,
+  ).toCBORHex(r);
+}
+
+export function parseStableswapOrderRedeemer(
+  redeemerCborHex: string,
+): O.Option<StableswapOrderRedeemer> {
+  try {
+    return O.some(
+      Data.withSchema(
+        StableswapOrderRedeemerSchema,
+        DEFAULT_SCHEMA_OPTIONS,
+      ).fromCBORHex(redeemerCborHex),
+    );
+  } catch (_) {
+    return O.none;
+  }
+}
+
+export function parseStableswapOrderRedeemerOrThrow(
+  redeemerCborHex: string,
+): StableswapOrderRedeemer {
+  return F.pipe(
+    parseStableswapOrderRedeemer(redeemerCborHex),
+    O.match(() => {
+      throw new Error('Expected a Stableswap Order redeemer.');
+    }, F.identity),
+  );
+}

package/src/contracts/stableswap/types.ts

@@ -0,0 +1,17 @@
+import { Data } from '@lucid-evolution/lucid';
+import { AssetClassSchema } from '../../types/generic';
+
+const StableswapParamsSchema = Data.Object({
+  iassetSymbol: Data.Bytes(),
+  cdpToken: AssetClassSchema,
+  versionRecordToken: AssetClassSchema,
+  cdpValHash: Data.Bytes(),
+  treasuryValHash: Data.Bytes(),
+});
+export type StableswapParams = Data.Static<typeof StableswapParamsSchema>;
+export const StableswapParams =
+  StableswapParamsSchema as unknown as StableswapParams;
+
+export function castStableswapParams(params: StableswapParams): Data {
+  return Data.castTo(params, StableswapParams);
+}

package/src/contracts/staking/helpers.ts

@@ -1,4 +1,9 @@
-import { fromText, UTxO, validatorToScriptHash } from '@lucid-evolution/lucid';
+import {
+  fromText,
+  OutRef,
+  UTxO,
+  validatorToScriptHash,
+} from '@lucid-evolution/lucid';
 import { LucidEvolution } from '@lucid-evolution/lucid';
 import { SystemParams } from '../../types/system-params';
 import {
@@ -8,11 +13,7 @@ import {
   StakingPosition,
   StakingPosLockedAmt,
 } from './types-new';
-import {
-  createScriptAddress,
-  resolveUtxo,
-  UtxoOrOutRef,
-} from '../../utils/lucid-utils';
+import { createScriptAddress } from '../../utils/lucid-utils';
 import { mkStakingValidatorFromSP } from './scripts';
 import { OCD_DECIMAL_UNIT } from '../../types/on-chain-decimal';
 
@@ -29,27 +30,33 @@ export function updateStakingLockedAmount(
   stakingPosLockedAmt: StakingPosLockedAmt,
   currentTime: bigint,
 ): StakingPosLockedAmt {
-  return new Map(
-    stakingPosLockedAmt
-      .entries()
-      .filter(([_, { votingEnd }]) => votingEnd > currentTime),
+  return stakingPosLockedAmt.filter(
+    ([_, { votingEnd }]) => votingEnd > currentTime,
   );
 }
 
-export async function findStakingManagerByOutRef(
-  stakingManager: UtxoOrOutRef,
+export function findStakingManagerByOutRef(
+  stakingManagerRef: OutRef,
   lucid: LucidEvolution,
 ): Promise<StakingManagerOutput> {
-  const utxo = await resolveUtxo(
-    stakingManager,
-    lucid,
-    'Unable to locate Staking Manager by output reference.',
-  );
-  if (!utxo.datum) {
-    throw new Error('Staking Manager UTxO has no datum.');
-  }
-  const datum = parseStakingManagerDatum(utxo.datum);
-  return { utxo, datum };
+  return lucid
+    .utxosByOutRef([stakingManagerRef])
+    .then((utxos) =>
+      utxos
+        .map((utxo) => {
+          if (!utxo.datum) return undefined;
+          const datum = parseStakingManagerDatum(utxo.datum);
+          return { utxo, datum };
+        })
+        .find((utxo) => utxo !== undefined),
+    )
+    .then((result) => {
+      if (!result)
+        throw new Error(
+          'Unable to locate Staking Manager by output reference.',
+        );
+      return result;
+    });
 }
 
 export function findStakingManager(
@@ -83,20 +90,28 @@ export function findStakingManager(
     });
 }
 
-export async function findStakingPositionByOutRef(
-  stakingPosition: UtxoOrOutRef,
+export function findStakingPositionByOutRef(
+  stakingPositionRef: OutRef,
   lucid: LucidEvolution,
 ): Promise<StakingPositionOutput> {
-  const utxo = await resolveUtxo(
-    stakingPosition,
-    lucid,
-    'Unable to locate Staking Position by output reference.',
-  );
-  if (!utxo.datum) {
-    throw new Error('Staking Position UTxO has no datum.');
-  }
-  const datum = parseStakingPositionOrThrow(utxo.datum);
-  return { utxo, datum };
+  return lucid
+    .utxosByOutRef([stakingPositionRef])
+    .then((utxos) =>
+      utxos
+        .map((utxo) => {
+          if (!utxo.datum) return undefined;
+          const datum = parseStakingPositionOrThrow(utxo.datum);
+          return { utxo, datum };
+        })
+        .find((utxo) => utxo !== undefined),
+    )
+    .then((result) => {
+      if (!result)
+        throw new Error(
+          'Unable to locate Staking Position by output reference.',
+        );
+      return result;
+    });
 }
 
 export const rewardSnapshotPrecision = OCD_DECIMAL_UNIT * OCD_DECIMAL_UNIT;

package/src/contracts/staking/scripts.ts

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

package/src/contracts/staking/transactions.ts

@@ -10,49 +10,46 @@ import {
   TxBuilder,
 } from '@lucid-evolution/lucid';
 import {
+  fromSystemParamsAsset,
   fromSystemParamsScriptRef,
   SystemParams,
 } from '../../types/system-params';
+import { addrDetails } from '../../utils/lucid-utils';
 import {
-  addrDetails,
-  getInlineDatumOrThrow,
-  resolveUtxo,
-  UtxoOrOutRef,
-} from '../../utils/lucid-utils';
-import {
+  calculateAdaReward,
   distributeReward,
-  rewardSnapshotPrecision,
+  findStakingManager,
+  findStakingManagerByOutRef,
+  findStakingPositionByOutRef,
   updateStakingLockedAmount,
 } from './helpers';
 import {
   parseStakingManagerDatum,
-  parseStakingPositionOrThrow,
   serialiseStakingDatum,
+  serialiseStakingRedeemer,
   StakingManager,
   StakingPosition,
 } from './types-new';
 import { matchSingle } from '../../utils/utils';
-import { serialiseStakingRedeemer } from './types';
-import { serialiseCollectorRedeemer } from '../collector/types';
-import { mkAssetsOf, mkLovelacesOf } from '../../utils/value-helpers';
-import { ONE_SECOND } from '../../utils/time-helpers';
+import { serialiseCollectorRedeemer } from '../collector/types-new';
+import {
+  assetClassValueOf,
+  getInlineDatumOrThrow,
+  mkAssetsOf,
+  mkLovelacesOf,
+} from '@3rd-eye-labs/cardano-offchain-common';
 
 export async function openStakingPosition(
   amount: bigint,
   params: SystemParams,
   lucid: LucidEvolution,
-  stakingManager: UtxoOrOutRef,
+  stakingManagerRef?: OutRef,
 ): Promise<TxBuilder> {
   const [pkh, _] = await addrDetails(lucid);
 
-  const stakingManagerUtxo = await resolveUtxo(
-    stakingManager,
-    lucid,
-    'Expected a single staking manager UTXO',
-  );
-  const stakingManagerDatum = parseStakingManagerDatum(
-    getInlineDatumOrThrow(stakingManagerUtxo),
-  );
+  const stakingManagerOut = stakingManagerRef
+    ? await findStakingManagerByOutRef(stakingManagerRef, lucid)
+    : await findStakingManager(params, lucid);
 
   const stakingRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -70,17 +67,17 @@ export async function openStakingPosition(
   );
 
   const newStakingManagerDatum: StakingManager = {
-    totalStake: stakingManagerDatum.totalStake + amount,
+    totalStake: stakingManagerOut.datum.totalStake + amount,
     managerSnapshot: {
-      snapshotAda: stakingManagerDatum.managerSnapshot.snapshotAda,
+      snapshotAda: stakingManagerOut.datum.managerSnapshot.snapshotAda,
     },
   };
 
   const stakingPositionDatum: StakingPosition = {
     owner: fromHex(pkh.hash),
-    lockedAmount: new Map([]),
+    lockedAmount: [],
     positionSnapshot: {
-      snapshotAda: stakingManagerDatum.managerSnapshot.snapshotAda,
+      snapshotAda: stakingManagerOut.datum.managerSnapshot.snapshotAda,
     },
   };
 
@@ -93,19 +90,19 @@ export async function openStakingPosition(
   return lucid
     .newTx()
     .collectFrom(
-      [stakingManagerUtxo],
+      [stakingManagerOut.utxo],
       serialiseStakingRedeemer({
-        CreateStakingPosition: { creatorPkh: pkh.hash },
+        CreateStakingPosition: { creatorPkh: fromHex(pkh.hash) },
       }),
     )
     .readFrom([stakingRefScriptUtxo])
     .pay.ToContract(
-      stakingManagerUtxo.address,
+      stakingManagerOut.utxo.address,
       {
         kind: 'inline',
         value: serialiseStakingDatum(newStakingManagerDatum),
       },
-      stakingManagerUtxo.assets,
+      stakingManagerOut.utxo.assets,
     )
     .readFrom([stakingTokenPolicyRefScriptUtxo])
     .mintAssets(
@@ -115,7 +112,7 @@ export async function openStakingPosition(
       Data.void(),
     )
     .pay.ToContract(
-      stakingManagerUtxo.address,
+      stakingManagerOut.utxo.address,
       {
         kind: 'inline',
         value: serialiseStakingDatum(stakingPositionDatum),
@@ -129,33 +126,23 @@ export async function openStakingPosition(
 }
 
 export async function adjustStakingPosition(
-  stakingPosition: UtxoOrOutRef,
+  stakingPositionRef: OutRef,
   amount: bigint,
   params: SystemParams,
   lucid: LucidEvolution,
   currentSlot: number,
-  stakingManager: UtxoOrOutRef,
+  stakingManagerRef?: OutRef,
 ): Promise<TxBuilder> {
   const network = lucid.config().network!;
-  const currentTime = slotToUnixTime(network, currentSlot) - 120 * ONE_SECOND;
-
-  const stakingPositionUtxo = await resolveUtxo(
-    stakingPosition,
-    lucid,
-    'Expected a single staking position UTXO',
-  );
-  const stakingPositionDatum = parseStakingPositionOrThrow(
-    getInlineDatumOrThrow(stakingPositionUtxo),
-  );
+  const now = BigInt(slotToUnixTime(network, currentSlot));
 
-  const stakingManagerUtxo = await resolveUtxo(
-    stakingManager,
+  const stakingPositionOut = await findStakingPositionByOutRef(
+    stakingPositionRef,
     lucid,
-    'Expected a single staking manager UTXO',
-  );
-  const stakingManagerDatum = parseStakingManagerDatum(
-    getInlineDatumOrThrow(stakingManagerUtxo),
   );
+  const stakingManagerOut = stakingManagerRef
+    ? await findStakingManagerByOutRef(stakingManagerRef, lucid)
+    : await findStakingManager(params, lucid);
 
   const stakingRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -164,98 +151,75 @@ export async function adjustStakingPosition(
     (_) => new Error('Expected a single staking Ref Script UTXO'),
   );
 
-  const indyToken =
-    params.stakingParams.indyToken[0].unCurrencySymbol +
-    fromText(params.stakingParams.indyToken[1].unTokenName);
+  const indyToken = fromSystemParamsAsset(params.stakingParams.indyToken);
 
-  const existingIndyAmount = stakingPositionUtxo.assets[indyToken] ?? 0n;
-  const currentSnapshotAda = stakingManagerDatum.managerSnapshot.snapshotAda;
-  const oldSnapshotAda = stakingPositionDatum.positionSnapshot.snapshotAda;
-  const adaReward =
-    ((currentSnapshotAda - oldSnapshotAda) * existingIndyAmount) /
-    rewardSnapshotPrecision;
+  const adaReward = calculateAdaReward(
+    stakingManagerOut.datum.managerSnapshot.snapshotAda,
+    stakingPositionOut.datum.positionSnapshot.snapshotAda,
+    assetClassValueOf(stakingPositionOut.utxo.assets, indyToken),
+  );
 
   const newLockedAmount = updateStakingLockedAmount(
-    stakingPositionDatum.lockedAmount,
-    BigInt(currentTime),
+    stakingPositionOut.datum.lockedAmount,
+    BigInt(now),
   );
 
   return lucid
     .newTx()
-    .validFrom(currentTime)
+    .validFrom(Number(now))
     .readFrom([stakingRefScriptUtxo])
     .collectFrom(
-      [stakingPositionUtxo],
+      [stakingPositionOut.utxo],
       serialiseStakingRedeemer({
         AdjustStakedAmount: { adjustAmount: amount },
       }),
     )
     .collectFrom(
-      [stakingManagerUtxo],
+      [stakingManagerOut.utxo],
       serialiseStakingRedeemer('UpdateTotalStake'),
     )
     .pay.ToContract(
-      stakingManagerUtxo.address,
+      stakingManagerOut.utxo.address,
       {
         kind: 'inline',
         value: serialiseStakingDatum({
-          ...stakingManagerDatum,
-          totalStake: stakingManagerDatum.totalStake + amount,
+          ...stakingManagerOut.datum,
+          totalStake: stakingManagerOut.datum.totalStake + amount,
         }),
       },
-      addAssets(stakingManagerUtxo.assets, mkLovelacesOf(-adaReward)),
+      addAssets(stakingManagerOut.utxo.assets, mkLovelacesOf(-adaReward)),
     )
     .pay.ToContract(
-      stakingPositionUtxo.address,
+      stakingPositionOut.utxo.address,
       {
         kind: 'inline',
         value: serialiseStakingDatum({
-          ...stakingPositionDatum,
+          ...stakingPositionOut.datum,
           lockedAmount: newLockedAmount,
-          positionSnapshot: stakingManagerDatum.managerSnapshot,
         }),
       },
-      addAssets(
-        stakingPositionUtxo.assets,
-        mkAssetsOf(
-          {
-            currencySymbol: params.stakingParams.indyToken[0].unCurrencySymbol,
-            tokenName: fromText(params.stakingParams.indyToken[1].unTokenName),
-          },
-          amount,
-        ),
-      ),
+      addAssets(stakingPositionOut.utxo.assets, mkAssetsOf(indyToken, amount)),
     )
-    .addSignerKey(toHex(stakingPositionDatum.owner));
+    .addSignerKey(toHex(stakingPositionOut.datum.owner));
 }
 
 export async function closeStakingPosition(
-  stakingPosition: UtxoOrOutRef,
+  stakingPositionRef: OutRef,
   params: SystemParams,
   lucid: LucidEvolution,
   currentSlot: number,
-  stakingManager: UtxoOrOutRef,
+  stakingManagerRef?: OutRef,
 ): Promise<TxBuilder> {
   const network = lucid.config().network!;
-  const currentTime = slotToUnixTime(network, currentSlot) - ONE_SECOND;
-
-  const stakingPositionUtxo = await resolveUtxo(
-    stakingPosition,
-    lucid,
-    'Expected a single staking position UTXO',
-  );
-  const stakingPositionDatum = parseStakingPositionOrThrow(
-    getInlineDatumOrThrow(stakingPositionUtxo),
-  );
+  const now = BigInt(slotToUnixTime(network, currentSlot));
 
-  const stakingManagerUtxo = await resolveUtxo(
-    stakingManager,
+  const stakingPositionOut = await findStakingPositionByOutRef(
+    stakingPositionRef,
     lucid,
-    'Expected a single staking manager UTXO',
-  );
-  const stakingManagerDatum = parseStakingManagerDatum(
-    getInlineDatumOrThrow(stakingManagerUtxo),
   );
+  const stakingManagerOut = stakingManagerRef
+    ? await findStakingManagerByOutRef(stakingManagerRef, lucid)
+    : await findStakingManager(params, lucid);
 
   const stakingRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -272,76 +236,67 @@ export async function closeStakingPosition(
     (_) => new Error('Expected a single staking token policy Ref Script UTXO'),
   );
 
-  const stakingToken =
-    params.stakingParams.stakingToken[0].unCurrencySymbol +
-    fromText(params.stakingParams.stakingToken[1].unTokenName);
-  const indyToken =
-    params.stakingParams.indyToken[0].unCurrencySymbol +
-    fromText(params.stakingParams.indyToken[1].unTokenName);
+  const indyToken = fromSystemParamsAsset(params.stakingParams.indyToken);
 
-  const existingIndyAmount = stakingPositionUtxo.assets[indyToken] ?? 0n;
-  const currentSnapshotAda = stakingManagerDatum.managerSnapshot.snapshotAda;
-  const oldSnapshotAda = stakingPositionDatum.positionSnapshot.snapshotAda;
-  const adaReward =
-    ((currentSnapshotAda - oldSnapshotAda) * existingIndyAmount) /
-    (1000000n * 1000000n);
+  const existingIndyAmount = assetClassValueOf(
+    stakingPositionOut.utxo.assets,
+    indyToken,
+  );
+  const adaReward = calculateAdaReward(
+    stakingManagerOut.datum.managerSnapshot.snapshotAda,
+    stakingPositionOut.datum.positionSnapshot.snapshotAda,
+    assetClassValueOf(stakingPositionOut.utxo.assets, indyToken),
+  );
 
   return lucid
     .newTx()
-    .validFrom(currentTime)
+    .validFrom(Number(now))
     .readFrom([stakingRefScriptUtxo, stakingTokenPolicyRefScriptUtxo])
-    .collectFrom([stakingPositionUtxo], serialiseStakingRedeemer('Unstake'))
+    .collectFrom([stakingPositionOut.utxo], serialiseStakingRedeemer('Unstake'))
     .collectFrom(
-      [stakingManagerUtxo],
+      [stakingManagerOut.utxo],
       serialiseStakingRedeemer('UpdateTotalStake'),
     )
     .pay.ToContract(
-      stakingManagerUtxo.address,
+      stakingManagerOut.utxo.address,
       {
         kind: 'inline',
         value: serialiseStakingDatum({
-          ...stakingManagerDatum,
-          totalStake: stakingManagerDatum.totalStake - existingIndyAmount,
+          ...stakingManagerOut.datum,
+          totalStake: stakingManagerOut.datum.totalStake - existingIndyAmount,
         }),
       },
-      addAssets(stakingManagerUtxo.assets, mkLovelacesOf(-adaReward)),
+      addAssets(stakingManagerOut.utxo.assets, mkLovelacesOf(-adaReward)),
     )
     .mintAssets(
-      {
-        [stakingToken]: -1n,
-      },
+      mkAssetsOf(fromSystemParamsAsset(params.stakingParams.stakingToken), -1n),
       Data.void(),
     )
-    .addSignerKey(toHex(stakingPositionDatum.owner));
+    .addSignerKey(toHex(stakingPositionOut.datum.owner));
 }
 
 const MIN_UTXO_AMOUNT = 2_000_000n;
 
 export async function distributeAda(
-  stakingManager: UtxoOrOutRef,
+  stakingManagerRef: OutRef,
   collectorRefs: OutRef[],
   params: SystemParams,
   lucid: LucidEvolution,
 ): Promise<TxBuilder> {
-  const stakingManagerUtxo = await resolveUtxo(
-    stakingManager,
-    lucid,
-    'Expected a single staking manager UTXO',
-  );
+  const [stakingManagerUtxo] = await lucid.utxosByOutRef([stakingManagerRef]);
   const stakingManagerDatum = parseStakingManagerDatum(
     getInlineDatumOrThrow(stakingManagerUtxo),
   );
-
   const collectorUtxos = (await lucid.utxosByOutRef(collectorRefs))
     .filter((utxo) => utxo.datum && utxo.datum === Data.void())
-    .filter((utxo) => utxo.assets.lovelace > MIN_UTXO_AMOUNT);
+    .filter((utxo) => utxo.assets['lovelace'] > MIN_UTXO_AMOUNT);
 
   if (collectorUtxos.length === 0) {
     throw new Error('No available collectors found');
   }
 
   const adaRewardCollected = collectorUtxos.reduce(
-    (acc, utxo) => acc + utxo.assets.lovelace - MIN_UTXO_AMOUNT,
+    (acc, utxo) => acc + utxo.assets['lovelace'] - MIN_UTXO_AMOUNT,
     0n,
   );
   const newSnapshot = distributeReward(