@indigo-labs/indigo-sdk 0.1.1 → 0.1.3

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

@@ -13,8 +13,13 @@ import {
   validatorToScriptHash,
 } from '@lucid-evolution/lucid';
 import { _treasuryValidator } from '../scripts/treasury-validator';
-import { ScriptReferences, SystemParams, TreasuryParams } from '../types/system-params';
-import { getRandomElement, scriptRef } from '../helpers/lucid-utils';
+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(
@@ -26,9 +31,11 @@ export class TreasuryContract {
   ): Promise<void> {
     const treasuryUtxo: UTxO = treasuryRef
       ? getRandomElement(await lucid.utxosByOutRef([treasuryRef]))
-      : getRandomElement(await lucid.utxosAt(
-        TreasuryContract.address(params.treasuryParams, lucid),
-        ));
+      : getRandomElement(
+          await lucid.utxosAt(
+            TreasuryContract.address(params.treasuryParams, lucid),
+          ),
+        );
 
     const treasuryScriptRefUtxo = await TreasuryContract.scriptRef(
       params.scriptReferences,
@@ -61,14 +68,15 @@ export class TreasuryContract {
             params.versionRecordToken[0].unCurrencySymbol,
             fromText(params.versionRecordToken[1].unTokenName),
           ]),
-          params.treasuryUtxosStakeCredential ?
-            new Constr(0, [
-              new Constr(0, [
-              new Constr(1, [
-                params.treasuryUtxosStakeCredential.contents.contents,
+          params.treasuryUtxosStakeCredential
+            ? new Constr(0, [
+                new Constr(0, [
+                  new Constr(1, [
+                    params.treasuryUtxosStakeCredential.contents.contents,
+                  ]),
+                ]),
               ])
-            ])
-            ]) : new Constr(1, []),
+            : new Constr(1, []),
         ]),
       ]),
     };
@@ -83,7 +91,16 @@ export class TreasuryContract {
     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);
+    return validatorToAddress(
+      network,
+      TreasuryContract.validator(params),
+      params.treasuryUtxosStakeCredential
+        ? {
+            type: 'Script',
+            hash: params.treasuryUtxosStakeCredential.contents.contents,
+          }
+        : undefined,
+    );
   }
 
   static async scriptRef(

package/src/helpers/asset-helpers.ts

@@ -1,28 +1,57 @@
-import { fromText, LucidEvolution, OutRef, UTxO } from "@lucid-evolution/lucid";
-import { CDPContract } from "../contracts/cdp";
-import { SystemParams } from "../types/system-params";
-import { IAsset } from "../types/indigo/cdp";
+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: IAsset };
+export type IAssetOutput = { utxo: UTxO; datum: IAssetContent };
 
 export class IAssetHelpers {
-    static async findIAssetByRef(outRef: OutRef, params: SystemParams, lucid: LucidEvolution): Promise<IAssetOutput> {
-        throw new Error('Not implemented');
-    }
+  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 => {
+  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 = CDPContract.decodeCdpDatum(utxo.datum);
-            if (datum.type !== 'IAsset') return undefined;
-            if (datum.name !== assetName) 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 'Unable to locate IAsset by name.';
-            return result;
-        });
-    } 
-}
+          })
+          .find((utxo) => utxo !== undefined),
+      )
+      .then((result) => {
+        if (!result) throw new Error('Unable to locate IAsset by name.');
+        return result;
+      });
+  }
+}

package/src/helpers/helper-txs.ts

@@ -0,0 +1,30 @@
+import {
+  LucidEvolution,
+  Network,
+  OutRef,
+  SpendingValidator,
+  validatorToAddress,
+} from '@lucid-evolution/lucid';
+import { alwaysFailValidator } from '../scripts/always-fail-validator';
+
+/**
+ * Uses an always fail validator for the destination address.
+ */
+export async function runCreateScriptRefTx(
+  lucid: LucidEvolution,
+  scriptRefValidator: SpendingValidator,
+  network: Network,
+): Promise<OutRef> {
+  const scriptAddr = validatorToAddress(network, alwaysFailValidator);
+
+  const txHash = await lucid
+    .newTx()
+    .pay.ToAddressWithData(scriptAddr, undefined, {}, scriptRefValidator)
+    .complete()
+    .then((tx) => tx.sign.withWallet().complete())
+    .then((tx) => tx.submit());
+
+  await lucid.awaitTx(txHash);
+
+  return { txHash: txHash, outputIndex: 0 };
+}

package/src/helpers/helpers.ts

@@ -1,17 +1,38 @@
 import * as fs from 'fs';
 import { SystemParams } from '../types/system-params';
+import { match, P } from 'ts-pattern';
 
-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
+/**
+ * Accept only a single item in the array and return it.
+ * When not exclusively a single item, throw an error.
+ */
+export function matchSingle<T>(xs: T[], mkErr: (xs: T[]) => Error): T {
+  return match(xs)
+    .with([P.select()], (res) => res as T)
+    .otherwise(() => {
+      throw mkErr(xs);
+    });
+}
+
+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;
+  return JSON.parse(fs.readFileSync(file, 'utf-8')) as SystemParams;
 }
 
 export function loadSystemParamsFromUrl(url: string): Promise<SystemParams> {
-    return fetch(url).then((res: Response) => res.json()).then((data: any) => data as SystemParams);
-}
+  return fetch(url)
+    .then((res: Response) => res.json())
+    .then((data: unknown) => data as SystemParams);
+}
+
+export const getRandomElement = <T>(arr: T[]) =>
+  arr.length ? arr[Math.floor(Math.random() * arr.length)] : undefined;

package/src/helpers/indigo-helpers.ts

@@ -0,0 +1,19 @@
+import {
+  OCD_DECIMAL_UNIT,
+  ocdDiv,
+  ocdMul,
+  OnChainDecimal,
+} from '../types/on-chain-decimal';
+
+export function calculateFeeFromPercentage(
+  feePercentage: OnChainDecimal,
+  amount: bigint,
+): bigint {
+  if (amount < 0) {
+    return 0n;
+  }
+
+  return ocdDiv(ocdMul({ getOnChainInt: amount }, feePercentage), {
+    getOnChainInt: 100n * OCD_DECIMAL_UNIT,
+  }).getOnChainInt;
+}

package/src/helpers/interest-oracle.ts

@@ -0,0 +1,57 @@
+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,
+  interestRate: bigint,
+): bigint {
+  return (
+    (timePeriod * interestRate * unitaryInterestPrecision) /
+    oneYear /
+    decimalUnit
+  );
+}
+
+export function calculateUnitaryInterestSinceOracleLastUpdated(
+  now: bigint,
+  oracleDatum: InterestOracleDatum,
+): bigint {
+  return calculateUnitaryInterest(
+    now - oracleDatum.lastUpdated,
+    oracleDatum.interestRate.getOnChainInt,
+  );
+}
+
+export function 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.getOnChainInt *
+        mintedAmount) /
+      oneYear /
+      decimalUnit;
+
+    return interestFromPreviousRates + lastRateInterest;
+  } else {
+    return (
+      ((now - interestLastSettled) *
+        interestOracleDatum.interestRate.getOnChainInt *
+        mintedAmount) /
+      oneYear /
+      decimalUnit
+    );
+  }
+}