@indigo-labs/indigo-sdk 0.2.41 → 0.3.0

package/src/contracts/stability-pool/transactions.ts

@@ -1,5 +1,4 @@
 import {
-  Constr,
   fromText,
   LucidEvolution,
   TxBuilder,
@@ -9,70 +8,83 @@ import {
   credentialToAddress,
   fromHex,
   toHex,
+  addAssets,
+  OutRef,
+  slotToUnixTime,
 } from '@lucid-evolution/lucid';
-import { ActionReturnDatum } from './types';
-import { fromSystemParamsAsset, SystemParams } from '../../types/system-params';
 import {
-  addrDetails,
-  getInlineDatumOrThrow,
-  scriptRef,
-  UtxoOrOutRef,
-} from '../../utils/lucid-utils';
+  fromSystemParamsAsset,
+  fromSystemParamsScriptRef,
+  SystemParams,
+} from '../../types/system-params';
+import { addrDetails, getInlineDatumOrThrow } from '../../utils/lucid-utils';
 import { mkStabilityPoolValidatorFromSP } from './scripts';
 import {
-  adjustmentHelper,
-  setSumInEpochToScaleToSum,
-  updatePoolSnapshotWithdrawalFee,
+  BASE_MAX_TX_FEE,
+  createProcessRequestAccountRedeemer,
+  findRelevantE2s2sIdxs,
+  initSpState,
+  liquidationHelper,
+  mkStabilityPoolAddr,
+  partitionEpochToScaleToSums,
+  updateAccount,
+  updatePoolStateWhenWithdrawalFee,
 } from './helpers';
-import { calculateFeeFromPercentage } from '../../utils/indigo-helpers';
-import { GovDatum, parseGovDatumOrThrow } from '../gov/types';
-import { IAssetContent, parseIAssetDatumOrThrow } from '../cdp/types';
-import {
-  addressFromBech32,
-  addressToBech32,
-} from '@3rd-eye-labs/cardano-offchain-common';
+import { calculateFeeFromRatio } from '../../utils/indigo-helpers';
 import {
   AccountAction,
   AccountContent,
-  EpochToScaleToSum,
   fromSPInteger,
   mkSPInteger,
-  parseAccountDatum,
-  parseStabilityPoolDatum,
+  parseAccountDatumOrThrow,
+  parseStabilityPoolDatumOrThrow,
+  serialiseActionReturnDatum,
   serialiseStabilityPoolDatum,
   serialiseStabilityPoolRedeemer,
   spAdd,
-  spDiv,
-  spMul,
   spSub,
-  StabilityPoolRedeemer,
-  StabilityPoolSnapshot,
+  spZeroNegatives,
 } from './types-new';
