@indigo-labs/indigo-sdk 0.1.21 → 0.1.22

package/src/contracts/staking.ts

@@ -0,0 +1,348 @@
+import {
+  Address,
+  applyParamsToScript,
+  Constr,
+  Data,
+  fromText,
+  LucidEvolution,
+  OutRef,
+  SpendingValidator,
+  TxBuilder,
+  UTxO,
+  validatorToAddress,
+  validatorToScriptHash,
+} from '@lucid-evolution/lucid';
+import {
+  ScriptReferences,
+  StakingParams,
+  SystemParams,
+} from '../types/system-params';
+import { addrDetails, scriptRef } from '../helpers/lucid-utils';
+import { _stakingValidator } from '../scripts/staking-validator';
+import {
+  serialiseStakingDatum,
+  StakingManagerContent,
+  StakingPositionContent,
+} from '../types/indigo/staking';
+import { StakingHelpers } from '../helpers/staking-helpers';
+
+export class StakingContract {
+  static async openPosition(
+    amount: bigint,
+    params: SystemParams,
+    lucid: LucidEvolution,
+    stakingManagerRef?: OutRef,
+  ): Promise<TxBuilder> {
+    const [pkh, _] = await addrDetails(lucid);
+
+    const stakingManagerOut = stakingManagerRef
+      ? await StakingHelpers.findStakingManagerByOutRef(
+          stakingManagerRef,
+          lucid,
+        )
+      : await StakingHelpers.findStakingManager(params, lucid);
+    const stakingScriptRef = await StakingContract.scriptRef(
+      params.scriptReferences,
+      lucid,
+    );
+    const stakingTokenScriptRefUtxo =
+      await StakingContract.stakingTokenScriptRef(
+        params.scriptReferences,
+        lucid,
+      );
+
+    const newStakingManagerDatum: StakingManagerContent = {
+      totalStake: stakingManagerOut.datum.totalStake + amount,
+      managerSnapshot: {
+        snapshotAda: stakingManagerOut.datum.managerSnapshot.snapshotAda,
+      },
+    };
+
+    const stakingPositionDatum: StakingPositionContent = {
+      owner: pkh.hash,
+      lockedAmount: new Map([]),
+      positionSnapshot: {
+        snapshotAda: stakingManagerOut.datum.managerSnapshot.snapshotAda,
+      },
+    };
+
+    const stakingToken =
+      params.stakingParams.stakingToken[0].unCurrencySymbol +
+      fromText(params.stakingParams.stakingToken[1].unTokenName);
+    const indyToken =
+      params.stakingParams.indyToken[0].unCurrencySymbol +
+      fromText(params.stakingParams.indyToken[1].unTokenName);
+    return lucid
+      .newTx()
+      .collectFrom([stakingManagerOut.utxo], Data.to(new Constr(0, [pkh.hash])))
+      .readFrom([stakingScriptRef])
+      .pay.ToContract(
+        stakingManagerOut.utxo.address,
+        {
+          kind: 'inline',
+          value: serialiseStakingDatum({
+            StakingManager: { content: newStakingManagerDatum },
+          }),
+        },
+        stakingManagerOut.utxo.assets,
+      )
+      .readFrom([stakingTokenScriptRefUtxo])
+      .mintAssets(
+        {
+          [stakingToken]: 1n,
+        },
+        Data.void(),
+      )
+      .pay.ToContract(
+        StakingContract.address(params.stakingParams, lucid),
+        {
+          kind: 'inline',
+          value: serialiseStakingDatum({
+            StakingPosition: { content: stakingPositionDatum },
+          }),
+        },
+        {
+          [stakingToken]: 1n,
+          [indyToken]: amount,
+        },
+      )
+      .addSignerKey(pkh.hash);
+  }
+
+  static async adjustPosition(
+    stakingPositionRef: OutRef,
+    amount: bigint,
+    params: SystemParams,
+    lucid: LucidEvolution,
+    stakingManagerRef?: OutRef,
+  ): Promise<TxBuilder> {
+    const [pkh, _] = await addrDetails(lucid);
+    const now = Date.now();
+
+    const stakingPositionOut = await StakingHelpers.findStakingPositionByOutRef(
+      stakingPositionRef,
+      lucid,
+    );
+    const stakingManagerOut = stakingManagerRef
+      ? await StakingHelpers.findStakingManagerByOutRef(
+          stakingManagerRef,
+          lucid,
+        )
+      : await StakingHelpers.findStakingManager(params, lucid);
+
+    const stakingScriptRef = await StakingContract.scriptRef(
+      params.scriptReferences,
+      lucid,
+    );
+
+    const stakingToken =
+      params.stakingParams.stakingToken[0].unCurrencySymbol +
+      fromText(params.stakingParams.stakingToken[1].unTokenName);
+    const stakingManagerToken =
+      params.stakingParams.stakingManagerNFT[0].unCurrencySymbol +
+      fromText(params.stakingParams.stakingManagerNFT[1].unTokenName);
+    const indyToken =
+      params.stakingParams.indyToken[0].unCurrencySymbol +
+      fromText(params.stakingParams.indyToken[1].unTokenName);
+
+    const existingIndyAmount = stakingPositionOut.utxo.assets[indyToken] ?? 0n;
+    const currentSnapshotAda =
+      stakingManagerOut.datum.managerSnapshot.snapshotAda;
+    const oldSnapshotAda =
+      stakingPositionOut.datum.positionSnapshot.snapshotAda;
+    const adaReward =
+      ((currentSnapshotAda - oldSnapshotAda) * existingIndyAmount) /
+      (1000000n * 1000000n);
+
+    const newLockedAmount = new Map<bigint, [bigint, bigint]>();
+    for (const [key, value] of stakingPositionOut.datum.lockedAmount) {
+      if (value[1] > now) {
+        newLockedAmount.set(key, [value[0], value[1]]);
+      }
+    }
+    return lucid
+      .newTx()
+      .validFrom(Date.now())
+      .readFrom([stakingScriptRef])
+      .collectFrom([stakingPositionOut.utxo], Data.to(new Constr(3, [amount])))
+      .collectFrom([stakingManagerOut.utxo], Data.to(new Constr(1, [])))
+      .pay.ToContract(
+        stakingManagerOut.utxo.address,
+        {
+          kind: 'inline',
+          value: serialiseStakingDatum({
+            StakingManager: {
+              content: {
+                ...stakingManagerOut.datum,
+                totalStake: stakingManagerOut.datum.totalStake + amount,
+              },
+            },
+          }),
+        },
+        {
+          lovelace: stakingManagerOut.utxo.assets.lovelace - adaReward,
+          [stakingManagerToken]: 1n,
+        },
+      )
+      .pay.ToContract(
+        stakingPositionOut.utxo.address,
+        {
+          kind: 'inline',
+          value: serialiseStakingDatum({
+            StakingPosition: {
+              content: {
+                ...stakingPositionOut.datum,
+                lockedAmount: newLockedAmount,
+              },
+            },
+          }),
+        },
+        {
+          [stakingToken]: 1n,
+          [indyToken]: stakingPositionOut.utxo.assets[indyToken] + amount,
+        },
+      )
+      .addSignerKey(pkh.hash);
+  }
+
+  static async closePosition(
+    stakingPositionRef: OutRef,
+    params: SystemParams,
+    lucid: LucidEvolution,
+    stakingManagerRef?: OutRef,
+  ): Promise<TxBuilder> {
+    const [pkh, _] = await addrDetails(lucid);
+
+    const stakingPositionOut = await StakingHelpers.findStakingPositionByOutRef(
+      stakingPositionRef,
+      lucid,
+    );
+    const stakingManagerOut = stakingManagerRef
+      ? await StakingHelpers.findStakingManagerByOutRef(
+          stakingManagerRef,
+          lucid,
+        )
+      : await StakingHelpers.findStakingManager(params, lucid);
+
+    const stakingScriptRef = await StakingContract.scriptRef(
+      params.scriptReferences,
+      lucid,
+    );
+    const stakingTokenScriptRefUtxo =
+      await StakingContract.stakingTokenScriptRef(
+        params.scriptReferences,
+        lucid,
+      );
+
+    const stakingToken =
+      params.stakingParams.stakingToken[0].unCurrencySymbol +
+      fromText(params.stakingParams.stakingToken[1].unTokenName);
+    const stakingManagerToken =
+      params.stakingParams.stakingManagerNFT[0].unCurrencySymbol +
+      fromText(params.stakingParams.stakingManagerNFT[1].unTokenName);
+    const indyToken =
+      params.stakingParams.indyToken[0].unCurrencySymbol +
+      fromText(params.stakingParams.indyToken[1].unTokenName);
+
+    const existingIndyAmount = stakingPositionOut.utxo.assets[indyToken] ?? 0n;
+    const currentSnapshotAda =
+      stakingManagerOut.datum.managerSnapshot.snapshotAda;
+    const oldSnapshotAda =
+      stakingPositionOut.datum.positionSnapshot.snapshotAda;
+    const adaReward =
+      ((currentSnapshotAda - oldSnapshotAda) * existingIndyAmount) /
+      (1000000n * 1000000n);
+
+    return lucid
+      .newTx()
+      .validFrom(Date.now())
+      .readFrom([stakingScriptRef])
+      .readFrom([stakingTokenScriptRefUtxo])
+      .collectFrom([stakingPositionOut.utxo], Data.to(new Constr(4, [])))
+      .collectFrom([stakingManagerOut.utxo], Data.to(new Constr(1, [])))
+      .pay.ToContract(
+        stakingManagerOut.utxo.address,
+        {
+          kind: 'inline',
+          value: serialiseStakingDatum({
+            StakingManager: {
+              content: {
+                ...stakingManagerOut.datum,
+                totalStake:
+                  stakingManagerOut.datum.totalStake - existingIndyAmount,
+              },
+            },
+          }),
+        },
+        {
+          lovelace: stakingManagerOut.utxo.assets.lovelace - adaReward,
+          [stakingManagerToken]: 1n,
+        },
+      )
+      .mintAssets(
+        {
+          [stakingToken]: -1n,
+        },
+        Data.void(),
+      )
+      .addSignerKey(pkh.hash);
+  }
+
+  // Staking Validator
+  static validator(params: StakingParams): SpendingValidator {
+    return {
+      type: 'PlutusV2',
+      script: applyParamsToScript(_stakingValidator.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.indyToken[0].unCurrencySymbol,
+            fromText(params.indyToken[1].unTokenName),
+          ]),
+          new Constr(0, [
+            params.pollToken[0].unCurrencySymbol,
+            fromText(params.pollToken[1].unTokenName),
+          ]),
+          new Constr(0, [
+            params.versionRecordToken[0].unCurrencySymbol,
+            fromText(params.versionRecordToken[1].unTokenName),
+          ]),
+          params.collectorValHash,
+        ]),
+      ]),
+    };
+  }
+
+  static validatorHash(params: StakingParams): string {
+    return validatorToScriptHash(StakingContract.validator(params));
+  }
+
+  static address(params: StakingParams, lucid: LucidEvolution): Address {
+    const network = lucid.config().network;
+    if (!network) {
+      throw new Error('Network configuration is undefined');
+    }
+    return validatorToAddress(network, StakingContract.validator(params));
+  }
+
+  static async scriptRef(
+    params: ScriptReferences,
+    lucid: LucidEvolution,
+  ): Promise<UTxO> {
+    return scriptRef(params.stakingValidatorRef, lucid);
+  }
+
+  static async stakingTokenScriptRef(
+    params: ScriptReferences,
+    lucid: LucidEvolution,
+  ): Promise<UTxO> {
+    return scriptRef(params.authTokenPolicies.stakingTokenRef, lucid);
+  }
+}

