@indigo-labs/indigo-sdk 0.1.20 → 0.1.22

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/transactions.ts → lrp.ts}

@@ -14,7 +14,7 @@ import {
   addrDetails,
   createScriptAddress,
   getInlineDatumOrThrow,
-} from '../../utils/lucid-utils';
+} 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';
@@ -24,18 +24,18 @@ import {
   parseLrpDatum,
   serialiseLrpDatum,
   serialiseLrpRedeemer,
-} from './types';
-import { parsePriceOracleDatum } from '../price-oracle/types';
-import { ocdMul, OnChainDecimal } from '../../types/on-chain-decimal';
-import { parseIAssetDatumOrThrow } from '../cdp/types';
+} from '../types/indigo/lrp';
+import { parsePriceOracleDatum } from '../types/indigo/price-oracle';
+import { ocdMul, OnChainDecimal } from '../types/on-chain-decimal';
+import { parseIAssetDatum } from '../types/indigo/cdp';
 import {
   assetClassValueOf,
   mkAssetsOf,
   mkLovelacesOf,
-} from '../../utils/value-helpers';
-import { calculateFeeFromPercentage } from '../../utils/indigo-helpers';
-import { matchSingle } from '../../utils/utils';
-import { AssetClass } from '../../types/generic';
+} from '../helpers/value-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;
 
@@ -116,9 +116,7 @@ export async function redeemLrp(
     (_) => new Error('Expected a single IAsset UTXO'),
   );
 
-  const iassetDatum = parseIAssetDatumOrThrow(
-    getInlineDatumOrThrow(iassetUtxo),
-  );
+  const iassetDatum = parseIAssetDatum(getInlineDatumOrThrow(iassetUtxo));
 
   const [lrpsToRedeemOutRefs, lrpRedemptionIAssetAmt] =
     unzip(redemptionLrpsData);
@@ -194,7 +192,7 @@ export async function redeemLrp(
           },
           addAssets(
             lrpUtxo.assets,
-            mkLovelacesOf(-lovelacesForRedemption + reimburstmentLovelaces),
+            mkLovelacesOf(-(lovelacesForRedemption - reimburstmentLovelaces)),
             mkAssetsOf(
               {
                 currencySymbol: lrpParams.iassetPolicyId,
@@ -238,6 +236,8 @@ export async function adjustLrp(
   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'),
@@ -292,7 +292,7 @@ export async function adjustLrp(
         mkLovelacesOf(lovelacesAdjustAmt),
       ),
     )
-    .addSignerKey(lrpDatum.owner);
+    .addSigner(ownAddr);
 }
 
 /**

package/src/contracts/{one-shot/transactions.ts → one-shot.ts}

@@ -9,9 +9,9 @@ import {
   toUnit,
   TxBuilder,
 } from '@lucid-evolution/lucid';
-import { OneShotParams } from './types';
-import { matchSingle } from '../../utils/utils';
-import { mkOneShotPolicy } from './scripts';
+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(