@indigo-labs/indigo-sdk 0.1.7 → 0.1.8

package/src/contracts/collector.ts

@@ -0,0 +1,98 @@
+import {
+  Address,
+  applyParamsToScript,
+  Constr,
+  Data,
+  fromText,
+  LucidEvolution,
+  OutRef,
+  SpendingValidator,
+  TxBuilder,
+  UTxO,
+  validatorToAddress,
+  validatorToScriptHash,
+} from '@lucid-evolution/lucid';
+import { _collectorValidator } from '../scripts/collector-validator';
+import {
+  CollectorParams,
+  ScriptReferences,
+  SystemParams,
+} from '../types/system-params';
+import { scriptRef } from '../helpers/lucid-utils';
+import { getRandomElement } from '../helpers/helpers';
+
+export class CollectorContract {
+  static async feeTx(
+    fee: bigint,
+    lucid: LucidEvolution,
+    params: SystemParams,
+    tx: TxBuilder,
+    collectorRef?: OutRef,
+  ): Promise<void> {
+    const collectorUtxo: UTxO = collectorRef
+      ? getRandomElement(await lucid.utxosByOutRef([collectorRef]))
+      : getRandomElement(
+          await lucid.utxosAt(
+            CollectorContract.address(params.collectorParams, lucid),
+          ),
+        );
+
+    const collectorScriptRefUtxo = await CollectorContract.scriptRef(
+      params.scriptReferences,
+      lucid,
+    );
+
+    tx.collectFrom([collectorUtxo], Data.to(new Constr(0, [])))
+      .pay.ToContract(
+        collectorUtxo.address,
+        { kind: 'inline', value: Data.to(new Constr(0, [])) },
+        {
+          ...collectorUtxo.assets,
+          lovelace: collectorUtxo.assets.lovelace + fee,
+        },
+      )
+      .readFrom([collectorScriptRefUtxo]);
+  }
+
+  // Collector Validator
+  static validator(params: CollectorParams): SpendingValidator {
+    return {
+      type: 'PlutusV2',
+      script: applyParamsToScript(_collectorValidator.cborHex, [
+        new Constr(0, [
+          new Constr(0, [
+            params.stakingManagerNFT[0].unCurrencySymbol,
+            fromText(params.stakingManagerNFT[1].unTokenName),
+          ]),
+          new Constr(0, [
+            params.stakingToken[0].unCurrencySymbol,
+            fromText(params.stakingToken[1].unTokenName),
+          ]),
+          new Constr(0, [
+            params.versionRecordToken[0].unCurrencySymbol,
+            fromText(params.versionRecordToken[1].unTokenName),
+          ]),
+        ]),
+      ]),
+    };
+  }
+
+  static validatorHash(params: CollectorParams): string {
+    return validatorToScriptHash(CollectorContract.validator(params));
+  }
+
+  static address(params: CollectorParams, lucid: LucidEvolution): Address {
+    const network = lucid.config().network;
+    if (!network) {
+      throw new Error('Network configuration is undefined');
+    }
+    return validatorToAddress(network, CollectorContract.validator(params));
+  }
+
+  static async scriptRef(
+    params: ScriptReferences,
+    lucid: LucidEvolution,
+  ): Promise<UTxO> {
+    return scriptRef(params.collectorValidatorRef, lucid);
+  }
+}

package/src/contracts/gov.ts

@@ -0,0 +1 @@
+export class GovContract {}

package/src/contracts/interest-oracle.ts

