@indigo-labs/indigo-sdk 0.1.19 → 0.1.21

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;
-  }
-}