package/src/contracts/treasury.ts

@@ -0,0 +1,112 @@
+import {
+  Address,
+  applyParamsToScript,
+  Constr,
+  Data,
+  fromText,
+  LucidEvolution,
+  OutRef,
+  SpendingValidator,
+  TxBuilder,
+  UTxO,
+  validatorToAddress,
+  validatorToScriptHash,
+} from '@lucid-evolution/lucid';
+import { _treasuryValidator } from '../scripts/treasury-validator';
+import {
+  ScriptReferences,
+  SystemParams,
+  TreasuryParams,
+} from '../types/system-params';
+import { scriptRef } from '../helpers/lucid-utils';
+import { getRandomElement } from '../helpers/helpers';
+
+export class TreasuryContract {
+  static async feeTx(
+    fee: bigint,
+    lucid: LucidEvolution,
+    params: SystemParams,
+    tx: TxBuilder,
+    treasuryRef?: OutRef,
+  ): Promise<void> {
+    const treasuryUtxo: UTxO = treasuryRef
+      ? getRandomElement(await lucid.utxosByOutRef([treasuryRef]))
+      : getRandomElement(
+          await lucid.utxosAt(
+            TreasuryContract.address(params.treasuryParams, lucid),
+          ),
+        );
+
+    const treasuryScriptRefUtxo = await TreasuryContract.scriptRef(
+      params.scriptReferences,
+      lucid,
+    );
+
+    tx.collectFrom([treasuryUtxo], Data.to(new Constr(4, [])))
+      .pay.ToContract(
+        treasuryUtxo.address,
+        { kind: 'inline', value: treasuryUtxo.datum || '' },
+        {
+          ...treasuryUtxo.assets,
+          lovelace: treasuryUtxo.assets['lovelace'] + fee,
+        },
+      )
+      .readFrom([treasuryScriptRefUtxo]);
+  }
+
+  // treasury Validator
+  static validator(params: TreasuryParams): SpendingValidator {
+    return {
+      type: 'PlutusV2',
+      script: applyParamsToScript(_treasuryValidator.cborHex, [
+        new Constr(0, [
+          new Constr(0, [
+            params.upgradeToken[0].unCurrencySymbol,
+            fromText(params.upgradeToken[1].unTokenName),
+          ]),
+          new Constr(0, [
+            params.versionRecordToken[0].unCurrencySymbol,
+            fromText(params.versionRecordToken[1].unTokenName),
+          ]),
+          params.treasuryUtxosStakeCredential
+            ? new Constr(0, [
+                new Constr(0, [
+                  new Constr(1, [
+                    params.treasuryUtxosStakeCredential.contents.contents,
+                  ]),
+                ]),
+              ])
+            : new Constr(1, []),
+        ]),
+      ]),
+    };
+  }
+
+  static validatorHash(params: TreasuryParams): string {
+    return validatorToScriptHash(TreasuryContract.validator(params));
+  }
+
+  static address(params: TreasuryParams, lucid: LucidEvolution): Address {
+    const network = lucid.config().network;
+    if (!network) {
+      throw new Error('Network configuration is undefined');
+    }
+    return validatorToAddress(
+      network,
+      TreasuryContract.validator(params),
+      params.treasuryUtxosStakeCredential
+        ? {
+            type: 'Script',
+            hash: params.treasuryUtxosStakeCredential.contents.contents,
+          }
+        : undefined,
+    );
+  }
+
+  static async scriptRef(
+    params: ScriptReferences,
+    lucid: LucidEvolution,
+  ): Promise<UTxO> {
+    return scriptRef(params.treasuryValidatorRef, lucid);
+  }
+}

