@indigo-labs/indigo-sdk 0.1.3 → 0.1.5

package/src/contracts/collector.ts

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

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

package/src/contracts/interest-oracle.ts

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

@@ -1,223 +0,0 @@
-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 { mkAssetsOf, mkLovelacesOf } from '../helpers/value-helpers';
-import { oracleExpirationAwareValidity } from '../helpers/price-oracle-helpers';
-import { calculateFeeFromPercentage } from '../helpers/indigo-helpers';
-import { matchSingle } from '../helpers/helpers';
-
-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(
-  redemptionLrpsData: [OutRef, bigint][],
-  lrpRefScriptOutRef: OutRef,
-  priceOracleOutRef: OutRef,
-  iassetOutRef: OutRef,
-  lucid: LucidEvolution,
-  lrpParams: LRPParams,
-  priceOracleParams: PriceOracleParams,
-  network: Network,
-): 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, mainLrpRedemptionIAssetAmt], _] = match(redemptionLrps)
-    .with(
-      [P._, ...P.array()],
-      ([[firstLrp, firstLrpIAssetAmt], ...rest]): [
-        [UTxO, bigint],
-        [UTxO, bigint][],
-      ] => [[firstLrp, firstLrpIAssetAmt], 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: mainLrpRedemptionIAssetAmt,
-        },
-        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(
-    lucid.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)
-  );
-}

package/src/contracts/one-shot.ts

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