@indigo-labs/indigo-sdk 0.1.2 → 0.1.3

package/src/contracts/collector.ts

@@ -13,8 +13,13 @@ import {
   validatorToScriptHash,
 } from '@lucid-evolution/lucid';
 import { _collectorValidator } from '../scripts/collector-validator';
-import { CollectorParams, ScriptReferences, SystemParams } from '../types/system-params';
-import { getRandomElement, scriptRef } from '../helpers/lucid-utils';
+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(
@@ -26,9 +31,11 @@ export class CollectorContract {
   ): Promise<void> {
     const collectorUtxo: UTxO = collectorRef
       ? getRandomElement(await lucid.utxosByOutRef([collectorRef]))
-      : getRandomElement(await lucid.utxosAt(
-          CollectorContract.address(params.collectorParams, lucid),
-        ));
+      : getRandomElement(
+          await lucid.utxosAt(
+            CollectorContract.address(params.collectorParams, lucid),
+          ),
+        );
 
     const collectorScriptRefUtxo = await CollectorContract.scriptRef(
       params.scriptReferences,
@@ -41,7 +48,7 @@ export class CollectorContract {
         { kind: 'inline', value: Data.to(new Constr(0, [])) },
         {
           ...collectorUtxo.assets,
-          lovelace: collectorUtxo.assets['lovelace'] + fee,
+          lovelace: collectorUtxo.assets.lovelace + fee,
         },
       )
       .readFrom([collectorScriptRefUtxo]);

package/src/contracts/gov.ts

@@ -1,58 +1 @@
-import { Constr, Data } from '@lucid-evolution/lucid';
-import { GovDatum } from '../types/indigo/gov';
-
-export class GovContract {
-  static decodeGovDatum(datum: string): GovDatum {
-    const d = Data.from(datum) as any;
-    if (
-      d.index !== 0 ||
-      d.fields.length !== 6 ||
-      d.fields[1].fields.length !== 10
-    )
-      throw 'Invalid GovDatum found';
-
-    return {
-      currentProposal: d.fields[0],
-      protocolParams: {
-        proposalDeposit: d.fields[1].fields[0],
-        votingPeriod: d.fields[1].fields[1],
-        effectiveDelay: d.fields[1].fields[2],
-        expirationPeriod: d.fields[1].fields[3],
-        collateralFeePercentage: d.fields[1].fields[4].fields[0],
-        proposingPeriod: d.fields[1].fields[5],
-        totalShards: d.fields[1].fields[6],
-        minimumQuorum: d.fields[1].fields[7],
-        maxTreasuryLovelaceSpend: d.fields[1].fields[8],
-        maxTreasuryIndySpend: d.fields[1].fields[9],
-      },
-      currentVersion: d.fields[2],
-      iassetsCount: d.fields[3],
-      activeProposals: d.fields[4],
-      treasuryIndyWithdrawnAmt: d.fields[5],
-    };
-  }
-
-  static encodeGovDatum(datum: GovDatum): string {
-    return Data.to(
-      new Constr(0, [
-        datum.currentProposal,
-        new Constr(0, [
-          datum.protocolParams.proposalDeposit,
-          datum.protocolParams.votingPeriod,
-          datum.protocolParams.effectiveDelay,
-          datum.protocolParams.expirationPeriod,
-          new Constr(0, [datum.protocolParams.collateralFeePercentage]),
-          datum.protocolParams.proposingPeriod,
-          datum.protocolParams.totalShards,
-          datum.protocolParams.minimumQuorum,
-          datum.protocolParams.maxTreasuryLovelaceSpend,
-          datum.protocolParams.maxTreasuryIndySpend,
-        ]),
-        datum.currentVersion,
-        datum.iassetsCount,
-        datum.activeProposals,
-        datum.treasuryIndyWithdrawnAmt,
-      ]),
-    );
-  }
-}
+export class GovContract {}

package/src/contracts/interest-oracle.ts

@@ -1,49 +1,149 @@
-import { Constr, Data } from "@lucid-evolution/lucid";
-import { InterestOracleDatum } from "../types/indigo/interest-oracle";
-import { oneYear } from "../helpers/time-helpers";
-
-const unitaryInterestPrecision = 1_000_000_000_000_000_000n;
-const decimalUnit = 1_000_000n;
+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 decodeInterestOracleDatum(datum: string): InterestOracleDatum {
-        const oracleDatum = Data.from(datum) as any;
-        if (oracleDatum.index != 0 || oracleDatum.fields.length !== 3 || oracleDatum.fields[1].index !== 0)
-            throw 'Invalid Interest Oracle Datum provided.'
-        
-        return {
-            unitaryInterest: oracleDatum.fields[0],
-            interestRate: oracleDatum.fields[1].fields[0],
-            lastUpdated: oracleDatum.fields[2],
-        }
-    }
-    
-    static encodeInterestOracleDatum(datum: InterestOracleDatum): string {
-        return Data.to(
-            new Constr(0, [
-                datum.unitaryInterest,
-                new Constr(0, [datum.interestRate]),
-                datum.lastUpdated,
-            ])
-        )
+  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];
     }
 
-    static calculateUnitaryInterestSinceOracleLastUpdated(now: bigint, oracleDatum: InterestOracleDatum): bigint {
-        return InterestOracleContract.calculateUnitaryInterest(now - oracleDatum.lastUpdated, oracleDatum.interestRate);
+    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,
+      );
     }
 
-    static calculateUnitaryInterest(timePeriod: bigint, interestRate: bigint): bigint {
-        return ((timePeriod * interestRate * unitaryInterestPrecision) / oneYear) / decimalUnit;
+    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;
     }
 
-    static calculateAccruedInterest(now: bigint, unitaryInterestSnapshot: bigint, mintedAmount: bigint, interestLastSettled: bigint, interestOracleDatum: InterestOracleDatum): bigint {
-        if (interestOracleDatum.unitaryInterest >= unitaryInterestSnapshot) {
-            const interestFromPreviousRates = ((interestOracleDatum.unitaryInterest - unitaryInterestSnapshot) * mintedAmount) / unitaryInterestPrecision;
-            const lastRateInterest = (((now - interestOracleDatum.lastUpdated) * interestOracleDatum.interestRate * mintedAmount) / oneYear) / decimalUnit;
+    const now = BigInt(Date.now());
+    const tx = lucid.newTx();
+    const datum = parseInterestOracleDatum(utxo.datum);
 
-            return interestFromPreviousRates + lastRateInterest;
-        } else {
-            return (((now - interestLastSettled) * interestOracleDatum.interestRate * mintedAmount) / oneYear) / decimalUnit;
-        }
+    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,223 @@
+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

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