package/src/helpers/asset-helpers.ts

@@ -0,0 +1,57 @@
+import { fromText, LucidEvolution, OutRef, UTxO } from '@lucid-evolution/lucid';
+import { CDPContract } from '../contracts/cdp';
+import { SystemParams } from '../types/system-params';
+import { IAssetContent, parseIAssetDatum } from '../types/indigo/cdp';
+
+export type IAssetOutput = { utxo: UTxO; datum: IAssetContent };
+
+export class IAssetHelpers {
+  static async findIAssetByRef(
+    outRef: OutRef,
+    lucid: LucidEvolution,
+  ): Promise<IAssetOutput> {
+    return lucid
+      .utxosByOutRef([outRef])
+      .then((utxos) =>
+        utxos
+          .map((utxo) => {
+            if (!utxo.datum) return undefined;
+            const datum = parseIAssetDatum(utxo.datum);
+            return { utxo, datum };
+          })
+          .find((utxo) => utxo !== undefined),
+      )
+      .then((result) => {
+        if (!result)
+          throw new Error('Unable to locate IAsset by output reference.');
+        return result;
+      });
+  }
+
+  static async findIAssetByName(
+    assetName: string,
+    params: SystemParams,
+    lucid: LucidEvolution,
+  ): Promise<IAssetOutput> {
+    return lucid
+      .utxosAtWithUnit(
+        CDPContract.address(params.cdpParams, lucid),
+        params.cdpParams.iAssetAuthToken[0].unCurrencySymbol +
+          fromText(params.cdpParams.iAssetAuthToken[1].unTokenName),
+      )
+      .then((utxos) =>
+        utxos
+          .map((utxo) => {
+            if (!utxo.datum) return undefined;
+            const datum = parseIAssetDatum(utxo.datum);
+            if (datum.assetName !== fromText(assetName)) return undefined;
+            return { utxo, datum };
+          })
+          .find((utxo) => utxo !== undefined),
+      )
+      .then((result) => {
+        if (!result) throw new Error('Unable to locate IAsset by name.');
+        return result;
+      });
+  }
+}

