@indigo-labs/indigo-sdk 0.5.5 → 0.5.6

package/src/contracts/stableswap/transactions.ts

@@ -1,475 +0,0 @@
-import {
-  addAssets,
-  Address,
-  credentialToAddress,
-  Data,
-  fromHex,
-  fromText,
-  LucidEvolution,
-  OutRef,
-  paymentCredentialOf,
-  sortUTxOs,
-  toHex,
-  TxBuilder,
-} from '@lucid-evolution/lucid';
-import {
-  fromSystemParamsScriptRef,
-  SystemParams,
-} from '../../types/system-params';
-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 { array as A, function as F } from 'fp-ts';
-import { isEmpty } from 'fp-ts/lib/Array';
-import {
-  BASE_MAX_EXECUTION_FEE,
-  createDestinationDatum,
-  estimateMinOrderOutputLovelaces,
-  PSMProcessingConfig,
-  StableswapInfo,
-  StableswapOrderInfo,
-  summariseOrder,
-} from './helpers';
-import * as Core from '@evolution-sdk/evolution';
-import { treasuryFeeTx } from '../treasury/transactions';
-import { Rational } from '../../types/rational';
-
-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,
-      );
-
-  const orderAssetsPlusFees = addAssets(
-    assetsToSwap,
-    mkLovelacesOf(maxExecutionFee),
-    mkLovelacesOf(additionalLovelaces),
-  );
-
-  const expectedMinOutputLovelaces = estimateMinOrderOutputLovelaces(
-    lucid,
-    datum,
-    orderAssetsPlusFees,
-  );
-
-  return lucid.newTx().pay.ToContract(
-    credentialToAddress(lucid.config().network!, {
-      hash: params.validatorHashes.stableswapHash,
-      type: 'Script',
-    }),
-    {
-      kind: 'inline',
-      value: serialiseStableswapOrderDatum(datum),
-    },
-    addAssets(orderAssetsPlusFees, mkLovelacesOf(expectedMinOutputLovelaces)),
-  );
-}
-
-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,
-  psmProcessingConfig?: PSMProcessingConfig,
-): 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),
-      );
-
-      const res = summariseOrder(
-        lucid,
-        { utxo: orderUtxo, datum: orderDatum },
-        { utxo: stableswapPoolUtxo, datum: stableswapPoolDatum },
-        sysParams,
-        psmProcessingConfig,
-      );
-
-      if (res._tag === 'ERROR') {
-        throw new Error(res.description);
-      }
-
-      return res.result;
-    },
-  );
-
-  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,
-        } satisfies StableswapInfo;
-      },
-    ),
-  );
-
-  const collateralAmtChangePool =
-    totalSwapInfo.suppliedCollateralAsset - totalSwapInfo.owedCollateralAsset;
-
-  const newPsmPoolValue = addAssets(
-    stableswapPoolUtxo.assets,
-    mkAssetsOf(collateralAc, collateralAmtChangePool),
-  );
-
-  if (assetClassValueOf(newPsmPoolValue, collateralAc) < 0n) {
-    throw new Error('Cannot batch more than liquidity allows');
-  }
-
-  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),
-      },
-      newPsmPoolValue,
-    )
-    // 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 1761019 lovelaces. }
-    // Trying to set it as low as possible to reduce costs.
-    .setMinFee(stableswapOrderOrefs.length > 1 ? 1_498_875n : 1_030_000n);
-
-  if (amountToMint !== 0n) {
-    tx.mintAssets(mkAssetsOf(iassetAc, amountToMint), Data.void());
-  }
-
-  F.pipe(
-    ordersInfo,
-    A.reduce<StableswapOrderInfo, TxBuilder>(tx, (acc, orderInfo) => {
-      return acc
-        .collectFrom(
-          [orderInfo.order.utxo],
-          isSameOutRef(orderInfo.order.utxo, mainOrderUtxo)
-            ? serialiseStableswapOrderRedeemer('BatchProcessStableswapOrders')
-            : {
-                kind: 'selected',
-                makeRedeemer: (inputIndices: bigint[]) => {
-                  return serialiseStableswapOrderRedeemer({
-                    BatchAuxiliary: {
-                      ownInputIndex: inputIndices[0],
-                      mainOrderInputIndex: inputIndices[1],
-                    },
-                  });
-                },
-                inputs: [orderInfo.order.utxo, mainOrderUtxo],
-              },
-        )
-        .pay.ToAddressWithData(
-          addressToBech32(
-            orderInfo.order.datum.destination,
-            lucid.config().network!,
-          ),
-          {
-            kind: 'inline',
-            value: createDestinationDatum(
-              orderInfo.order.datum.destinationInlineDatum ?? null,
-              orderInfo.order.utxo,
-            ),
-          },
-          addAssets(
-            // NOTICE: 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.order.utxo.assets) -
-                orderInfo.order.datum.maxExecutionFee,
-            ),
-            orderInfo.orderType === 'MINTING'
-              ? 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);
-}

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

@@ -1,131 +0,0 @@
-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

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