@indigo-labs/indigo-sdk 0.2.42 → 0.3.1

package/src/contracts/stableswap/transactions.ts

@@ -0,0 +1,647 @@
+import {
+  addAssets,
+  Address,
+  credentialToAddress,
+  Data,
+  fromHex,
+  fromText,
+  LucidEvolution,
+  OutRef,
+  paymentCredentialOf,
+  sortUTxOs,
+  toHex,
+  TxBuilder,
+  UTxO,
+  validatorToScriptHash,
+} from '@lucid-evolution/lucid';
+import {
+  fromSystemParamsScriptRef,
+  SystemParams,
+} from '../../types/system-params';
+import { mkStableswapValidatorFromSP } from './scripts';
+import { estimateUtxoMinLovelace } from '../../utils/lucid-utils';
+import {
+  parseStableswapOrderDatumOrThrow,
+  serialiseStableswapOrderDatum,
+  serialiseStableswapOrderRedeemer,
+  StableswapOrderDatum,
+} from './types-new';
+import {
+  AssetClass,
+  addressFromBech32,
+  addressToBech32,
+  getInlineDatumOrThrow,
+  matchSingle,
+  mkAssetsOf,
+  mkLovelacesOf,
+  lovelacesAmt,
+  isSameOutRef,
+  assetClassValueOf,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import {
+  parseStableswapPoolDatumOrThrow,
+  serialiseCdpRedeemer,
+  serialiseStableswapPoolDatum,
+  StableswapPoolContent,
+} from '../cdp/types-new';
+import { calculateFeeFromRatio } from '../../utils/indigo-helpers';
+import { array as A, function as F } from 'fp-ts';
+import { isEmpty } from 'fp-ts/lib/Array';
+import { BASE_MAX_EXECUTION_FEE, createDestinationDatum } from './helpers';
+import * as Core from '@evolution-sdk/evolution';
+import { treasuryFeeTx } from '../treasury/transactions';
+import {
+  Rational,
+  rationalDiv,
+  rationalFloor,
+  rationalFromInt,
+  rationalMul,
+} from '../../types/rational';
+
+type StableswapInfo = {
+  suppliedCollateralAsset: bigint;
+  suppliedIasset: bigint;
+  owedCollateralAsset: bigint;
+  owedIasset: bigint;
+  mintingFee: bigint;
+  redemptionFee: bigint;
+};
+
+type StableswapOrderInfo = {
+  utxo: UTxO;
+  datum: StableswapOrderDatum;
+  swapInfo: StableswapInfo;
+};
+
+export async function createStableswapOrder(
+  iasset: string,
+  collateralAsset: AssetClass,
+  amount: bigint,
+  minting: boolean,
+  poolDatum: StableswapPoolContent,
+  params: SystemParams,
+  lucid: LucidEvolution,
+  destinationAddress?: Address,
+  destinationInlineDatum?: Core.Data.Data,
+  maxExecutionFee: bigint = BASE_MAX_EXECUTION_FEE,
+  additionalLovelaces: bigint = 0n,
+  maxFeeRatio?: Rational,
+): Promise<TxBuilder> {
+  const myAddress = await lucid.wallet().address();
+
+  const pkh = paymentCredentialOf(myAddress);
+
+  const datum: StableswapOrderDatum = {
+    iasset: fromHex(fromText(iasset)),
+    collateralAsset: collateralAsset,
+    owner: fromHex(pkh.hash),
+    destination: addressFromBech32(destinationAddress ?? myAddress),
+    destinationInlineDatum: destinationInlineDatum ?? null,
+    maxExecutionFee: maxExecutionFee,
+    maxFeeRatio:
+      maxFeeRatio ??
+      (minting ? poolDatum.mintingFeeRatio : poolDatum.redemptionFeeRatio),
+  };
+
+  const assetsToSwap = minting
+    ? mkAssetsOf(collateralAsset, amount)
+    : mkAssetsOf(
+        {
+          currencySymbol: fromHex(
+            params.stableswapParams.iassetSymbol.unCurrencySymbol,
+          ),
+          tokenName: fromHex(fromText(iasset)),
+        },
+        amount,
+      );
+
+  // This is an approximation of the amount of lovelace that will be needed to pay for the output.
+  const expectedOutputLovelaces = estimateUtxoMinLovelace(
+    lucid.config().protocolParameters!,
+    myAddress,
+    assetsToSwap,
+    {
+      kind: 'inline',
+      value: createDestinationDatum(destinationInlineDatum ?? null, {
+        txHash:
+          '0000000000000000000000000000000000000000000000000000000000000000',
+        outputIndex: 0,
+      }),
+    },
+  );
+
+  const roundedExpectedOutputLovelaces =
+    (expectedOutputLovelaces / 1_000_000n + 1n) * 1_000_000n;
+
+  return lucid.newTx().pay.ToContract(
+    credentialToAddress(lucid.config().network!, {
+      hash: validatorToScriptHash(
+        mkStableswapValidatorFromSP(params.stableswapParams),
+      ),
+      type: 'Script',
+    }),
+    {
+      kind: 'inline',
+      value: serialiseStableswapOrderDatum(datum),
+    },
+    addAssets(
+      assetsToSwap,
+      mkLovelacesOf(
+        roundedExpectedOutputLovelaces + maxExecutionFee + additionalLovelaces,
+      ),
+    ),
+  );
+}
+
+export async function cancelStableswapOrder(
+  stableswapOrderOref: OutRef,
+  sysParams: SystemParams,
+  lucid: LucidEvolution,
+): Promise<TxBuilder> {
+  const stableswapScriptRefUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.stableswapValidatorRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single Stableswap Ref Script UTXO'),
+  );
+
+  const stableswapOrderUtxo = matchSingle(
+    await lucid.utxosByOutRef([stableswapOrderOref]),
+    (_) => new Error('Expected a single Stableswap Order UTXO.'),
+  );
+
+  const stableswapOrderDatum = parseStableswapOrderDatumOrThrow(
+    getInlineDatumOrThrow(stableswapOrderUtxo),
+  );
+
+  return lucid
+    .newTx()
+    .readFrom([stableswapScriptRefUtxo])
+    .collectFrom(
+      [stableswapOrderUtxo],
+      serialiseStableswapOrderRedeemer('CancelStableswapOrder'),
+    )
+    .addSignerKey(toHex(stableswapOrderDatum.owner));
+}
+
+export async function batchProcessStableswapOrders(
+  stableswapOrderOrefs: OutRef[],
+  stableswapPoolOref: OutRef,
+  treasuryOref: OutRef,
+  sysParams: SystemParams,
+  lucid: LucidEvolution,
+): Promise<TxBuilder> {
+  const stableswapScriptRefUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.stableswapValidatorRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single Stableswap Ref Script UTXO'),
+  );
+
+  const cdpScriptRefUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef),
+    ]),
+    (_) => new Error('Expected a single CDP Ref Script UTXO'),
+  );
+
+  const iAssetTokenPolicyRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.iAssetTokenPolicyRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single iasset token policy Ref Script UTXO'),
+  );
+
+  if (isEmpty(stableswapOrderOrefs)) {
+    throw new Error('At least one order must be provided.');
+  }
+
+  const stableswapOrderUtxos = await lucid.utxosByOutRef(stableswapOrderOrefs);
+
+  const sortedStableswapOrderUtxos = sortUTxOs(
+    stableswapOrderUtxos,
+    'Canonical',
+  );
+
+  if (sortedStableswapOrderUtxos.length !== stableswapOrderOrefs.length) {
+    throw new Error('Expected certain number of orders');
+  }
+
+  const mainOrderUtxo = sortedStableswapOrderUtxos[0];
+
+  const mainOrderDatum = parseStableswapOrderDatumOrThrow(
+    getInlineDatumOrThrow(mainOrderUtxo),
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      sysParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: mainOrderDatum.iasset,
+  };
+
+  const collateralAc = mainOrderDatum.collateralAsset;
+
+  const stableswapPoolUtxo = matchSingle(
+    await lucid.utxosByOutRef([stableswapPoolOref]),
+    (_) => new Error('Expected a single cdp UTXO'),
+  );
+
+  const stableswapPoolDatum = parseStableswapPoolDatumOrThrow(
+    getInlineDatumOrThrow(stableswapPoolUtxo),
+  );
+
+  const ordersInfo: StableswapOrderInfo[] = sortedStableswapOrderUtxos.map(
+    (orderUtxo) => {
+      const orderDatum = parseStableswapOrderDatumOrThrow(
+        getInlineDatumOrThrow(orderUtxo),
+      );
+
+      if (
+        toHex(orderDatum.iasset) != toHex(mainOrderDatum.iasset) ||
+        toHex(orderDatum.collateralAsset.currencySymbol) !=
+          toHex(mainOrderDatum.collateralAsset.currencySymbol) ||
+        toHex(orderDatum.collateralAsset.tokenName) !=
+          toHex(mainOrderDatum.collateralAsset.tokenName)
+      ) {
+        throw new Error('Wrong batch of orders');
+      }
+
+      const suppliedIasset = assetClassValueOf(orderUtxo.assets, iassetAc);
+      const suppliedCollateralAsset = assetClassValueOf(
+        orderUtxo.assets,
+        collateralAc,
+      );
+
+      if (
+        (suppliedIasset != 0n && suppliedCollateralAsset != 0n) ||
+        (suppliedIasset == 0n && suppliedCollateralAsset == 0n)
+      ) {
+        throw new Error(
+          'An order must supply either iAsset or collateral asset',
+        );
+      }
+
+      const isMinting = suppliedCollateralAsset > 0n;
+
+      const isOneToOne =
+        stableswapPoolDatum.collateralToIassetRatio.numerator ===
+        stableswapPoolDatum.collateralToIassetRatio.denominator;
+
+      if (isMinting) {
+        // Mint order with one to one ratio case.
+        if (isOneToOne) {
+          const fee = calculateFeeFromRatio(
+            stableswapPoolDatum.mintingFeeRatio,
+            suppliedCollateralAsset,
+          );
+
+          return {
+            utxo: orderUtxo,
+            datum: orderDatum,
+            swapInfo: {
+              suppliedCollateralAsset: suppliedCollateralAsset,
+              suppliedIasset: 0n,
+              owedCollateralAsset: 0n,
+              owedIasset: suppliedCollateralAsset - fee,
+              mintingFee: fee,
+              redemptionFee: 0n,
+            },
+          };
+          // Mint order with any ratio case.
+        } else {
+          const iAssetConversion = rationalFloor(
+            rationalDiv(
+              rationalFromInt(suppliedCollateralAsset),
+              stableswapPoolDatum.collateralToIassetRatio,
+            ),
+          );
+
+          const attemptedNormalizedCollateral = rationalFloor(
+            rationalMul(
+              rationalFromInt(iAssetConversion),
+              stableswapPoolDatum.collateralToIassetRatio,
+            ),
+          );
+
+          const normalizedCollateralSupplied =
+            rationalFloor(
+              rationalDiv(
+                rationalFromInt(attemptedNormalizedCollateral),
+                stableswapPoolDatum.collateralToIassetRatio,
+              ),
+            ) != iAssetConversion
+              ? suppliedCollateralAsset
+              : attemptedNormalizedCollateral;
+
+          const fee = calculateFeeFromRatio(
+            stableswapPoolDatum.mintingFeeRatio,
+            iAssetConversion,
+          );
+
+          return {
+            utxo: orderUtxo,
+            datum: orderDatum,
+            swapInfo: {
+              suppliedCollateralAsset: normalizedCollateralSupplied,
+              suppliedIasset: 0n,
+              owedCollateralAsset: 0n,
+              owedIasset: iAssetConversion - fee,
+              mintingFee: fee,
+              redemptionFee: 0n,
+            },
+          };
+        }
+        // Redeem order case
+      } else {
+        const fee = calculateFeeFromRatio(
+          stableswapPoolDatum.redemptionFeeRatio,
+          suppliedIasset,
+        );
+
+        const effectiveSuppliedIasset = suppliedIasset - fee;
+
+        // Redeem order with one to one ratio case
+        if (isOneToOne) {
+          return {
+            utxo: orderUtxo,
+            datum: orderDatum,
+            swapInfo: {
+              suppliedCollateralAsset: 0n,
+              suppliedIasset: effectiveSuppliedIasset,
+              owedCollateralAsset: effectiveSuppliedIasset,
+              owedIasset: 0n,
+              mintingFee: 0n,
+              redemptionFee: fee,
+            },
+          };
+          // Redeem order with any ratio case
+        } else {
+          const collateralConversion = rationalFloor(
+            rationalMul(
+              rationalFromInt(effectiveSuppliedIasset),
+              stableswapPoolDatum.collateralToIassetRatio,
+            ),
+          );
+
+          const attemptedNormalizedEffectiveIasset = rationalFloor(
+            rationalDiv(
+              rationalFromInt(collateralConversion),
+              stableswapPoolDatum.collateralToIassetRatio,
+            ),
+          );
+
+          const normalizedEffectiveIasset =
+            rationalFloor(
+              rationalMul(
+                rationalFromInt(attemptedNormalizedEffectiveIasset),
+                stableswapPoolDatum.collateralToIassetRatio,
+              ),
+            ) != collateralConversion
+              ? effectiveSuppliedIasset
+              : attemptedNormalizedEffectiveIasset;
+
+          return {
+            utxo: orderUtxo,
+            datum: orderDatum,
+            swapInfo: {
+              suppliedCollateralAsset: 0n,
+              suppliedIasset: normalizedEffectiveIasset,
+              owedCollateralAsset: rationalFloor(
+                rationalMul(
+                  rationalFromInt(effectiveSuppliedIasset),
+                  stableswapPoolDatum.collateralToIassetRatio,
+                ),
+              ),
+              owedIasset: 0n,
+              mintingFee: 0n,
+              redemptionFee: fee,
+            },
+          };
+        }
+      }
+    },
+  );
+
+  const totalSwapInfo = F.pipe(
+    ordersInfo,
+    A.reduce<StableswapOrderInfo, StableswapInfo>(
+      {
+        suppliedCollateralAsset: 0n,
+        suppliedIasset: 0n,
+        owedCollateralAsset: 0n,
+        owedIasset: 0n,
+        mintingFee: 0n,
+        redemptionFee: 0n,
+      },
+      (acc, orderInfo) => {
+        return {
+          suppliedCollateralAsset:
+            acc.suppliedCollateralAsset +
+            orderInfo.swapInfo.suppliedCollateralAsset,
+          suppliedIasset:
+            acc.suppliedIasset + orderInfo.swapInfo.suppliedIasset,
+          owedCollateralAsset:
+            acc.owedCollateralAsset + orderInfo.swapInfo.owedCollateralAsset,
+          owedIasset: acc.owedIasset + orderInfo.swapInfo.owedIasset,
+          mintingFee: acc.mintingFee + orderInfo.swapInfo.mintingFee,
+          redemptionFee: acc.redemptionFee + orderInfo.swapInfo.redemptionFee,
+        };
+      },
+    ),
+  );
+
+  const collateralAmtChangePool =
+    totalSwapInfo.suppliedCollateralAsset - totalSwapInfo.owedCollateralAsset;
+
+  const amountToMint =
+    totalSwapInfo.owedIasset -
+    totalSwapInfo.suppliedIasset +
+    totalSwapInfo.mintingFee;
+
+  const fee = totalSwapInfo.mintingFee + totalSwapInfo.redemptionFee;
+
+  const tx = lucid
+    .newTx()
+    .readFrom([
+      stableswapScriptRefUtxo,
+      cdpScriptRefUtxo,
+      iAssetTokenPolicyRefScriptUtxo,
+    ])
+    .collectFrom([stableswapPoolUtxo], {
+      kind: 'selected',
+      makeRedeemer: (inputIndices) =>
+        serialiseCdpRedeemer({
+          Stableswap: {
+            forwardingInputIndex: inputIndices[0],
+          },
+        }),
+      inputs: [mainOrderUtxo],
+    })
+    .pay.ToContract(
+      stableswapPoolUtxo.address,
+      {
+        kind: 'inline',
+        value: serialiseStableswapPoolDatum(stableswapPoolDatum),
+      },
+      collateralAmtChangePool != 0n
+        ? addAssets(
+            stableswapPoolUtxo.assets,
+            mkAssetsOf(collateralAc, collateralAmtChangePool),
+          )
+        : stableswapPoolUtxo.assets,
+    )
+    // This has to be added as otherwise there is the following error:
+    // TxBuilderError: { Complete: RedeemerBuilder: Coin selection had to be updated
+    // after building redeemers, possibly leading to incorrect indices. Try setting
+    // a minimum fee of 2055720 lovelaces. }
+    .setMinFee(2_055_720n);
+
+  if (amountToMint !== 0n) {
+    tx.mintAssets(mkAssetsOf(iassetAc, amountToMint), Data.void());
+  }
+
+  F.pipe(
+    ordersInfo,
+    A.reduce<StableswapOrderInfo, TxBuilder>(tx, (acc, orderInfo) => {
+      return acc
+        .collectFrom(
+          [orderInfo.utxo],
+          isSameOutRef(orderInfo.utxo, mainOrderUtxo)
+            ? serialiseStableswapOrderRedeemer('BatchProcessStableswapOrders')
+            : {
+                kind: 'selected',
+                makeRedeemer: (inputIndices: bigint[]) => {
+                  return serialiseStableswapOrderRedeemer({
+                    BatchAuxiliary: {
+                      ownInputIndex: inputIndices[0],
+                      mainOrderInputIndex: inputIndices[1],
+                    },
+                  });
+                },
+                inputs: [orderInfo.utxo, mainOrderUtxo],
+              },
+        )
+        .pay.ToAddressWithData(
+          addressToBech32(orderInfo.datum.destination, lucid.config().network!),
+          {
+            kind: 'inline',
+            value: createDestinationDatum(
+              orderInfo.datum.destinationInlineDatum ?? null,
+              orderInfo.utxo,
+            ),
+          },
+          addAssets(
+            // Currently, we always take the max execution fee from the order utxo.
+            // This can be improved so that we take the actual execution fee.
+            mkLovelacesOf(
+              lovelacesAmt(orderInfo.utxo.assets) -
+                orderInfo.datum.maxExecutionFee,
+            ),
+            orderInfo.swapInfo.owedIasset > 0
+              ? mkAssetsOf(iassetAc, orderInfo.swapInfo.owedIasset)
+              : mkAssetsOf(
+                  collateralAc,
+                  orderInfo.swapInfo.owedCollateralAsset,
+                ),
+          ),
+        );
+    }),
+  );
+  if (fee > 0) {
+    await treasuryFeeTx(
+      iassetAc,
+      fee,
+      0n,
+      lucid,
+      sysParams,
+      tx,
+      stableswapPoolOref,
+      treasuryOref,
+    );
+  }
+  return tx;
+}
+
+export async function updateStableswapPoolFees(
+  stableswapPoolOutRef: OutRef,
+  stableswapFeeOutRef: OutRef,
+  newMintingFeeRatio: Rational | null,
+  newRedemptionFeeRatio: Rational | null,
+  sysParams: SystemParams,
+  lucid: LucidEvolution,
+): Promise<TxBuilder> {
+  const stableswapScriptRefUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.stableswapValidatorRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single Stableswap Ref Script UTXO'),
+  );
+
+  const cdpScriptRefUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef),
+    ]),
+    (_) => new Error('Expected a single CDP Ref Script UTXO'),
+  );
+
+  const stableswapPool = matchSingle(
+    await lucid.utxosByOutRef([stableswapPoolOutRef]),
+    (_) => new Error('Expected a single Stableswap Pool UTXO.'),
+  );
+
+  const stableswapFeeUtxo = matchSingle(
+    await lucid.utxosByOutRef([stableswapFeeOutRef]),
+    (_) => new Error('Expected a single Stableswap Fee UTXO.'),
+  );
+
+  const stableswapPoolDatum = parseStableswapPoolDatumOrThrow(
+    getInlineDatumOrThrow(stableswapPool),
+  );
+  const newStableswapPoolDatum = {
+    ...stableswapPoolDatum,
+    mintingFeeRatio: newMintingFeeRatio ?? stableswapPoolDatum.mintingFeeRatio,
+    redemptionFeeRatio:
+      newRedemptionFeeRatio ?? stableswapPoolDatum.redemptionFeeRatio,
+  };
+
+  if (!stableswapPoolDatum.feeManager) {
+    throw new Error('Stableswap pool fee manager is not set');
+  }
+
+  return lucid
+    .newTx()
+    .readFrom([stableswapScriptRefUtxo, cdpScriptRefUtxo])
+    .collectFrom([stableswapPool], {
+      kind: 'selected',
+      makeRedeemer: (inputIndices) =>
+        serialiseCdpRedeemer({
+          Stableswap: {
+            forwardingInputIndex: inputIndices[0],
+          },
+        }),
+      inputs: [stableswapFeeUtxo],
+    })
+    .collectFrom(
+      [stableswapFeeUtxo],
+      serialiseStableswapOrderRedeemer('UpdateFees'),
+    )
+    .pay.ToContract(
+      stableswapPool.address,
+      {
+        kind: 'inline',
+        value: serialiseStableswapPoolDatum(newStableswapPoolDatum),
+      },
+      stableswapPool.assets,
+    )
+    .addSignerKey(toHex(stableswapPoolDatum.feeManager))
+    .setMinFee(1038402n);
+}