@@ -0,0 +1,149 @@
+import {
+  fromText,
+  LucidEvolution,
+  OutRef,
+  toUnit,
+  TxBuilder,
+  UTxO,
+  validatorToAddress,
+} from '@lucid-evolution/lucid';
+import { AssetClass } from '../types/generic';
+import {
+  InterestOracleParams,
+  parseInterestOracleDatum,
+  serialiseFeedInterestOracleRedeemer,
+  serialiseInterestOracleDatum,
+} from '../types/indigo/interest-oracle';
+import { oneShotMintTx } from './one-shot';
+import { mkInterestOracleValidator } from '../scripts/interest-oracle-validator';
+import { findInterestOracle } from '../../tests/queries/interest-oracle-queries';
+import { ONE_SECOND } from '../helpers/time-helpers';
+import { calculateUnitaryInterestSinceOracleLastUpdated } from '../helpers/interest-oracle';
+
+export class InterestOracleContract {
+  static async startInterestOracle(
+    initialUnitaryInterest: bigint,
+    initialInterestRate: bigint,
+    initialLastInterestUpdate: bigint,
+    oracleParams: InterestOracleParams,
+    lucid: LucidEvolution,
+    withScriptRef: boolean = false,
+    refOutRef?: OutRef,
+    interestTokenName?: string,
+  ): Promise<[TxBuilder, AssetClass]> {
+    const tokenName = interestTokenName ?? 'INTEREST_ORACLE';
+    if (!refOutRef) {
+      refOutRef = (await lucid.wallet().getUtxos())[0];
+    }
+
+    const [tx, policyId] = await oneShotMintTx(lucid, {
+      referenceOutRef: {
+        txHash: refOutRef.txHash,
+        outputIdx: BigInt(refOutRef.outputIndex),
+      },
+      mintAmounts: [
+        {
+          tokenName: fromText(tokenName),
+          amount: 1n,
+        },
+      ],
+    });
+
+    const validator = mkInterestOracleValidator(oracleParams);
+
+    tx.pay.ToContract(
+      validatorToAddress(lucid.config().network, validator),
+      {
+        kind: 'inline',
+        value: serialiseInterestOracleDatum({
+          unitaryInterest: initialUnitaryInterest,
+          interestRate: {
+            getOnChainInt: initialInterestRate,
+          },
+          lastUpdated: initialLastInterestUpdate,
+        }),
+      },
+      {
+        lovelace: 2_500_000n,
+        [toUnit(policyId, fromText(tokenName))]: 1n,
+      },
+    );
+
+    if (withScriptRef) {
+      tx.pay.ToAddressWithData(
+        validatorToAddress(lucid.config().network, validator),
+        undefined,
+        undefined,
+        validator,
+      );
+    }
+
+    return [
+      tx,
+      {
+        currencySymbol: policyId,
+        tokenName: fromText(tokenName),
+      },
+    ];
+  }
+
+  static async feedInterestOracle(
+    params: InterestOracleParams,
+    newInterestRate: bigint,
+    lucid: LucidEvolution,
+    assetClass?: AssetClass,
+    utxo?: UTxO,
+    scriptRef?: UTxO,
+  ): Promise<TxBuilder> {
+    if (!assetClass && !utxo)
+      throw new Error('Either interest oracle nft or utxo must be provided');
+    if (assetClass && !utxo) {
+      const [ioUtxo, _datum] = await findInterestOracle(lucid, assetClass);
+      utxo = ioUtxo;
+    }
+
+    const now = BigInt(Date.now());
+    const tx = lucid.newTx();
+    const datum = parseInterestOracleDatum(utxo.datum);
+
+    if (scriptRef) {
+      tx.readFrom([scriptRef]);
+    } else {
+      tx.attach.Script(mkInterestOracleValidator(params));
+    }
+
+    tx.collectFrom(
+      [utxo],
+      serialiseFeedInterestOracleRedeemer({
+        newInterestRate: {
+          getOnChainInt: newInterestRate,
+        },
+        currentTime: now,
+      }),
+    );
+
+    tx.pay.ToContract(
+      utxo.address,
+      {
+        kind: 'inline',
+        value: serialiseInterestOracleDatum({
+          unitaryInterest:
+            datum.unitaryInterest +
+            calculateUnitaryInterestSinceOracleLastUpdated(now, datum),
+          interestRate: {
+            getOnChainInt: newInterestRate,
+          },
+          lastUpdated: now,
+        }),
+      },
+      utxo.assets,
+    );
+
+    tx.validFrom(Number(now) - ONE_SECOND);
+    tx.validTo(Number(now + params.biasTime) - ONE_SECOND);
+
+    tx.addSignerKey(params.owner);
+
+    return tx;
+  }
+}

package/src/contracts/lrp.ts

