@indigo-labs/indigo-sdk 0.2.42 → 0.3.0

package/src/contracts/lrp/scripts.ts

@@ -1,27 +0,0 @@
-import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
-import { castLrpParams, LRPParams } from './types';
-import { fromSystemParamsAsset, LrpParamsSP } from '../../types/system-params';
-import { _lrpValidator } from '../../validators/lrp-validator';
-
-export const mkLrpValidator = (params: LRPParams): SpendingValidator => {
-  return {
-    type: 'PlutusV2',
-    script: applyParamsToScript(_lrpValidator.cborHex, [castLrpParams(params)]),
-  };
-};
-
-export const mkLrpValidatorFromSP = (
-  params: LrpParamsSP,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV2',
-    script: applyParamsToScript(_lrpValidator.cborHex, [
-      castLrpParams({
-        versionRecordToken: fromSystemParamsAsset(params.versionRecordToken),
-        iassetNft: fromSystemParamsAsset(params.iassetNft),
-        minRedemptionLovelacesAmt: BigInt(params.minRedemptionLovelacesAmt),
-        iassetPolicyId: params.iassetPolicyId.unCurrencySymbol,
-      }),
-    ]),
-  };
-};

package/src/contracts/lrp/transactions.ts

@@ -1,250 +0,0 @@
-import {
-  LucidEvolution,
-  TxBuilder,
-  Credential,
-  OutRef,
-  addAssets,
-  unixTimeToSlot,
-  slotToUnixTime,
-} from '@lucid-evolution/lucid';
-import {
-  addrDetails,
-  createScriptAddress,
-  getInlineDatumOrThrow,
-  resolveUtxo,
-  UtxoOrOutRef,
-} from '../../utils/lucid-utils';
-import { unzip, zip } from 'fp-ts/lib/Array';
-import {
-  LRPDatum,
-  parseLrpDatumOrThrow,
-  serialiseLrpDatum,
-  serialiseLrpRedeemer,
-} from './types';
-import { parsePriceOracleDatum } from '../price-oracle/types';
-import { OnChainDecimal } from '../../types/on-chain-decimal';
-import { parseIAssetDatumOrThrow } from '../cdp/types';
-import {
-  assetClassValueOf,
-  mkAssetsOf,
-  mkLovelacesOf,
-} from '../../utils/value-helpers';
-import { matchSingle } from '../../utils/utils';
-import { AssetClass } from '../../types/generic';
-import {
-  fromSystemParamsScriptRef,
-  SystemParams,
-} from '../../types/system-params';
-import { buildRedemptionsTx, MIN_LRP_COLLATERAL_AMT } from './helpers';
-
-export async function openLrp(
-  assetTokenName: string,
-  lovelacesAmt: bigint,
-  maxPrice: OnChainDecimal,
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-  lrpStakeCredential?: Credential,
-): Promise<TxBuilder> {
-  const network = lucid.config().network!;
-
-  const [ownPkh, _] = await addrDetails(lucid);
-
-  const newDatum: LRPDatum = {
-    owner: ownPkh.hash,
-    iasset: assetTokenName,
-    maxPrice: maxPrice,
-    lovelacesToSpend: lovelacesAmt,
-  };
-
-  return lucid.newTx().pay.ToContract(
-    createScriptAddress(
-      network,
-      sysParams.validatorHashes.lrpHash,
-      lrpStakeCredential,
-    ),
-    {
-      kind: 'inline',
-      value: serialiseLrpDatum(newDatum),
-    },
-    { lovelace: lovelacesAmt + MIN_LRP_COLLATERAL_AMT },
-  );
-}
-
-export async function cancelLrp(
-  lrp: UtxoOrOutRef,
-  sysParams: SystemParams,
-  lucid: LucidEvolution,
-): Promise<TxBuilder> {
-  const lrpScriptRefUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(sysParams.scriptReferences.lrpValidatorRef),
-    ]),
-    (_) => new Error('Expected a single LRP Ref Script UTXO'),
-  );
-
-  const lrpUtxo = await resolveUtxo(lrp, lucid, 'Expected a single LRP UTXO.');
-
-  const lrpDatum = parseLrpDatumOrThrow(getInlineDatumOrThrow(lrpUtxo));
-
-  return lucid
-    .newTx()
-    .readFrom([lrpScriptRefUtxo])
-    .collectFrom([lrpUtxo], serialiseLrpRedeemer('Cancel'))
-    .addSignerKey(lrpDatum.owner);
-}
-
-export async function redeemLrp(
-  /** The tuple represents the LRP outref and the amount of iAssets to redeem against it. */
-  redemptionLrpsData: [OutRef, bigint][],
-  priceOracle: UtxoOrOutRef,
-  iasset: UtxoOrOutRef,
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-): Promise<TxBuilder> {
-  const network = lucid.config().network!;
-
-  const lrpScriptRefUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(sysParams.scriptReferences.lrpValidatorRef),
-    ]),
-    (_) => new Error('Expected a single LRP Ref Script UTXO'),
-  );
-
-  const priceOracleUtxo = await resolveUtxo(
-    priceOracle,
-    lucid,
-    'Expected a single price oracle UTXO',
-  );
-
-  const iassetUtxo = await resolveUtxo(
-    iasset,
-    lucid,
-    'Expected a single IAsset UTXO',
-  );
-
-  const iassetDatum = parseIAssetDatumOrThrow(
-    getInlineDatumOrThrow(iassetUtxo),
-  );
-
-  const [lrpsToRedeemOutRefs, lrpRedemptionIAssetAmt] =
-    unzip(redemptionLrpsData);
-
-  const priceOracleDatum = parsePriceOracleDatum(
-    getInlineDatumOrThrow(priceOracleUtxo),
-  );
-
-  const redemptionLrps = await lucid
-    .utxosByOutRef(lrpsToRedeemOutRefs)
-    .then((val) => zip(val, lrpRedemptionIAssetAmt));
-
-  const tx = buildRedemptionsTx(
-    redemptionLrps,
-    priceOracleDatum.price,
-    iassetDatum.redemptionReimbursementPercentage,
-    sysParams,
-    lucid.newTx(),
-    0n,
-  );
-
-  return (
-    lucid
-      .newTx()
-      .validTo(
-        slotToUnixTime(
-          network,
-          unixTimeToSlot(network, Number(priceOracleDatum.expiration)) - 1,
-        ),
-      )
-      // Ref script
-      .readFrom([lrpScriptRefUtxo])
-      // Ref inputs
-      .readFrom([iassetUtxo, priceOracleUtxo])
-      .compose(tx)
-  );
-}
-
-/**
- * Create Tx adjusting the LRP and claiming the received iAssets
- */
-export async function adjustLrp(
-  lucid: LucidEvolution,
-  lrp: UtxoOrOutRef,
-  /**
-   * A positive amount increases the lovelaces in the LRP,
-   * and a negative amount takes lovelaces from the LRP.
-   */
-  lovelacesAdjustAmt: bigint,
-  newMaxPrice: OnChainDecimal | undefined,
-  sysParams: SystemParams,
-): Promise<TxBuilder> {
-  const lrpScriptRefUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(sysParams.scriptReferences.lrpValidatorRef),
-    ]),
-    (_) => new Error('Expected a single LRP Ref Script UTXO'),
-  );
-
-  const lrpUtxo = await resolveUtxo(lrp, lucid, 'Expected a single LRP UTXO.');
-
-  const lrpDatum = parseLrpDatumOrThrow(getInlineDatumOrThrow(lrpUtxo));
-
-  const rewardAssetClass: AssetClass = {
-    currencySymbol: sysParams.lrpParams.iassetPolicyId.unCurrencySymbol,
-    tokenName: lrpDatum.iasset,
-  };
-  const rewardAssetsAmt = assetClassValueOf(lrpUtxo.assets, rewardAssetClass);
-
-  // The claim case
-  if (lovelacesAdjustAmt === 0n && lrpDatum.lovelacesToSpend === 0n) {
-    throw new Error(
-      "When there's no more lovelaces to spend, use close instead of claim.",
-    );
-  }
-
-  // Negative adjust case
-  if (
-    lovelacesAdjustAmt < 0 &&
-    lrpDatum.lovelacesToSpend <= lovelacesAdjustAmt
-  ) {
-    throw new Error(
-      "Can't adjust negatively by more than available. Also, for adjusting by exactly the amount deposited, a close action should be used instead.",
-    );
-  }
-
-  if (newMaxPrice && newMaxPrice.getOnChainInt < 0n) {
-    throw new Error('Max price cannot be negative');
-  }
-
-  return lucid
-    .newTx()
-    .readFrom([lrpScriptRefUtxo])
-    .collectFrom([lrpUtxo], serialiseLrpRedeemer('Cancel'))
-    .pay.ToContract(
-      lrpUtxo.address,
-      {
-        kind: 'inline',
-        value: serialiseLrpDatum({
-          ...lrpDatum,
-          lovelacesToSpend: lrpDatum.lovelacesToSpend + lovelacesAdjustAmt,
-          maxPrice: newMaxPrice ? newMaxPrice : lrpDatum.maxPrice,
-        }),
-      },
-      addAssets(
-        lrpUtxo.assets,
-        mkAssetsOf(rewardAssetClass, -rewardAssetsAmt),
-        mkLovelacesOf(lovelacesAdjustAmt),
-      ),
-    )
-    .addSignerKey(lrpDatum.owner);
-}
-
-/**
- * Create Tx claiming the received iAssets.
- */
-export async function claimLrp(
-  lucid: LucidEvolution,
-  lrp: UtxoOrOutRef,
-  sysParams: SystemParams,
-): Promise<TxBuilder> {
-  return adjustLrp(lucid, lrp, 0n, undefined, sysParams);
-}