package/src/{utils → helpers}/helper-txs.ts

@@ -8,7 +8,6 @@ import {
 import { alwaysFailValidator } from '../scripts/always-fail-validator';
 
 /**
- * TODO: remove this, it should be part of the testsuite only
  * Uses an always fail validator for the destination address.
  */
 export async function runCreateScriptRefTx(

package/src/{utils/utils.ts → helpers/helpers.ts}

@@ -14,6 +14,16 @@ export function matchSingle<T>(xs: T[], mkErr: (xs: T[]) => Error): T {
     });
 }
 
+export function calculateFeeFromPercentage(
+  percent: bigint,
+  amount: bigint,
+): bigint {
+  if (amount <= 0n) return 0n;
+  const a = (amount * percent) / 1_000_000n;
+  const b = BigInt(100_000_000);
+  return (a * 1_000_000n) / b;
+}
+
 export function loadSystemParamsFromFile(file: string): SystemParams {
   return JSON.parse(fs.readFileSync(file, 'utf-8')) as SystemParams;
 }

package/src/{contracts/interest-oracle/helpers.ts → helpers/interest-oracle.ts}

@@ -1,14 +1,8 @@
-import { InterestOracleDatum } from './types';
-import { ONE_YEAR } from '../../utils/time-helpers';
-import {
-  OCD_DECIMAL_UNIT,
-  ocdAdd,
-  ocdCeil,
-  ocdMul,
-  OnChainDecimal,
-} from '../../types/on-chain-decimal';
+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;
 
 export function calculateUnitaryInterest(
   timePeriod: bigint,
@@ -16,8 +10,8 @@ export function calculateUnitaryInterest(
 ): bigint {
   return (
     (timePeriod * interestRate * unitaryInterestPrecision) /
-    ONE_YEAR /
-    OCD_DECIMAL_UNIT
+    oneYear /
+    decimalUnit
   );
 }
 
@@ -47,8 +41,8 @@ export function calculateAccruedInterest(
       ((now - interestOracleDatum.lastUpdated) *
         interestOracleDatum.interestRate.getOnChainInt *
         mintedAmount) /
-      ONE_YEAR /
-      OCD_DECIMAL_UNIT;
+      oneYear /
+      decimalUnit;
 
     return interestFromPreviousRates + lastRateInterest;
   } else {
@@ -56,30 +50,8 @@ export function calculateAccruedInterest(
       ((now - interestLastSettled) *
         interestOracleDatum.interestRate.getOnChainInt *
         mintedAmount) /
-      ONE_YEAR /
-      OCD_DECIMAL_UNIT
+      oneYear /
+      decimalUnit
     );
   }
 }
-
-/**
- * Calculate the amount of interest needed to achieve 100% collateral ratio.
- */
-export function computeInterestLovelacesFor100PercentCR(
-  collateral: bigint,
-  mintedAmt: bigint,
-  price: OnChainDecimal,
-): bigint {
-  const amt = ocdCeil(
-    ocdAdd(
-      { getOnChainInt: collateral * OCD_DECIMAL_UNIT },
-      ocdMul({ getOnChainInt: -mintedAmt * OCD_DECIMAL_UNIT }, price),
-    ),
-  );
-
-  if (amt <= 0) {
-    return 0n;
-  } else {
-    return amt;
-  }
-}