@@ -0,0 +1,315 @@
+import {
+  LucidEvolution,
+  Network,
+  ScriptHash,
+  TxBuilder,
+  Credential,
+  OutRef,
+  UTxO,
+  addAssets,
+} from '@lucid-evolution/lucid';
+import {
+  addrDetails,
+  createScriptAddress,
+  getInlineDatumOrThrow,
+} from '../helpers/lucid-utils';
+import { match, P } from 'ts-pattern';
+import { unzip, zip } from 'fp-ts/lib/Array';
+import { reduceWithIndex } from 'fp-ts/lib/Array';
+import {
+  LRPDatum,
+  LRPParams,
+  parseLrpDatum,
+  serialiseLrpDatum,
+  serialiseLrpRedeemer,
+} from '../types/indigo/lrp';
+import {
+  parsePriceOracleDatum,
+  PriceOracleParams,
+} from '../types/indigo/price-oracle';
+import { ocdMul, OnChainDecimal } from '../types/on-chain-decimal';
+import { parseIAssetDatum } from '../types/indigo/cdp';
+import {
+  assetClassValueOf,
+  mkAssetsOf,
+  mkLovelacesOf,
+} from '../helpers/value-helpers';
+import { oracleExpirationAwareValidity } from '../helpers/price-oracle-helpers';
+import { calculateFeeFromPercentage } from '../helpers/indigo-helpers';
+import { matchSingle } from '../helpers/helpers';
+import { AssetClass } from '../types/generic';
+
+const MIN_UTXO_COLLATERAL_AMT = 2_000_000n;
+
+export async function openLrp(
+  assetTokenName: string,
+  lovelacesAmt: bigint,
+  maxPrice: OnChainDecimal,
+  lucid: LucidEvolution,
+  lrpScriptHash: ScriptHash,
+  network: Network,
+  lrpStakeCredential?: Credential,
+): Promise<TxBuilder> {
+  const [ownPkh, _] = await addrDetails(lucid);
+
+  const newDatum: LRPDatum = {
+    owner: ownPkh.hash,
+    iasset: assetTokenName,
+    maxPrice: maxPrice,
+    lovelacesToSpend: lovelacesAmt,
+  };
+
+  return lucid.newTx().pay.ToContract(
+    createScriptAddress(network, lrpScriptHash, lrpStakeCredential),
+    {
+      kind: 'inline',
+      value: serialiseLrpDatum(newDatum),
+    },
+    { lovelace: lovelacesAmt + MIN_UTXO_COLLATERAL_AMT },
+  );
+}
+
+export async function cancelLrp(
+  lrpOutRef: OutRef,
+  lrpRefScriptOutRef: OutRef,
+  lucid: LucidEvolution,
+): Promise<TxBuilder> {
+  const ownAddr = await lucid.wallet().address();
+  // TODO: use Promise.all
+  const lrpScriptRefUtxo = matchSingle(
+    await lucid.utxosByOutRef([lrpRefScriptOutRef]),
+    (_) => new Error('Expected a single LRP Ref Script UTXO'),
+  );
+
+  const lrpUtxo = matchSingle(
+    await lucid.utxosByOutRef([lrpOutRef]),
+    (_) => new Error('Expected a single LRP UTXO.'),
+  );
+
+  return lucid
+    .newTx()
+    .readFrom([lrpScriptRefUtxo])
+    .collectFrom([lrpUtxo], serialiseLrpRedeemer('Cancel'))
+    .addSigner(ownAddr);
+}
+
+export async function redeemLrp(
+  /** The tuple represents the LRP outref and the amount of iAssets to redeem against it. */
+  redemptionLrpsData: [OutRef, bigint][],
+  lrpRefScriptOutRef: OutRef,
+  priceOracleOutRef: OutRef,
+  iassetOutRef: OutRef,
+  lucid: LucidEvolution,
+  lrpParams: LRPParams,
+  priceOracleParams: PriceOracleParams,
+  network: Network,
+  currentSlot: number,
+): Promise<TxBuilder> {
+  const lrpScriptRefUtxo = matchSingle(
+    await lucid.utxosByOutRef([lrpRefScriptOutRef]),
+    (_) => new Error('Expected a single LRP Ref Script UTXO'),
+  );
+
+  const priceOracleUtxo = matchSingle(
+    await lucid.utxosByOutRef([priceOracleOutRef]),
+    (_) => new Error('Expected a single price oracle UTXO'),
+  );
+
+  const iassetUtxo = matchSingle(
+    await lucid.utxosByOutRef([iassetOutRef]),
+    (_) => new Error('Expected a single IAsset UTXO'),
+  );
+
+  const iassetDatum = parseIAssetDatum(getInlineDatumOrThrow(iassetUtxo));
+
+  const [lrpsToRedeemOutRefs, lrpRedemptionIAssetAmt] =
+    unzip(redemptionLrpsData);
+
+  const priceOracleDatum = parsePriceOracleDatum(
+    getInlineDatumOrThrow(priceOracleUtxo),
+  );
+
+  const redemptionLrps = await lucid
+    .utxosByOutRef(lrpsToRedeemOutRefs)
+    .then((val) => zip(val, lrpRedemptionIAssetAmt));
+
+  const [[mainLrpUtxo, _], __] = match(redemptionLrps)
+    .with(
+      [P._, ...P.array()],
+      ([[firstLrp, _], ...rest]): [[UTxO, bigint], [UTxO, bigint][]] => [
+        [firstLrp, _],
+        rest,
+      ],
+    )
+    .otherwise(() => {
+      throw new Error('Expects at least 1 UTXO to redeem.');
+    });
+
+  const mainLrpDatum = parseLrpDatum(getInlineDatumOrThrow(mainLrpUtxo));
+
+  const tx = reduceWithIndex<[UTxO, bigint], TxBuilder>(
+    lucid.newTx(),
+    (idx, acc, [lrpUtxo, redeemIAssetAmt]) => {
+      const lovelacesForRedemption = ocdMul(
+        {
+          getOnChainInt: redeemIAssetAmt,
+        },
+        priceOracleDatum.price,
+      ).getOnChainInt;
+      const reimburstmentLovelaces = calculateFeeFromPercentage(
+        iassetDatum.redemptionReimbursementPercentage,
+        lovelacesForRedemption,
+      );
+
+      const lrpDatum = parseLrpDatum(getInlineDatumOrThrow(lrpUtxo));
+
+      return acc
+        .collectFrom(
+          [lrpUtxo],
+          serialiseLrpRedeemer(
+            idx === 0
+              ? { Redeem: { continuingOutputIdx: 0n } }
+              : {
+                  RedeemAuxiliary: {
+                    continuingOutputIdx: BigInt(idx),
+                    mainRedeemOutRef: {
+                      txHash: { hash: mainLrpUtxo.txHash },
+                      outputIndex: BigInt(mainLrpUtxo.outputIndex),
+                    },
+                    asset: mainLrpDatum.iasset,
+                    assetPrice: priceOracleDatum.price,
+                    redemptionReimbursementPercentage:
+                      iassetDatum.redemptionReimbursementPercentage,
+                  },
+                },
+          ),
+        )
+        .pay.ToContract(
+          lrpUtxo.address,
+          {
+            kind: 'inline',
+            value: serialiseLrpDatum({
+              ...lrpDatum,
+              lovelacesToSpend:
+                lrpDatum.lovelacesToSpend - lovelacesForRedemption,
+            }),
+          },
+          addAssets(
+            lrpUtxo.assets,
+            mkLovelacesOf(-(lovelacesForRedemption - reimburstmentLovelaces)),
+            mkAssetsOf(
+              {
+                currencySymbol: lrpParams.iassetPolicyId,
+                tokenName: mainLrpDatum.iasset,
+              },
+              redeemIAssetAmt,
+            ),
+          ),
+        );
+    },
+  )(redemptionLrps);
+
+  const txValidity = oracleExpirationAwareValidity(
+    currentSlot,
+    Number(priceOracleParams.biasTime),
+    Number(priceOracleDatum.expiration),
+    network,
+  );
+
+  return (
+    lucid
+      .newTx()
+      .validFrom(txValidity.validFrom)
+      .validTo(txValidity.validTo)
+      // 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,
+  lrpOutRef: OutRef,
+  /**
+   * A positive amount increases the lovelaces in the LRP,
+   * and a negative amount takes lovelaces from the LRP.
+   */
+  lovelacesAdjustAmt: bigint,
+  lrpRefScriptOutRef: OutRef,
+  lrpParams: LRPParams,
+): Promise<TxBuilder> {
+  const ownAddr = await lucid.wallet().address();
+
+  const lrpScriptRefUtxo = matchSingle(
+    await lucid.utxosByOutRef([lrpRefScriptOutRef]),
+    (_) => new Error('Expected a single LRP Ref Script UTXO'),
+  );
+
+  const lrpUtxo = matchSingle(
+    await lucid.utxosByOutRef([lrpOutRef]),
+    (_) => new Error('Expected a single LRP UTXO.'),
+  );
+
+  const lrpDatum = parseLrpDatum(getInlineDatumOrThrow(lrpUtxo));
+
+  const rewardAssetClass: AssetClass = {
+    currencySymbol: lrpParams.iassetPolicyId,
+    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.",
+    );
+  }
+
+  return lucid
+    .newTx()
+    .readFrom([lrpScriptRefUtxo])
+    .collectFrom([lrpUtxo], serialiseLrpRedeemer('Cancel'))
+    .pay.ToContract(
+      lrpUtxo.address,
+      {
+        kind: 'inline',
+        value: serialiseLrpDatum({
+          ...lrpDatum,
+          lovelacesToSpend: lrpDatum.lovelacesToSpend + lovelacesAdjustAmt,
+        }),
+      },
+      addAssets(
+        lrpUtxo.assets,
+        mkAssetsOf(rewardAssetClass, -rewardAssetsAmt),
+        mkLovelacesOf(lovelacesAdjustAmt),
+      ),
+    )
+    .addSigner(ownAddr);
+}
+
+/**
+ * Create Tx claiming the received iAssets.
+ */
+export async function claimLrp(
+  lucid: LucidEvolution,
+  lrpOutRef: OutRef,
+  lrpRefScriptOutRef: OutRef,
+  lrpParams: LRPParams,
+): Promise<TxBuilder> {
+  return adjustLrp(lucid, lrpOutRef, 0n, lrpRefScriptOutRef, lrpParams);
+}