package/src/contracts/lrp/types.ts

@@ -1,131 +0,0 @@
-import { Data, Datum, Redeemer, UTxO } from '@lucid-evolution/lucid';
-import { AssetClassSchema, OutputReferenceSchema } from '../../types/generic';
-import {
-  OnChainDecimal,
-  OnChainDecimalSchema,
-} from '../../types/on-chain-decimal';
-import { option as O, function as F } from 'fp-ts';
-import { match, P } from 'ts-pattern';
-
-export const LRPParamsSchema = Data.Object({
-  versionRecordToken: AssetClassSchema,
-  iassetNft: AssetClassSchema,
-  iassetPolicyId: Data.Bytes(),
-  minRedemptionLovelacesAmt: Data.Integer(),
-});
-export type LRPParams = Data.Static<typeof LRPParamsSchema>;
-const LRPParams = LRPParamsSchema as unknown as LRPParams;
-
-export const LRPDatumSchema = Data.Object({
-  owner: Data.Bytes(),
-  iasset: Data.Bytes(),
-  maxPrice: OnChainDecimalSchema,
-  /**
-   * The amount of lovelaces that is available to be spent.
-   * This doesn't correspond to the lovelaces in UTXO's value,
-   * since that can contain fees, too.
-   */
-  lovelacesToSpend: Data.Integer(),
-});
-export type LRPDatum = Data.Static<typeof LRPDatumSchema>;
-const LRPDatum = LRPDatumSchema as unknown as LRPDatum;
-
-export const LRPRedeemerSchema = Data.Enum([
-  Data.Object({ Redeem: Data.Object({ continuingOutputIdx: Data.Integer() }) }),
-  Data.Object({
-    RedeemAuxiliary: Data.Object({
-      continuingOutputIdx: Data.Integer(),
-      mainRedeemOutRef: OutputReferenceSchema,
-      asset: Data.Bytes(),
-      assetPrice: OnChainDecimalSchema,
-      redemptionReimbursementPercentage: OnChainDecimalSchema,
-    }),
-  }),
-  Data.Literal('Cancel'),
-  Data.Literal('UpgradeVersion'),
-]);
-export type LRPRedeemer = Data.Static<typeof LRPRedeemerSchema>;
-const LRPRedeemer = LRPRedeemerSchema as unknown as LRPRedeemer;
-
-export function parseLrpDatum(datum: Datum): O.Option<LRPDatum> {
-  try {
-    return O.some(Data.from<LRPDatum>(datum, LRPDatum));
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parseLrpDatumOrThrow(datum: Datum): LRPDatum {
-  return F.pipe(
-    parseLrpDatum(datum),
-    O.match(() => {
-      throw new Error('Expected an LRP datum.');
-    }, F.identity),
-  );
-}
-
-type LRPSerialisationOptions =
-  // No replacing, just use non-canonical format.
-  | { _tag: 'noReplace' }
-  // Adaptive replace, when the spentDatum is canonical, do the replace,
-  // otherwise use the non canonical.
-  | { _tag: 'adaptiveReplace'; spentLrpDatum: string };
-
-export function serialiseLrpDatum(
-  datum: LRPDatum,
-  // Overall, we don't want to do the replacing. We just use non-canonical format.
-  serialisationOptions: LRPSerialisationOptions = { _tag: 'noReplace' },
-): Datum {
-  const d = Data.to<LRPDatum>(datum, LRPDatum);
-
-  return match(serialisationOptions)
-    .returnType<Datum>()
-    .with({ _tag: 'noReplace' }, () => d)
-    .with(
-      { _tag: 'adaptiveReplace', spentLrpDatum: P.select() },
-      (spentLrpDatum) => {
-        const isSpentDatumCanonical = spentLrpDatum.includes(
-          Data.to<OnChainDecimal>(
-            parseLrpDatumOrThrow(spentLrpDatum).maxPrice,
-            OnChainDecimal,
-            {
-              canonical: true,
-            },
-          ),
-        );
-
-        // When spent datum was canonical, replace.
-        if (isSpentDatumCanonical) {
-          // If the lrp was created using a canonical on-chain decimal, we need to serialise it canonically.
-          // This is due to some issue related to how Aiken compares objects.
-          // See "Wrong continuing output" trace, specifically the spread of the previous datum ie. expecting the serialisation to be the same as it was created with
-          // We however do not want to do this for any lrps that are being build canonical.
-          const ocdSerialisedCanonical = Data.to<OnChainDecimal>(
-            datum.maxPrice,
-            OnChainDecimal,
-            { canonical: true },
-          );
-          const ocdSerialisedNonCanonical = Data.to<OnChainDecimal>(
-            datum.maxPrice,
-            OnChainDecimal,
-            { canonical: false },
-          );
-
-          return d.replace(ocdSerialisedNonCanonical, ocdSerialisedCanonical);
-        }
-
-        return d;
-      },
-    )
-    .exhaustive();
-}
-
-export function serialiseLrpRedeemer(redeemer: LRPRedeemer): Redeemer {
-  return Data.to<LRPRedeemer>(redeemer, LRPRedeemer);
-}
-
-export function castLrpParams(params: LRPParams): Data {
-  return Data.castTo(params, LRPParams);
-}
-
-export type LrpOutput = { datum: LRPDatum; utxo: UTxO };

package/src/contracts/poll/types-poll.ts

@@ -1,88 +0,0 @@
-import { Data, Datum } from '@lucid-evolution/lucid';
-import { TreasuryWithdrawalSchema } from '../gov/types';
-import { AddressSchema } from '../../types/generic';
-import { option as O, function as F } from 'fp-ts';
-import { match, P } from 'ts-pattern';
-import { ProposalContentSchema } from '../gov/types-new';
-
-const PollStatusSchema = Data.Object({
-  yesVotes: Data.Integer(),
-  noVotes: Data.Integer(),
-});
-export type PollStatus = Data.Static<typeof PollStatusSchema>;
-
-const PollManagerContentSchema = Data.Object({
-  pollId: Data.Integer(),
-  pollOwner: Data.Bytes(),
-  content: ProposalContentSchema,
-  treasuryWithdrawal: Data.Nullable(TreasuryWithdrawalSchema),
-  status: PollStatusSchema,
-  votingEndTime: Data.Integer(),
-  createdShardsCount: Data.Integer(),
-  talliedShardsCount: Data.Integer(),
-  totalShardsCount: Data.Integer(),
-  proposingEndTime: Data.Integer(),
-  expirationTime: Data.Integer(),
-  protocolVersion: Data.Integer(),
-  minimumQuorum: Data.Integer(),
-});
-export type PollManagerContent = Data.Static<typeof PollManagerContentSchema>;
-
-const PollShardContentSchema = Data.Object({
-  pollId: Data.Integer(),
-  status: PollStatusSchema,
-  votingEndTime: Data.Integer(),
-  managerAddress: AddressSchema,
-});
-export type PollShardContent = Data.Static<typeof PollShardContentSchema>;
-
-const PollDatumSchema = Data.Enum([
-  Data.Object({
-    PollManager: Data.Object({ content: PollManagerContentSchema }),
-  }),
-  Data.Object({ PollShard: Data.Object({ content: PollShardContentSchema }) }),
-]);
-export type PollDatum = Data.Static<typeof PollDatumSchema>;
-export const PollDatum = PollDatumSchema as unknown as PollDatum;
-
-export function parsePollManager(datum: Datum): O.Option<PollManagerContent> {
-  try {
-    return match(Data.from<PollDatum>(datum, PollDatum))
-      .with({ PollManager: P.select() }, (res) => O.some(res.content))
-      .otherwise(() => O.none);
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parsePollManagerOrThrow(datum: Datum): PollManagerContent {
-  return F.pipe(
-    parsePollManager(datum),
-    O.match(() => {
-      throw new Error('Expected a Poll manager datum.');
-    }, F.identity),
-  );
-}
-
-export function parsePollShard(datum: Datum): O.Option<PollShardContent> {
-  try {
-    return match(Data.from<PollDatum>(datum, PollDatum))
-      .with({ PollShard: P.select() }, (res) => O.some(res.content))
-      .otherwise(() => O.none);
-  } catch (_) {
-    return O.none;
-  }
-}
-
-export function parsePollShardOrThrow(datum: Datum): PollShardContent {
-  return F.pipe(
-    parsePollShard(datum),
-    O.match(() => {
-      throw new Error('Expected a Poll shard datum.');
-    }, F.identity),
-  );
-}
-
-export function serialisePollDatum(datum: PollDatum): Datum {
-  return Data.to<PollDatum>(datum, PollDatum);
-}

package/src/contracts/vesting/helpers.ts

@@ -1,218 +0,0 @@
-import { match, P } from 'ts-pattern';
-import { ONE_DAY } from '../../utils/time-helpers';
-import { OCD_DECIMAL_UNIT } from '../../types/on-chain-decimal';
-import { array as A } from 'fp-ts';
-import { bigintMax, bigintMin } from '../../utils/bigint-utils';
-
-type Schedule = {
-  vestedAtTime: bigint;
-  unlockAmt: bigint;
-};
-
-type VestingSchedule = {
-  maxUnlockable: bigint;
-  schedule: Schedule[];
-};
-
-export const teamVestingSchedule: Schedule[] = [
-  {
-    vestedAtTime: 1669067100000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1672523100000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1675201500000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1677620700000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1680299100000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1682891100000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1685569500000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1688161500000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1690839900000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1693518300000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1696110300000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1698788700000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1701380700000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1704059100000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1706737500000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1709243100000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1711921500000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1714513500000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1717191900000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1719783900000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1722462300000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1725140700000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1727732700000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-  {
-    vestedAtTime: 1730411100000n,
-    unlockAmt: 328_125n * OCD_DECIMAL_UNIT,
-  },
-];
-
-export const spDistributionSchedule: VestingSchedule = {
-  maxUnlockable: 2_013_760n * OCD_DECIMAL_UNIT,
-  schedule: [
-    {
-      vestedAtTime: 1669931100000n,
-      unlockAmt: 28_768n * OCD_DECIMAL_UNIT,
-    },
-  ],
-};
-
-export const liqDistributionSchedule: VestingSchedule = {
-  maxUnlockable: 316_470n * OCD_DECIMAL_UNIT,
-  schedule: [
-    {
-      vestedAtTime: 1671659100000n,
-      unlockAmt: 4_795n * OCD_DECIMAL_UNIT,
-    },
-  ],
-};
-
-export const spLpDistributionSchedule: VestingSchedule = {
-  maxUnlockable: 17_016_441n * OCD_DECIMAL_UNIT,
-  schedule: [
-    {
-      vestedAtTime: 1700171100000n,
-      unlockAmt: 33_563n * OCD_DECIMAL_UNIT,
-    },
-  ],
-};
-
-export const govDistributionSchedule: VestingSchedule = {
-  maxUnlockable: 1_381_248n * OCD_DECIMAL_UNIT,
-  schedule: [
-    {
-      vestedAtTime: 1670363100000n,
-      unlockAmt: 2_398n * OCD_DECIMAL_UNIT,
-    },
-  ],
-};
-
-export function calculateTotalVestedTeam(currentTime: bigint): bigint {
-  return A.reduce<Schedule, bigint>(0n, (acc, schedule) => {
-    if (currentTime >= schedule.vestedAtTime) {
-      return acc + schedule.unlockAmt;
-    } else {
-      return acc;
-    }
-  })(teamVestingSchedule);
-}
-
-export function calculateVestedPerEpoch(
-  schedule: VestingSchedule,
-  currentTime: bigint,
-): bigint {
-  const vestingFreq = 5n * ONE_DAY;
-
-  function go(sched: Schedule[]): bigint {
-    return (
-      match(sched)
-        .returnType<bigint>()
-        .with([], () => 0n)
-        // If the current time is earlier than the first vesting period,
-        // the vested INDY is zero.
-        // Otherwise, the vested INDY increases by the given amount every epoch
-        // after the given date.
-        // The + 1 indicates that the first vest happens from the given date
-        // (as opposed to having to wait for an epoch to complete)
-        .with([P.select()], (sched) =>
-          bigintMax(
-            0n,
-            ((currentTime - sched.vestedAtTime) / vestingFreq + 1n) *
-              sched.unlockAmt,
-          ),
-        )
-        // If the current time is past the first period in the schedule,
-        // at least all INDY from the first period is vested, and can proceed
-        // to compute the vested amount for remaining periods.
-        .with([P._, P._, ...P.array()], ([sched1, sched2, ...rest]) =>
-          currentTime >= sched2.vestedAtTime
-            ? ((sched2.vestedAtTime - sched1.vestedAtTime) / vestingFreq) *
-                sched1.unlockAmt +
-              go([sched2, ...rest])
-            : bigintMax(
-                0n,
-                ((currentTime - sched1.vestedAtTime) / vestingFreq + 1n) *
-                  sched1.unlockAmt,
-              ),
-        )
-        .run()
-    );
-  }
-
-  return bigintMin(schedule.maxUnlockable, go(schedule.schedule));
-}
-
-export function calculateTotalVestedRewards(currentTime: bigint): bigint {
-  return (
-    calculateVestedPerEpoch(spDistributionSchedule, currentTime) +
-    calculateVestedPerEpoch(govDistributionSchedule, currentTime) +
-    calculateVestedPerEpoch(liqDistributionSchedule, currentTime) +
-    calculateVestedPerEpoch(spLpDistributionSchedule, currentTime)
-  );
-}