@indigo-labs/indigo-sdk 0.1.19 → 0.1.21

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/staking-helpers.ts

@@ -1,94 +0,0 @@
-import { fromText, OutRef, UTxO } from '@lucid-evolution/lucid';
-import { LucidEvolution } from '@lucid-evolution/lucid';
-import { StakingContract } from '../contracts/staking';
-import { SystemParams } from '../types/system-params';
-import {
-  parseStakingManagerDatum,
-  parseStakingPositionDatum,
-  StakingManagerContent,
-  StakingPositionContent,
-} from '../types/indigo/staking';
-
-export type StakingPositionOutput = {
-  utxo: UTxO;
-  datum: StakingPositionContent;
-};
-export type StakingManagerOutput = { utxo: UTxO; datum: StakingManagerContent };
-
-export class StakingHelpers {
-  static async findStakingManagerByOutRef(
-    stakingManagerRef: OutRef,
-    lucid: LucidEvolution,
-  ): Promise<StakingManagerOutput> {
-    return lucid
-      .utxosByOutRef([stakingManagerRef])
-      .then((utxos) =>
-        utxos
-          .map((utxo) => {
-            if (!utxo.datum) return undefined;
-            const datum = parseStakingManagerDatum(utxo.datum);
-            return { utxo, datum };
-          })
-          .find((utxo) => utxo !== undefined),
-      )
-      .then((result) => {
-        if (!result)
-          throw new Error(
-            'Unable to locate Staking Manager by output reference.',
-          );
-        return result;
-      });
-  }
-
-  static async findStakingManager(
-    params: SystemParams,
-    lucid: LucidEvolution,
-  ): Promise<StakingManagerOutput> {
-    return lucid
-      .utxosAtWithUnit(
-        StakingContract.address(params.stakingParams, lucid),
-        params.stakingParams.stakingManagerNFT[0].unCurrencySymbol +
-          fromText(params.stakingParams.stakingManagerNFT[1].unTokenName),
-      )
-      .then((utxos) =>
-        utxos
-          .map((utxo) => {
-            if (!utxo.datum) return undefined;
-            const datum = parseStakingManagerDatum(utxo.datum);
-            return { utxo, datum };
-          })
-          .find((utxo) => utxo !== undefined),
-      )
-      .then((result) => {
-        if (!result)
-          throw new Error(
-            'Unable to locate Staking Manager by output reference.',
-          );
-        return result;
-      });
-  }
-
-  static async findStakingPositionByOutRef(
-    stakingPositionRef: OutRef,
-    lucid: LucidEvolution,
-  ): Promise<StakingPositionOutput> {
-    return lucid
-      .utxosByOutRef([stakingPositionRef])
-      .then((utxos) =>
-        utxos
-          .map((utxo) => {
-            if (!utxo.datum) return undefined;
-            const datum = parseStakingPositionDatum(utxo.datum);
-            return { utxo, datum };
-          })
-          .find((utxo) => utxo !== undefined),
-      )
-      .then((result) => {
-        if (!result)
-          throw new Error(
-            'Unable to locate Staking Position by output reference.',
-          );
-        return result;
-      });
-  }
-}

package/src/helpers/time-helpers.ts

@@ -1,4 +0,0 @@
-export const ONE_SECOND: number = 1_000;
-export const oneHour: bigint = 3_600_000n;
-export const oneDay: bigint = 86_400_000n;
-export const oneYear: bigint = 31_536_000_000n;