package/src/contracts/one-shot.ts

@@ -0,0 +1,67 @@
+import {
+  addAssets,
+  Assets,
+  Constr,
+  Data,
+  LucidEvolution,
+  mintingPolicyToId,
+  PolicyId,
+  toUnit,
+  TxBuilder,
+} from '@lucid-evolution/lucid';
+import { OneShotParams } from '../types/one-shot';
+import { matchSingle } from '../helpers/helpers';
+import { mkOneShotPolicy } from '../scripts/one-shot-policy';
+import { reduce } from 'fp-ts/lib/Array';
+
+export async function oneShotMintTx(
+  lucid: LucidEvolution,
+  params: OneShotParams,
+): Promise<[TxBuilder, PolicyId]> {
+  const oneShotPolicy = mkOneShotPolicy(params);
+  const policyId = mintingPolicyToId(oneShotPolicy);
+
+  const refUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      {
+        txHash: params.referenceOutRef.txHash,
+        outputIndex: Number(params.referenceOutRef.outputIdx),
+      },
+    ]),
+    (_) => {
+      throw new Error('Cannot find the reference UTXO for one-shot.');
+    },
+  );
+
+  return [
+    lucid
+      .newTx()
+      .collectFrom([refUtxo])
+      .mintAssets(
+        reduce<{ tokenName: string; amount: bigint }, Assets>(
+          {},
+          (acc, entry) =>
+            addAssets(acc, {
+              [toUnit(policyId, entry.tokenName)]: entry.amount,
+            }),
+        )(params.mintAmounts),
+        Data.to(new Constr(0, [])),
+      )
+      .attach.MintingPolicy(oneShotPolicy),
+    policyId,
+  ];
+}
+
+export async function runOneShotMintTx(
+  lucid: LucidEvolution,
+  params: OneShotParams,
+): Promise<PolicyId> {
+  const [tx, policyId] = await oneShotMintTx(lucid, params);
+  const txHash = await tx
+    .complete()
+    .then((tx) => tx.sign.withWallet().complete())
+    .then((tx) => tx.submit());
+
+  await lucid.awaitTx(txHash);
+  return policyId;
+}