@indigo-labs/indigo-sdk 0.1.3 → 0.1.4

package/src/contracts/staking.ts

@@ -1,348 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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/helpers/helper-txs.ts

@@ -1,30 +0,0 @@
-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,38 +0,0 @@
-import * as fs from 'fs';
-import { SystemParams } from '../types/system-params';
-import { match, P } from 'ts-pattern';
-
-/**
- * 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;
-}
-
-export function loadSystemParamsFromUrl(url: string): Promise<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

@@ -1,19 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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
-    );
-  }
-}