-import { collectorFeeTx } from '../collector/transactions';
-import { mkAssetsOf } from '../../utils/value-helpers';
+import {
+  adaAssetClass,
+  addressFromBech32,
+  addressToBech32,
+  AssetClass,
+  assetClassValueOf,
+  estimateUtxoMinLovelace,
+  lovelacesAmt,
+  matchSingle,
+  mkAssetsOf,
+  mkLovelacesOf,
+  negateAssets,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import { parseIAssetDatumOrThrow } from '../iasset/types';
+import { match, P } from 'ts-pattern';
+import { bigintMax, zeroNegatives } from '../../utils/bigint-utils';
 
 export async function createSpAccount(
-  asset: string,
+  assetAscii: string,
   amount: bigint,
-  params: SystemParams,
+  sysParams: SystemParams,
   lucid: LucidEvolution,
 ): Promise<TxBuilder> {
   const [pkh, _skh] = await addrDetails(lucid);
-  const minLovelaces = BigInt(
-    params.stabilityPoolParams.accountCreateFeeLovelaces +
-      params.stabilityPoolParams.requestCollateralLovelaces,
-  );
+
+  const iasset = fromHex(fromText(assetAscii));
+  const iassetAssetClass = {
+    currencySymbol: fromHex(
+      sysParams.stabilityPoolParams.assetSymbol.unCurrencySymbol,
+    ),
+    tokenName: iasset,
+  };
+
   const datum: AccountContent = {
     owner: fromHex(pkh.hash),
-    asset: fromHex(fromText(asset)),
-    accountSnapshot: {
-      productVal: { value: 0n },
-      depositVal: { value: 0n },
-      sumVal: { value: 0n },
-      epoch: 0n,
-      scale: 0n,
-    },
+    iasset: iasset,
+    state: initSpState,
+    assetSums: [],
     request: 'Create',
+    lastRequestProcessingTime: 0n,
   };
 
   return lucid
@@ -80,7 +92,7 @@ export async function createSpAccount(
     .pay.ToContract(
       credentialToAddress(lucid.config().network!, {
         hash: validatorToScriptHash(
-          mkStabilityPoolValidatorFromSP(params.stabilityPoolParams),
+          mkStabilityPoolValidatorFromSP(sysParams.stabilityPoolParams),
         ),
         type: 'Script',
       }),
@@ -88,30 +100,35 @@ export async function createSpAccount(
         kind: 'inline',
         value: serialiseStabilityPoolDatum({ Account: datum }),
       },
-      {
-        lovelace: minLovelaces,
-        [params.stabilityPoolParams.assetSymbol.unCurrencySymbol +
-        fromText(asset)]: amount,
-      },
+      addAssets(
+        mkAssetsOf(iassetAssetClass, amount),
+        mkLovelacesOf(
+          // TODO: Calculate a more accurate amount to just cover costs.
+          5_000_000n,
+        ),
+      ),
     )
     .addSignerKey(pkh.hash);
 }
 
 export async function adjustSpAccount(
-  asset: string,
   amount: bigint,
   accountUtxo: UTxO,
-  params: SystemParams,
+  sysParams: SystemParams,
   lucid: LucidEvolution,
 ): Promise<TxBuilder> {
   const myAddress = await lucid.wallet().address();
 
-  const stabilityPoolScriptRef = await scriptRef(
-    params.scriptReferences.stabilityPoolValidatorRef,
-    lucid,
+  const stabilityPoolScriptRef = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.stabilityPoolValidatorRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single stability pool Ref Script UTXO'),
   );
 
-  const oldAccountDatum: AccountContent = parseAccountDatum(
+  const oldAccountDatum: AccountContent = parseAccountDatumOrThrow(
     getInlineDatumOrThrow(accountUtxo),
   );
 
@@ -125,21 +142,6 @@ export async function adjustSpAccount(
     },
   };
 
-  const value = {
-    lovelace: BigInt(
-      params.stabilityPoolParams.requestCollateralLovelaces +
-        params.stabilityPoolParams.accountAdjustmentFeeLovelaces,
-    ),
-    [params.stabilityPoolParams.accountToken[0].unCurrencySymbol +
-    fromText(params.stabilityPoolParams.accountToken[1].unTokenName)]: 1n,
-  };
-
-  if (amount > 0n) {
-    value[
-      params.stabilityPoolParams.assetSymbol.unCurrencySymbol + fromText(asset)
-    ] = amount;
-  }
-
   return lucid
     .newTx()
     .readFrom([stabilityPoolScriptRef])
@@ -155,41 +157,62 @@ export async function adjustSpAccount(
       }),
     )
     .pay.ToContract(
-      credentialToAddress(lucid.config().network!, {
-        hash: validatorToScriptHash(
-          mkStabilityPoolValidatorFromSP(params.stabilityPoolParams),
-        ),
-        type: 'Script',
-      }),
+      accountUtxo.address,
       {
         kind: 'inline',
         value: serialiseStabilityPoolDatum({
           Account: newAccountDatum,
         }),
       },
-      value,
+      addAssets(
+        mkLovelacesOf(
+          // TODO: Calculate a more accurate amount to just cover costs.
+          7_000_000n,
+        ),
+        mkAssetsOf(
+          fromSystemParamsAsset(sysParams.stabilityPoolParams.accountToken),
+          1n,
+        ),
+        amount > 0n
+          ? mkAssetsOf(
+              {
+                currencySymbol: fromHex(
+                  sysParams.stabilityPoolParams.assetSymbol.unCurrencySymbol,
+                ),
+                tokenName: oldAccountDatum.iasset,
+              },
+              amount,
+            )
+          : {},
+      ),
     )
     .addSignerKey(toHex(oldAccountDatum.owner));
 }
 
 export async function closeSpAccount(
   accountUtxo: UTxO,
-  params: SystemParams,
+  sysParams: SystemParams,
   lucid: LucidEvolution,
+  maxTxFee: bigint = BASE_MAX_TX_FEE,
 ): Promise<TxBuilder> {
   const myAddress = await lucid.wallet().address();
 
-  const stabilityPoolScriptRef = await scriptRef(
-    params.scriptReferences.stabilityPoolValidatorRef,
-    lucid,
+  const stabilityPoolScriptRef = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.stabilityPoolValidatorRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single stability pool Ref Script UTXO'),
   );
 
   const request: AccountAction = {
     Close: {
       outputAddress: addressFromBech32(myAddress),
+      maxTxFee: maxTxFee,
     },
   };
-  const oldAccountDatum: AccountContent = parseAccountDatum(
+  const oldAccountDatum: AccountContent = parseAccountDatumOrThrow(
     getInlineDatumOrThrow(accountUtxo),
   );
   const newAccountDatum: AccountContent = {
@@ -205,462 +228,571 @@ export async function closeSpAccount(
       serialiseStabilityPoolRedeemer({ RequestAction: request }),
     )
     .pay.ToContract(
-      credentialToAddress(lucid.config().network!, {
-        hash: validatorToScriptHash(
-          mkStabilityPoolValidatorFromSP(params.stabilityPoolParams),
-        ),
-        type: 'Script',
-      }),
+      accountUtxo.address,
       {
         kind: 'inline',
         value: serialiseStabilityPoolDatum({ Account: newAccountDatum }),
       },
-      {
-        lovelace: BigInt(
-          params.stabilityPoolParams.requestCollateralLovelaces +
-            params.stabilityPoolParams.accountAdjustmentFeeLovelaces,
+      addAssets(
+        mkLovelacesOf(
+          // TODO: Calculate a more accurate amount to just cover costs.
+          5_000_000n,
         ),
-        [params.stabilityPoolParams.accountToken[0].unCurrencySymbol +
-        fromText(params.stabilityPoolParams.accountToken[1].unTokenName)]: 1n,
-      },
+        mkAssetsOf(
+          fromSystemParamsAsset(sysParams.stabilityPoolParams.accountToken),
+          1n,
+        ),
+      ),
     )
     .addSignerKey(toHex(oldAccountDatum.owner));
 }
 
 export async function processSpRequest(
-  asset: string,
   stabilityPoolUtxo: UTxO,
   accountUtxo: UTxO,
-  govUtxo: UTxO,
   iAssetUtxo: UTxO,
-  newSnapshotUtxo: UTxO | undefined,
-  params: SystemParams,
+  /**
+   * For performance provide only the ones related to the pool's iAsset.
+   */
+  allE2s2sSnapshotOrefs: OutRef[],
+  sysParams: SystemParams,
   lucid: LucidEvolution,
-  collector: UtxoOrOutRef,
+  currentSlot: number,
 ): Promise<TxBuilder> {
-  const redeemer: StabilityPoolRedeemer = {
-    ProcessRequest: {
-      txHash: { hash: fromHex(accountUtxo.txHash) },
-      outputIndex: BigInt(accountUtxo.outputIndex),
-    },
-  };
-  const stabilityPoolScriptRef = await scriptRef(
-    params.scriptReferences.stabilityPoolValidatorRef,
-    lucid,
+  const network = lucid.config().network!;
+  const currentTime = BigInt(slotToUnixTime(network, currentSlot));
+
+  const stabilityPoolScriptRef = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.stabilityPoolValidatorRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single stability pool Ref Script UTXO'),
   );
 
-  const accountDatum = parseAccountDatum(getInlineDatumOrThrow(accountUtxo));
+  const accountDatum = parseAccountDatumOrThrow(
+    getInlineDatumOrThrow(accountUtxo),
+  );
 
-  const stabilityPoolDatum = parseStabilityPoolDatum(
+  const stabilityPoolDatum = parseStabilityPoolDatumOrThrow(
     getInlineDatumOrThrow(stabilityPoolUtxo),
   );
 
+  const baseRefInputs = [iAssetUtxo, stabilityPoolScriptRef];
+
+  const validFrom = slotToUnixTime(network, currentSlot - 1);
   const tx = lucid
     .newTx()
-    .collectFrom([stabilityPoolUtxo], serialiseStabilityPoolRedeemer(redeemer))
-    .collectFrom([accountUtxo], serialiseStabilityPoolRedeemer(redeemer))
-    .readFrom([iAssetUtxo, govUtxo, stabilityPoolScriptRef]);
-
+    .validFrom(validFrom)
+    .validTo(validFrom + sysParams.stabilityPoolParams.accountProcessingBiasMs)
+    .readFrom(baseRefInputs)
+    .collectFrom([stabilityPoolUtxo], {
+      kind: 'selected',
+      inputs: [stabilityPoolUtxo, accountUtxo],
+      makeRedeemer: (indices) =>
+        serialiseStabilityPoolRedeemer({
+          ProcessRequestPool: {
+            poolInputIdx: indices[0],
+            accountInputIdx: indices[1],
+          },
+        }),
+    });
   if (!accountDatum.request) throw new Error('Account Request is null');
 
-  if (accountDatum.request === 'Create') {
-    const accountTokenScriptRef = await scriptRef(
-      params.scriptReferences.authTokenPolicies.accountTokenRef,
-      lucid,
-    );
-    tx.readFrom([accountTokenScriptRef]);
-
-    const iassetUnit =
-      params.stabilityPoolParams.assetSymbol.unCurrencySymbol + fromText(asset);
-    const reqAmount = accountUtxo.assets[iassetUnit] ?? 0n;
-
-    const newAccountSnapshot: StabilityPoolSnapshot = {
-      ...stabilityPoolDatum.poolSnapshot,
-      depositVal: {
-        value: spAdd(
-          accountDatum.accountSnapshot.depositVal,
-          mkSPInteger(reqAmount),
-        ).value,
-      },
-    };
+  const iassetAssetClass: AssetClass = {
+    currencySymbol: fromHex(
+      sysParams.stabilityPoolParams.assetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stabilityPoolDatum.iasset,
+  };
 
-    const newDeposit = spAdd(
-      stabilityPoolDatum.poolSnapshot.depositVal,
-      mkSPInteger(reqAmount),
-    );
+  await match(accountDatum.request)
+    .with('Create', async (_) => {
+      const accountTokenScriptRef = matchSingle(
+        await lucid.utxosByOutRef([
+          fromSystemParamsScriptRef(
+            sysParams.scriptReferences.authTokenPolicies.accountTokenRef,
+          ),
+        ]),
+        (_) =>
+          new Error('Expected a single cdp auth token policy Ref Script UTXO'),
+      );
 
-    const newSum = spAdd(
-      stabilityPoolDatum.poolSnapshot.sumVal,
-      spDiv(
-        spMul(
-          mkSPInteger(
-            BigInt(params.stabilityPoolParams.accountCreateFeeLovelaces),
+      const requestDepositAmt = assetClassValueOf(
+        accountUtxo.assets,
+        iassetAssetClass,
+      );
+
+      const poolAddr = mkStabilityPoolAddr(lucid, sysParams);
+
+      tx.readFrom([accountTokenScriptRef])
+        .collectFrom([accountUtxo], {
+          kind: 'selected',
+          inputs: [stabilityPoolUtxo, accountUtxo],
+          makeRedeemer: (indices) =>
+            serialiseStabilityPoolRedeemer({
+              ProcessRequestAccount: {
+                poolInputIdx: indices[0],
+                accountInputIdx: indices[1],
+                e2s2sIdxs: [],
+                currentTime: currentTime,
+              },
+            }),
+        })
+        .mintAssets(
+          mkAssetsOf(
+            fromSystemParamsAsset(sysParams.stabilityPoolParams.accountToken),
+            1n,
           ),
-          stabilityPoolDatum.poolSnapshot.productVal,
+          Data.void(),
+        )
+        .pay.ToContract(
+          poolAddr,
+          {
+            kind: 'inline',
+            value: serialiseStabilityPoolDatum({
+              StabilityPool: liquidationHelper(
+                {
+                  ...stabilityPoolDatum,
+                  state: {
+                    ...stabilityPoolDatum.state,
+                    depositVal: spAdd(
+                      stabilityPoolDatum.state.depositVal,
+                      mkSPInteger(requestDepositAmt),
+                    ),
+                  },
+                },
+                adaAssetClass,
+                0n,
+                BigInt(sysParams.stabilityPoolParams.accountCreateFeeLovelaces),
+              ),
+            }),
+          },
+          addAssets(
+            stabilityPoolUtxo.assets,
+            mkAssetsOf(iassetAssetClass, requestDepositAmt),
+            mkLovelacesOf(
+              BigInt(sysParams.stabilityPoolParams.accountCreateFeeLovelaces),
+            ),
+          ),
+        )
+        .pay.ToContract(
+          poolAddr,
+          {
+            kind: 'inline',
+            value: serialiseStabilityPoolDatum({
+              Account: {
+                owner: accountDatum.owner,
+                iasset: stabilityPoolDatum.iasset,
+                state: {
+                  ...stabilityPoolDatum.state,
+                  depositVal: mkSPInteger(requestDepositAmt),
+                },
+                assetSums: stabilityPoolDatum.assetStates.map(([key, val]) => [
+                  key,
+                  val.currentSumVal,
+                ]),
+                request: null,
+                lastRequestProcessingTime: currentTime,
+              },
+            }),
+          },
+          addAssets(
+            mkAssetsOf(
+              fromSystemParamsAsset(sysParams.stabilityPoolParams.accountToken),
+              1n,
+            ),
+            mkLovelacesOf(lovelacesAmt(accountUtxo.assets)),
+          ),
+        );
+    })
+    .with({ Adjust: P.select() }, async (adjustContent) => {
+      const iassetDatum = parseIAssetDatumOrThrow(
+        getInlineDatumOrThrow(iAssetUtxo),
+      );
+
+      const accountDepositChange = adjustContent.amount;
+      const outputAddress = addressToBech32(
+        adjustContent.outputAddress,
+        lucid.config().network!,
+      );
+
+      const e2s2sIdxs = await findRelevantE2s2sIdxs(
+        lucid,
+        stabilityPoolDatum,
+        accountDatum.state,
+        allE2s2sSnapshotOrefs,
+      );
+
+      const { updatedAccountContent, reward } = updateAccount(
+        stabilityPoolDatum,
+        accountDatum,
+        e2s2sIdxs,
+      );
+
+      const isDepositOrRewardWithdrawal = accountDepositChange >= 0;
+
+      const accountBalanceChange = isDepositOrRewardWithdrawal
+        ? accountDepositChange
+        : bigintMax(
+            accountDepositChange,
+            -fromSPInteger(updatedAccountContent.state.depositVal),
+          );
+
+      const newPoolDepositExcludingFee = spZeroNegatives(
+        spAdd(
+          stabilityPoolDatum.state.depositVal,
+          mkSPInteger(accountBalanceChange),
         ),
-        newDeposit,
-      ),
-    );
+      );
 
-    const newStabilityPoolSnapshot: StabilityPoolSnapshot = {
-      ...stabilityPoolDatum.poolSnapshot,
-      depositVal: newDeposit,
-      sumVal: newSum,
-    };
-
-    const newEpochToScaleToSum: EpochToScaleToSum = setSumInEpochToScaleToSum(
-      stabilityPoolDatum.epochToScaleToSum,
-      stabilityPoolDatum.poolSnapshot.epoch,
-      stabilityPoolDatum.poolSnapshot.scale,
-      newSum,
-    );
+      const withdrawalFeeAmt =
+        isDepositOrRewardWithdrawal || newPoolDepositExcludingFee.value === 0n
+          ? 0n
+          : calculateFeeFromRatio(
+              iassetDatum.stabilityPoolWithdrawalFeeRatio,
+              -accountBalanceChange,
+            );
+
+      const newPoolState = updatePoolStateWhenWithdrawalFee(withdrawalFeeAmt, {
+        ...stabilityPoolDatum.state,
+        depositVal: newPoolDepositExcludingFee,
+      });
+
+      const { e2s2sRefInputs, mkProcessRequestAccountRedeemerContent } =
+        createProcessRequestAccountRedeemer(
+          e2s2sIdxs,
+          baseRefInputs,
+          currentTime,
+        );
+
+      if (e2s2sRefInputs.length > 0) {
+        tx.readFrom(e2s2sRefInputs);
+      }
+
+      tx.collectFrom([accountUtxo], {
+        kind: 'selected',
+        inputs: [stabilityPoolUtxo, accountUtxo],
+        makeRedeemer: (indices) => {
+          return serialiseStabilityPoolRedeemer({
+            ProcessRequestAccount: mkProcessRequestAccountRedeemerContent(
+              indices[0],
+              indices[1],
+            ),
+          });
+        },
+      }).pay.ToContract(
+        stabilityPoolUtxo.address,
+        {
+          kind: 'inline',
+          value: serialiseStabilityPoolDatum({
+            StabilityPool: {
+              ...stabilityPoolDatum,
+              state: newPoolState,
+            },
+          }),
+        },
+        addAssets(
+          stabilityPoolUtxo.assets,
+          negateAssets(reward),
+          mkAssetsOf(iassetAssetClass, accountBalanceChange + withdrawalFeeAmt),
+        ),
+      );
 
-    const stabilityPoolAssetToken = stabilityPoolUtxo.assets[iassetUnit] ?? 0n;
-    const poolOutputValue = {
-      lovelace:
-        stabilityPoolUtxo.assets.lovelace +
-        BigInt(params.stabilityPoolParams.accountCreateFeeLovelaces),
-      [params.stabilityPoolParams.stabilityPoolToken[0].unCurrencySymbol +
-      fromText(params.stabilityPoolParams.stabilityPoolToken[1].unTokenName)]:
-        1n,
-      [params.stabilityPoolParams.assetSymbol.unCurrencySymbol +
-      fromText(asset)]: stabilityPoolAssetToken + reqAmount,
-    };
+      const theoreticalOwnerOutputVal = addAssets(
+        reward,
+        isDepositOrRewardWithdrawal
+          ? {}
+          : mkAssetsOf(
+              iassetAssetClass,
+              -accountBalanceChange - withdrawalFeeAmt,
+            ),
+      );
+      const ownerOutputDat = serialiseActionReturnDatum({
+        IndigoStabilityPoolAccountAdjustment: {
+          txHash: fromHex(accountUtxo.txHash),
+          outputIndex: BigInt(accountUtxo.outputIndex),
+        },
+      });
 
-    tx.mintAssets(
-      {
-        [params.stabilityPoolParams.accountToken[0].unCurrencySymbol +
-        fromText(params.stabilityPoolParams.accountToken[1].unTokenName)]: 1n,
-      },
-      Data.to(new Constr(0, [])),
-    );
+      const ownerOutputMinUtxoLovelace = estimateUtxoMinLovelace(
+        lucid.config().protocolParameters!,
+        outputAddress,
+        theoreticalOwnerOutputVal,
+        { InlineDatum: { datum: ownerOutputDat } },
+      );
 
-    tx.pay.ToContract(
-      stabilityPoolUtxo.address,
-      {
-        kind: 'inline',
-        value: serialiseStabilityPoolDatum({
-          StabilityPool: {
-            ...stabilityPoolDatum,
-            poolSnapshot: newStabilityPoolSnapshot,
-            epochToScaleToSum: newEpochToScaleToSum,
+      // Add extra lovelaces only when needed to reach minUTxo lovelaces.
+      const extraOwnerOutputLovelacesAmt =
+        lovelacesAmt(theoreticalOwnerOutputVal) >= ownerOutputMinUtxoLovelace
+          ? 0n
+          : ownerOutputMinUtxoLovelace -
+            lovelacesAmt(theoreticalOwnerOutputVal);
+
+      const actualOwnerOutputVal = addAssets(
+        theoreticalOwnerOutputVal,
+        mkLovelacesOf(extraOwnerOutputLovelacesAmt),
+      );
+
+      const accountOutputDat = serialiseStabilityPoolDatum({
+        Account: {
+          ...updatedAccountContent,
+          state: {
+            ...updatedAccountContent.state,
+            depositVal: spAdd(
+              updatedAccountContent.state.depositVal,
+              mkSPInteger(accountBalanceChange),
+            ),
           },
-        }),
-      },
-      poolOutputValue,
-    );
+          request: null,
+          lastRequestProcessingTime: currentTime,
+        },
+      });
 
-    tx.pay.ToContract(
-      stabilityPoolUtxo.address,
-      {
-        kind: 'inline',
-        value: serialiseStabilityPoolDatum({
-          Account: {
-            ...accountDatum,
-            accountSnapshot: newAccountSnapshot,
-            request: null,
+      const accountOutputValWithoutAda = mkAssetsOf(
+        fromSystemParamsAsset(sysParams.stabilityPoolParams.accountToken),
+        1n,
+      );
+
+      const accountOutMinUtxoLovelace = estimateUtxoMinLovelace(
+        lucid.config().protocolParameters!,
+        stabilityPoolUtxo.address,
+        accountOutputValWithoutAda,
+        { InlineDatum: { datum: accountOutputDat } },
+      );
+
+      // TODO: include Tx fee here.
+      const accountOutputAdaAmt =
+        lovelacesAmt(accountUtxo.assets) - extraOwnerOutputLovelacesAmt;
+
+      // This is to prevent spending ADA from the wallet submitting the request processing Tx.
+      if (accountOutputAdaAmt < accountOutMinUtxoLovelace) {
+        throw new Error("Account doesn't have enough ADA to be processed.");
+      }
+
+      tx.pay
+        .ToContract(
+          stabilityPoolUtxo.address,
+          {
+            kind: 'inline',
+            value: accountOutputDat,
           },
-        }),
-      },
-      {
-        lovelace:
-          accountUtxo.assets.lovelace -
-          BigInt(params.stabilityPoolParams.accountCreateFeeLovelaces),
-        [params.stabilityPoolParams.accountToken[0].unCurrencySymbol +
-        fromText(params.stabilityPoolParams.accountToken[1].unTokenName)]: 1n,
-      },
-    );
-  } else if ('Adjust' in accountDatum.request) {
-    const amount = accountDatum.request.Adjust.amount;
-    const outputAddress = addressToBech32(
-      accountDatum.request.Adjust.outputAddress,
-      lucid.config().network!,
-    );
-    const myAddress = await lucid.wallet().address();
-    const [updatedAccountSnapshot, reward, refInputs] = adjustmentHelper(
-      stabilityPoolUtxo,
-      newSnapshotUtxo,
-      stabilityPoolDatum.poolSnapshot,
-      stabilityPoolDatum.epochToScaleToSum,
-      accountDatum.accountSnapshot,
-    );
-    const govDatum: GovDatum = parseGovDatumOrThrow(
-      getInlineDatumOrThrow(govUtxo),
-    );
-    const iassetDatum: IAssetContent = parseIAssetDatumOrThrow(
-      getInlineDatumOrThrow(iAssetUtxo),
-    );
-    const rewardLovelacesFee = calculateFeeFromPercentage(
-      govDatum.protocolParams.collateralFeePercentage,
-      reward,
-    );
-    const isDepositOrRewardWithdrawal: boolean = amount > 0n;
-    const bigIntMax = (...args: bigint[]): bigint =>
-      args.reduce((m, e) => (e > m ? e : m));
-
-    const balanceChange: bigint = isDepositOrRewardWithdrawal
-      ? amount
-      : bigIntMax(amount, -fromSPInteger(updatedAccountSnapshot.depositVal));
-    const newAccountSnapshot: StabilityPoolSnapshot = {
-      ...updatedAccountSnapshot,
-      depositVal: spAdd(
-        updatedAccountSnapshot.depositVal,
-        mkSPInteger(balanceChange),
-      ),
-    };
-    const _newPoolDepositExcludingFee = spAdd(
-      stabilityPoolDatum.poolSnapshot.depositVal,
-      mkSPInteger(balanceChange),
-    );
-    const newPoolDepositExcludingFee =
-      _newPoolDepositExcludingFee.value > 0n
-        ? _newPoolDepositExcludingFee
-        : mkSPInteger(0n);
-    const withdrawalFee =
-      isDepositOrRewardWithdrawal || newPoolDepositExcludingFee.value === 0n
-        ? 0n
-        : calculateFeeFromPercentage(
-            iassetDatum.stabilityPoolWithdrawalFeePercentage,
-            -balanceChange,
-          );
-    const newPoolDeposit = spAdd(
-      newPoolDepositExcludingFee,
-      mkSPInteger(withdrawalFee),
-    );
-    const newPoolProduct =
-      withdrawalFee === 0n
-        ? stabilityPoolDatum.poolSnapshot.productVal
-        : spMul(
-            stabilityPoolDatum.poolSnapshot.productVal,
-            spAdd(
-              mkSPInteger(1n),
-              spDiv(mkSPInteger(withdrawalFee), newPoolDepositExcludingFee),
-            ),
-          );
-    const newPoolSum = spAdd(
-      stabilityPoolDatum.poolSnapshot.sumVal,
-      spDiv(
-        spMul(
-          mkSPInteger(
-            BigInt(params.stabilityPoolParams.accountAdjustmentFeeLovelaces),
+          addAssets(
+            accountOutputValWithoutAda,
+            mkLovelacesOf(accountOutputAdaAmt),
           ),
-          newPoolProduct,
+        )
+        .pay.ToAddressWithData(
+          outputAddress,
+          {
+            kind: 'inline',
+            value: ownerOutputDat,
+          },
+          actualOwnerOutputVal,
+        );
+    })
+    .with({ Close: P.select() }, async (closeContent) => {
+      const accountTokenScriptRef = matchSingle(
+        await lucid.utxosByOutRef([
+          fromSystemParamsScriptRef(
+            sysParams.scriptReferences.authTokenPolicies.accountTokenRef,
+          ),
+        ]),
+        (_) =>
+          new Error('Expected a single cdp auth token policy Ref Script UTXO'),
+      );
+
+      const iassetDatum = parseIAssetDatumOrThrow(
+        getInlineDatumOrThrow(iAssetUtxo),
+      );
+
+      const outputAddress = addressToBech32(
+        closeContent.outputAddress,
+        lucid.config().network!,
+      );
+
+      const e2s2sIdxs = await findRelevantE2s2sIdxs(
+        lucid,
+        stabilityPoolDatum,
+        accountDatum.state,
+        allE2s2sSnapshotOrefs,
+      );
+
+      const { updatedAccountContent, reward } = updateAccount(
+        stabilityPoolDatum,
+        accountDatum,
+        e2s2sIdxs,
+      );
+
+      const newPoolDepositExcludingFee = spZeroNegatives(
+        spSub(
+          stabilityPoolDatum.state.depositVal,
+          updatedAccountContent.state.depositVal,
         ),
-        newPoolDeposit,
-      ),
-    );
-    const newPoolSnapshot: StabilityPoolSnapshot = {
-      ...stabilityPoolDatum.poolSnapshot,
-      depositVal: newPoolDeposit,
-      sumVal: newPoolSum,
-      productVal: newPoolProduct,
-    };
-    const newEpochToScaleToSum: EpochToScaleToSum = setSumInEpochToScaleToSum(
-      stabilityPoolDatum.epochToScaleToSum,
-      stabilityPoolDatum.poolSnapshot.epoch,
-      stabilityPoolDatum.poolSnapshot.scale,
-      newPoolSum,
-    );
+      );
 
-    if (rewardLovelacesFee > 0n) {
-      await collectorFeeTx(rewardLovelacesFee, lucid, params, tx, collector);
-    }
-    tx.readFrom([govUtxo, iAssetUtxo, ...refInputs]);
-    tx.pay.ToContract(
-      stabilityPoolUtxo.address,
-      {
-        kind: 'inline',
-        value: serialiseStabilityPoolDatum({
-          StabilityPool: {
-            ...stabilityPoolDatum,
-            poolSnapshot: newPoolSnapshot,
-            epochToScaleToSum: newEpochToScaleToSum,
+      const withdrawnAmt = zeroNegatives(
+        fromSPInteger(updatedAccountContent.state.depositVal),
+      );
+
+      const withdrawalFeeAmt =
+        newPoolDepositExcludingFee.value === 0n
+          ? 0n
+          : calculateFeeFromRatio(
+              iassetDatum.stabilityPoolWithdrawalFeeRatio,
+              withdrawnAmt,
+            );
+
+      const newPoolState = updatePoolStateWhenWithdrawalFee(withdrawalFeeAmt, {
+        ...stabilityPoolDatum.state,
+        depositVal: newPoolDepositExcludingFee,
+      });
+
+      const { e2s2sRefInputs, mkProcessRequestAccountRedeemerContent } =
+        createProcessRequestAccountRedeemer(
+          e2s2sIdxs,
+          [...baseRefInputs, accountTokenScriptRef],
+          currentTime,
+        );
+
+      if (e2s2sRefInputs.length > 0) {
+        tx.readFrom(e2s2sRefInputs);
+      }
+
+      tx.readFrom([accountTokenScriptRef])
+        .collectFrom([accountUtxo], {
+          kind: 'selected',
+          inputs: [stabilityPoolUtxo, accountUtxo],
+          makeRedeemer: (indices) => {
+            return serialiseStabilityPoolRedeemer({
+              ProcessRequestAccount: mkProcessRequestAccountRedeemerContent(
+                indices[0],
+                indices[1],
+              ),
+            });
           },
-        }),
-      },
-      {
-        lovelace:
-          stabilityPoolUtxo.assets.lovelace +
-          BigInt(params.stabilityPoolParams.accountAdjustmentFeeLovelaces) -
-          reward,
-        [params.stabilityPoolParams.stabilityPoolToken[0].unCurrencySymbol +
-        fromText(params.stabilityPoolParams.stabilityPoolToken[1].unTokenName)]:
-          1n,
-        [params.stabilityPoolParams.assetSymbol.unCurrencySymbol +
-        fromText(asset)]:
-          stabilityPoolUtxo.assets[
-            params.stabilityPoolParams.assetSymbol.unCurrencySymbol +
-              fromText(asset)
-          ] +
-          balanceChange +
-          withdrawalFee,
-      },
-    );
-    tx.pay.ToContract(
-      stabilityPoolUtxo.address,
-      {
-        kind: 'inline',
-        value: serialiseStabilityPoolDatum({
-          Account: {
-            ...accountDatum,
-            accountSnapshot: newAccountSnapshot,
-            request: null,
+        })
+        .mintAssets(
+          mkAssetsOf(
+            fromSystemParamsAsset(sysParams.stabilityPoolParams.accountToken),
+            -1n,
+          ),
+          Data.void(),
+        )
+        .pay.ToContract(
+          stabilityPoolUtxo.address,
+          {
+            kind: 'inline',
+            value: serialiseStabilityPoolDatum({
+              StabilityPool: {
+                ...stabilityPoolDatum,
+                state: newPoolState,
+              },
+            }),
           },
-        }),
-      },
-      {
-        lovelace:
-          accountUtxo.assets.lovelace -
-          BigInt(params.stabilityPoolParams.accountAdjustmentFeeLovelaces) -
-          2_000_000n,
-        [params.stabilityPoolParams.accountToken[0].unCurrencySymbol +
-        fromText(params.stabilityPoolParams.accountToken[1].unTokenName)]: 1n,
-      },
-    );
-    if (myAddress !== outputAddress) {
-      tx.pay.ToAddressWithData(
-        outputAddress,
-        {
-          kind: 'inline',
-          value: Data.to(
-            {
-              IndigoStabilityPoolAccountAdjustment: {
-                spent_account: {
-                  txHash: { hash: accountUtxo.txHash },
-                  outputIndex: BigInt(accountUtxo.outputIndex),
-                },
+          addAssets(
+            stabilityPoolUtxo.assets,
+            negateAssets(reward),
+            mkAssetsOf(iassetAssetClass, -withdrawnAmt + withdrawalFeeAmt),
+          ),
+        )
+        .pay.ToAddressWithData(
+          outputAddress,
+          {
+            kind: 'inline',
+            value: serialiseActionReturnDatum({
+              IndigoStabilityPoolAccountClosure: {
+                txHash: fromHex(accountUtxo.txHash),
+                outputIndex: BigInt(accountUtxo.outputIndex),
               },
-            },
-            ActionReturnDatum,
+            }),
+          },
+          addAssets(
+            mkLovelacesOf(lovelacesAmt(accountUtxo.assets)),
+            reward,
+            mkAssetsOf(iassetAssetClass, withdrawnAmt - withdrawalFeeAmt),
           ),
-        },
-        {
-          lovelace: reward - rewardLovelacesFee + 2_000_000n,
-          ...(!isDepositOrRewardWithdrawal
-            ? {
-                [params.stabilityPoolParams.assetSymbol.unCurrencySymbol +
-                fromText(asset)]: -balanceChange - withdrawalFee,
-              }
-            : {}),
-        },
-      );
-    } else {
-      // TODO: User is self-handling the process request, so we will need to handle the change datum
-    }
-  } else if ('Close' in accountDatum.request) {
-    const outputAddress = addressToBech32(
-      accountDatum.request.Close.outputAddress,
-      lucid.config().network!,
-    );
-    const myAddress = await lucid.wallet().address();
-    const [updatedAccountSnapshot, reward, refInputs] = adjustmentHelper(
-      stabilityPoolUtxo,
-      newSnapshotUtxo,
-      stabilityPoolDatum.poolSnapshot,
-      stabilityPoolDatum.epochToScaleToSum,
-      accountDatum.accountSnapshot,
-    );
-    const govDatum: GovDatum = parseGovDatumOrThrow(
-      getInlineDatumOrThrow(govUtxo),
-    );
-    const iassetDatum: IAssetContent = parseIAssetDatumOrThrow(
-      getInlineDatumOrThrow(iAssetUtxo),
-    );
-    const rewardLovelacesFee = calculateFeeFromPercentage(
-      govDatum.protocolParams.collateralFeePercentage,
-      reward,
-    );
-    const fund = updatedAccountSnapshot.depositVal;
-    const newPoolDepositExcludingFee = spSub(
-      stabilityPoolDatum.poolSnapshot.depositVal,
-      fund,
-    );
-    const withdrawnAmt = fund.value < 0n ? mkSPInteger(0n) : fund;
-    const withdrawalFeeAmount =
-      newPoolDepositExcludingFee.value === 0n
-        ? 0n
-        : calculateFeeFromPercentage(
-            iassetDatum.stabilityPoolWithdrawalFeePercentage,
-            withdrawnAmt.value,
-          );
-    const [newPoolDeposit, newPoolProduct] = updatePoolSnapshotWithdrawalFee(
-      mkSPInteger(withdrawalFeeAmount),
-      newPoolDepositExcludingFee,
-      stabilityPoolDatum.poolSnapshot,
-    );
-    const newPoolSnapshot: StabilityPoolSnapshot = {
-      ...stabilityPoolDatum.poolSnapshot,
-      depositVal: newPoolDeposit,
-      productVal: newPoolProduct,
-    };
-    const accountTokenRef = await scriptRef(
-      params.scriptReferences.authTokenPolicies.accountTokenRef,
-      lucid,
-    );
-    await collectorFeeTx(rewardLovelacesFee, lucid, params, tx, collector);
-    tx.readFrom([govUtxo, iAssetUtxo, accountTokenRef, ...refInputs]);
-    tx.mintAssets(
+        );
+    })
+    .exhaustive();
+
+  return tx;
+}
+
+export async function createE2s2sSnapshots(
+  stabilityPoolOref: OutRef,
+  sysParams: SystemParams,
+  lucid: LucidEvolution,
+): Promise<TxBuilder> {
+  const stabilityPoolRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.stabilityPoolValidatorRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single stability pool Ref Script UTXO'),
+  );
+  const snapshotE2s2sPolicyRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.authTokenPolicies
+          .snapshotEpochToScaleToSumTokenRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single snapshot e2s2s policy Ref Script UTXO'),
+  );
+
+  const spUtxo = matchSingle(
+    await lucid.utxosByOutRef([stabilityPoolOref]),
+    (_) => new Error('Expected a single stability pool UTXO'),
+  );
+  const spDatum = parseStabilityPoolDatumOrThrow(getInlineDatumOrThrow(spUtxo));
+
+  const [newSnapshotDatums, newAssetStates] =
+    partitionEpochToScaleToSums(spDatum);
+
+  if (newSnapshotDatums.length === 0) {
+    throw new Error('There has to be a snapshot being created.');
+  }
+
+  const snapshotAc = fromSystemParamsAsset(
+    sysParams.stabilityPoolParams.snapshotEpochToScaleToSumToken,
+  );
+
+  const tx = lucid
+    .newTx()
+    .readFrom([stabilityPoolRefScriptUtxo, snapshotE2s2sPolicyRefScriptUtxo])
+    .collectFrom(
+      [spUtxo],
+      serialiseStabilityPoolRedeemer('RecordEpochToScaleToSum'),
+    )
+    .mintAssets(
+      mkAssetsOf(snapshotAc, BigInt(newSnapshotDatums.length)),
+      Data.void(),
+    )
+    .pay.ToContract(
+      spUtxo.address,
       {
-        [params.stabilityPoolParams.accountToken[0].unCurrencySymbol +
-        fromText(params.stabilityPoolParams.accountToken[1].unTokenName)]: -1n,
+        kind: 'inline',
+        value: serialiseStabilityPoolDatum({
+          StabilityPool: { ...spDatum, assetStates: newAssetStates },
+        }),
       },
-      Data.to(new Constr(0, [])),
+      spUtxo.assets,
     );
-    const assetOutputAmountForSP =
-      stabilityPoolUtxo.assets[
-        params.stabilityPoolParams.assetSymbol.unCurrencySymbol +
-          fromText(asset)
-      ] -
-      fromSPInteger(withdrawnAmt) -
-      withdrawalFeeAmount;
+
+  for (const newDatum of newSnapshotDatums) {
     tx.pay.ToContract(
-      stabilityPoolUtxo.address,
+      spUtxo.address,
       {
         kind: 'inline',
         value: serialiseStabilityPoolDatum({
-          StabilityPool: {
-            ...stabilityPoolDatum,
-            poolSnapshot: newPoolSnapshot,
-          },
+          SnapshotEpochToScaleToSum: newDatum,
         }),
       },
-      {
-        lovelace: stabilityPoolUtxo.assets.lovelace - reward,
-        [params.stabilityPoolParams.stabilityPoolToken[0].unCurrencySymbol +
-        fromText(params.stabilityPoolParams.stabilityPoolToken[1].unTokenName)]:
-          1n,
-        ...(assetOutputAmountForSP > 0n
-          ? {
-              [params.stabilityPoolParams.assetSymbol.unCurrencySymbol +
-              fromText(asset)]: assetOutputAmountForSP,
-            }
-          : {}),
-      },
+      mkAssetsOf(snapshotAc, 1n),
     );
-    if (myAddress !== outputAddress) {
-      tx.pay.ToAddressWithData(
-        outputAddress,
-        {
-          kind: 'inline',
-          value: Data.to(
-            {
-              IndigoStabilityPoolAccountClosure: {
-                closed_account: {
-                  txHash: { hash: accountUtxo.txHash },
-                  outputIndex: BigInt(accountUtxo.outputIndex),
-                },
-              },
-            },
-            ActionReturnDatum,
-          ),
-        },
-        {
-          lovelace: accountUtxo.assets.lovelace + reward - rewardLovelacesFee,
-          [params.stabilityPoolParams.assetSymbol.unCurrencySymbol +
-          fromText(asset)]: fromSPInteger(withdrawnAmt) - withdrawalFeeAmount,
-        },
-      );
-    }
   }
 
   return tx;
@@ -671,29 +803,27 @@ export async function annulRequest(
   params: SystemParams,
   lucid: LucidEvolution,
 ): Promise<TxBuilder> {
-  const stabilityPoolScriptRef = await scriptRef(
-    params.scriptReferences.stabilityPoolValidatorRef,
-    lucid,
+  const stabilityPoolRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        params.scriptReferences.stabilityPoolValidatorRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single stability pool Ref Script UTXO'),
   );
-
-  const oldAccountDatum: AccountContent = parseAccountDatum(
+  const oldAccountDatum: AccountContent = parseAccountDatumOrThrow(
     getInlineDatumOrThrow(accountUtxo),
   );
 
   const tx = lucid
     .newTx()
-    .readFrom([stabilityPoolScriptRef])
+    .readFrom([stabilityPoolRefScriptUtxo])
     .collectFrom([accountUtxo], serialiseStabilityPoolRedeemer('AnnulRequest'))
     .addSignerKey(toHex(oldAccountDatum.owner));
 
   if (oldAccountDatum.request !== 'Create') {
     tx.pay.ToContract(
-      credentialToAddress(lucid.config().network!, {
-        hash: validatorToScriptHash(
-          mkStabilityPoolValidatorFromSP(params.stabilityPoolParams),
-        ),
-        type: 'Script',
-      }),
+      accountUtxo.address,
       {
         kind: 'inline',
         value: serialiseStabilityPoolDatum({