@indigo-labs/indigo-sdk 0.5.5 → 0.5.6

package/src/contracts/interest-collection/types-new.ts

@@ -1,50 +0,0 @@
-import { TSchema, Data } from '@evolution-sdk/evolution';
-import { MultisigSchema } from '../../types/multisig';
-
-const InterestCollectionDatumSchema = TSchema.Struct({
-  admin_permissions: MultisigSchema,
-});
-
-export type InterestCollectionDatum = typeof InterestCollectionDatumSchema.Type;
-
-const InterestCollectionRedeemerSchema = TSchema.Union(
-  TSchema.Literal('CollectInterest', { flatInUnion: true }),
-  TSchema.Struct(
-    {
-      BatchCollectInterest: TSchema.Struct(
-        {
-          currentTime: TSchema.Integer,
-          ownInputIndex: TSchema.Integer,
-          collateralAssetRefInputIndex: TSchema.Integer,
-          interestOracleRefInputIndex: TSchema.Integer,
-        },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Literal('Distribute', { flatInUnion: true }),
-  TSchema.Literal('UpdatePermissions', { flatInUnion: true }),
-  TSchema.Literal('UpgradeVersion', { flatInUnion: true }),
-);
-
-export type InterestCollectionRedeemer =
-  typeof InterestCollectionRedeemerSchema.Type;
-
-export function serialiseInterestCollectionRedeemer(
-  redeemer: InterestCollectionRedeemer,
-): string {
-  return Data.withSchema(InterestCollectionRedeemerSchema).toCBORHex(redeemer);
-}
-
-export function parseInterestCollectionDatum(
-  datum: string,
-): InterestCollectionDatum {
-  return Data.withSchema(InterestCollectionDatumSchema).fromCBORHex(datum);
-}
-
-export function serialiseInterestCollectionDatum(
-  datum: InterestCollectionDatum,
-): string {
-  return Data.withSchema(InterestCollectionDatumSchema).toCBORHex(datum);
-}

package/src/contracts/interest-collection/types.ts

@@ -1,26 +0,0 @@
-import { Data } from '@lucid-evolution/lucid';
-import { AssetClassSchema } from '../../types/generic';
-
-export const InterestCollectionParamsSchema = Data.Object({
-  versionRecordNft: AssetClassSchema,
-  multisigUtxoNft: AssetClassSchema,
-  cdpAuthTk: AssetClassSchema,
-  collateralAssetAuthTk: AssetClassSchema,
-  govAuthTk: AssetClassSchema,
-  cdpAssetSymbol: Data.Bytes(),
-  cdpBiasTime: Data.Integer(),
-  interestSettlementCooldown: Data.Integer(),
-});
-
-export type InterestCollectionParams = Data.Static<
-  typeof InterestCollectionParamsSchema
->;
-
-const InterestCollectionParams =
-  InterestCollectionParamsSchema as unknown as InterestCollectionParams;
-
-export function castInterestCollectionParams(
-  params: InterestCollectionParams,
-): Data {
-  return Data.castTo(params, InterestCollectionParams);
-}

package/src/contracts/interest-oracle/helpers.ts

@@ -1,61 +0,0 @@
-import { ONE_YEAR } from '../../utils/time-helpers';
-import { OCD_DECIMAL_UNIT } from '../../types/on-chain-decimal';
-import { InterestOracleDatum } from './types-new';
-
-const unitaryInterestPrecision = 1_000_000_000_000_000_000n;
-
-export function calculateUnitaryInterest(
-  timePeriod: bigint,
-  interestRate: bigint,
-): bigint {
-  return (
-    (timePeriod * interestRate * unitaryInterestPrecision) /
-    ONE_YEAR /
-    OCD_DECIMAL_UNIT
-  );
-}
-
-export function calculateUnitaryInterestSinceOracleLastUpdated(
-  now: bigint,
-  oracleDatum: InterestOracleDatum,
-): bigint {
-  return calculateUnitaryInterest(
-    now - oracleDatum.lastUpdated,
-    oracleDatum.interestRate.getOnChainInt,
-  );
-}
-
-export function calculateAccruedInterest(
-  /**
-   * Should be ideally the result of the following: lucid.slotToUnixTime(lucid.currentSlot()).
-   * Otherwise, the unix timestamp should suffice, but might not be 100% precise as on-chain.
-   */
-  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) /
-      ONE_YEAR /
-      OCD_DECIMAL_UNIT;
-
-    return interestFromPreviousRates + lastRateInterest;
-  } else {
-    return (
-      ((now - interestLastSettled) *
-        interestOracleDatum.interestRate.getOnChainInt *
-        mintedAmount) /
-      ONE_YEAR /
-      OCD_DECIMAL_UNIT
-    );
-  }
-}

package/src/contracts/interest-oracle/scripts.ts

@@ -1,18 +0,0 @@
-import { applyParamsToScript } from '@lucid-evolution/lucid';
-import { SpendingValidator } from '@lucid-evolution/lucid';
-import {
-  castInterestOracleParams,
-  InterestOracleParams,
-} from '../interest-oracle/types';
-import { _interestOracleValidator } from '../../validators/interest-oracle-validator';
-
-export function mkInterestOracleValidator(
-  params: InterestOracleParams,
-): SpendingValidator {
-  return {
-    type: 'PlutusV3',
-    script: applyParamsToScript(_interestOracleValidator.cborHex, [
-      castInterestOracleParams(params),
-    ]),
-  };
-}

package/src/contracts/interest-oracle/transactions.ts

@@ -1,151 +0,0 @@
-import {
-  fromHex,
-  fromText,
-  LucidEvolution,
-  OutRef,
-  toUnit,
-  TxBuilder,
-  UTxO,
-  validatorToAddress,
-} from '@lucid-evolution/lucid';
-import { InterestOracleParams } from './types';
-import { oneShotMintTx } from '../one-shot/transactions';
-import { mkInterestOracleValidator } from './scripts';
-import { findInterestOracle } from '../../../tests/queries/interest-oracle-queries';
-import { ONE_SECOND } from '../../utils/time-helpers';
-import { calculateUnitaryInterestSinceOracleLastUpdated } from '../interest-oracle/helpers';
-import { getInlineDatumOrThrow } from '../../utils/lucid-utils';
-import { AssetClass } from '@3rd-eye-labs/cardano-offchain-common';
-import {
-  parseInterestOracleDatum,
-  serialiseFeedInterestOracleRedeemer,
-  serialiseInterestOracleDatum,
-} from './types-new';
-
-export async function startInterestOracle(
-  initialUnitaryInterest: bigint,
-  initialInterestRate: bigint,
-  initialLastInterestUpdate: bigint,
-  oracleParams: InterestOracleParams,
-  lucid: LucidEvolution,
-  interestTokenName?: string,
-  withScriptRef: boolean = false,
-  refOutRef?: OutRef,
-): Promise<[TxBuilder, AssetClass]> {
-  const network = lucid.config().network!;
-
-  const tokenName = interestTokenName ?? 'INTEREST_ORACLE';
-  if (!refOutRef) {
-    refOutRef = (await lucid.wallet().getUtxos())[0];
-  }
-
-  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(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(network, validator),
-      undefined,
-      undefined,
-      validator,
-    );
-  }
-
-  return [
-    tx,
-    {
-      currencySymbol: fromHex(policyId),
-      tokenName: fromHex(fromText(tokenName)),
-    },
-  ];
-}
-
-export async function 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) {
-    utxo = await findInterestOracle(lucid, assetClass);
-  }
-
-  const now = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
-
-  const tx = lucid.newTx();
-  const datum = parseInterestOracleDatum(getInlineDatumOrThrow(utxo!));
-
-  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/interest-oracle/types-new.ts

@@ -1,32 +0,0 @@
-import { TSchema, Data } from '@evolution-sdk/evolution';
-import { OnChainDecimalSchema } from '../../types/on-chain-decimal';
-
-export const InterestOracleDatumSchema = TSchema.Struct({
-  unitaryInterest: TSchema.Integer,
-  interestRate: OnChainDecimalSchema,
-  lastUpdated: TSchema.Integer,
-});
-export type InterestOracleDatum = typeof InterestOracleDatumSchema.Type;
-
-const InterestOracleRedeemerSchema = TSchema.Struct({
-  newInterestRate: OnChainDecimalSchema,
-  currentTime: TSchema.Integer,
-});
-
-export type InterestOracleRedeemer = typeof InterestOracleRedeemerSchema.Type;
-
-export function serialiseFeedInterestOracleRedeemer(
-  redeemer: InterestOracleRedeemer,
-): string {
-  return Data.withSchema(InterestOracleRedeemerSchema).toCBORHex(redeemer);
-}
-
-export function parseInterestOracleDatum(datum: string): InterestOracleDatum {
-  return Data.withSchema(InterestOracleDatumSchema).fromCBORHex(datum);
-}
-
-export function serialiseInterestOracleDatum(
-  datum: InterestOracleDatum,
-): string {
-  return Data.withSchema(InterestOracleDatumSchema).toCBORHex(datum);
-}

package/src/contracts/interest-oracle/types.ts

@@ -1,16 +0,0 @@
-import { Data } from '@lucid-evolution/lucid';
-
-export const InterestOracleParamsSchema = Data.Object({
-  /**  Milliseconds */
-  biasTime: Data.Integer(),
-  owner: Data.Bytes(),
-});
-export type InterestOracleParams = Data.Static<
-  typeof InterestOracleParamsSchema
->;
-const InterestOracleParams =
-  InterestOracleParamsSchema as unknown as InterestOracleParams;
-
-export function castInterestOracleParams(params: InterestOracleParams): Data {
-  return Data.castTo(params, InterestOracleParams);
-}

package/src/contracts/one-shot/scripts.ts

@@ -1,12 +0,0 @@
-import { applyParamsToScript, MintingPolicy } from '@lucid-evolution/lucid';
-import { castOneShotParams, OneShotParams } from './types';
-import { _oneShotPolicy } from '../../validators/one-shot-policy';
-
-export function mkOneShotPolicy(params: OneShotParams): MintingPolicy {
-  return {
-    type: 'PlutusV3',
-    script: applyParamsToScript(_oneShotPolicy.cborHex, [
-      castOneShotParams(params),
-    ]),
-  };
-}

package/src/contracts/one-shot/transactions.ts

@@ -1,66 +0,0 @@
-import {
-  addAssets,
-  Assets,
-  Data,
-  LucidEvolution,
-  mintingPolicyToId,
-  PolicyId,
-  toUnit,
-  TxBuilder,
-} from '@lucid-evolution/lucid';
-import { OneShotParams } from './types';
-import { matchSingle } from '../../utils/utils';
-import { mkOneShotPolicy } from './scripts';
-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.void(),
-      )
-      .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;
-}

package/src/contracts/one-shot/types.ts

@@ -1,22 +0,0 @@
-import { Data } from '@lucid-evolution/lucid';
-
-export const OneShotParamsSchema = Data.Object({
-  referenceOutRef: Data.Object({
-    txHash: Data.Bytes(),
-    outputIdx: Data.Integer(),
-  }),
-  mintAmounts: Data.Array(
-    Data.Object({
-      /// Use hex encoded string
-      tokenName: Data.Bytes(),
-      amount: Data.Integer(),
-    }),
-  ),
-});
-
-export type OneShotParams = Data.Static<typeof OneShotParamsSchema>;
-const OneShotParams = OneShotParamsSchema as unknown as OneShotParams;
-
-export function castOneShotParams(params: OneShotParams): Data {
-  return Data.castTo(params, OneShotParams);
-}

package/src/contracts/poll/helpers.ts

@@ -1,37 +0,0 @@
-import { ocdDiv, OnChainDecimal } from '../../types/on-chain-decimal';
-import { PollStatus } from './types-poll-new';
-
-function q(pollStatus: PollStatus, e: bigint): OnChainDecimal {
-  if (pollStatus.yesVotes + pollStatus.noVotes === 0n)
-    return { getOnChainInt: 0n };
-  else {
-    const q =
-      ocdDiv(
-        { getOnChainInt: pollStatus.yesVotes },
-        { getOnChainInt: BigInt(Math.floor(Math.sqrt(Number(e)))) },
-      ).getOnChainInt -
-      ocdDiv(
-        { getOnChainInt: pollStatus.noVotes },
-        {
-          getOnChainInt: BigInt(
-            Math.floor(
-              Math.sqrt(Number(pollStatus.yesVotes + pollStatus.noVotes)),
-            ),
-          ),
-        },
-      ).getOnChainInt;
-
-    return { getOnChainInt: BigInt(q) };
-  }
-}
-
-export function pollPassQuorum(
-  pollStatus: PollStatus,
-  electorate: bigint,
-  minQuorum: bigint,
-): boolean {
-  return (
-    pollStatus.yesVotes + pollStatus.noVotes >= minQuorum &&
-    q(pollStatus, electorate).getOnChainInt > 50_000n
-  );
-}

package/src/contracts/poll/scripts.ts

@@ -1,71 +0,0 @@
-import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
-import {
-  castPollManagerParams,
-  PollManagerParams,
-} from '../poll/types-poll-manager';
-import {
-  PollManagerParamsSP,
-  PollShardParamsSP,
-  fromSystemParamsAssetLucid,
-} from '../../types/system-params';
-import { castPollShardParams, PollShardParams } from './types-poll-shard';
-import { _pollManagerValidator } from '../../validators/poll-manager-validator';
-import { _pollShardValidator } from '../../validators/poll-shard-validator';
-
-export const mkPollManagerValidator = (
-  params: PollManagerParams,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV3',
-    script: applyParamsToScript(_pollManagerValidator.cborHex, [
-      castPollManagerParams(params),
-    ]),
-  };
-};
-
-export const mkPollManagerValidatorFromSP = (
-  params: PollManagerParamsSP,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV3',
-    script: applyParamsToScript(_pollManagerValidator.cborHex, [
-      castPollManagerParams({
-        govNFT: fromSystemParamsAssetLucid(params.govNFT),
-        pollToken: fromSystemParamsAssetLucid(params.pollToken),
-        upgradeToken: fromSystemParamsAssetLucid(params.upgradeToken),
-        indyAsset: fromSystemParamsAssetLucid(params.indyAsset),
-        govExecuteValHash: params.govExecuteValHash,
-        pBiasTime: BigInt(params.pBiasTime),
-        shardValHash: params.shardsValHash,
-        treasuryValHash: params.treasuryValHash,
-      }),
-    ]),
-  };
-};
-
-export const mkPollShardValidator = (
-  params: PollShardParams,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV3',
-    script: applyParamsToScript(_pollShardValidator.cborHex, [
-      castPollShardParams(params),
-    ]),
-  };
-};
-
-export const mkPollShardValidatorFromSP = (
-  params: PollShardParamsSP,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV3',
-    script: applyParamsToScript(_pollShardValidator.cborHex, [
-      castPollShardParams({
-        pollToken: fromSystemParamsAssetLucid(params.pollToken),
-        stakingToken: fromSystemParamsAssetLucid(params.stakingToken),
-        indyAsset: fromSystemParamsAssetLucid(params.indyAsset),
-        stakingValHash: params.stakingValHash,
-      }),
-    ]),
-  };
-};

package/src/contracts/poll/types-poll-manager.ts

@@ -1,20 +0,0 @@
-import { Data } from '@lucid-evolution/lucid';
-import { AssetClassSchema } from '../../types/generic';
-
-const PollManagerParamsSchema = Data.Object({
-  govNFT: AssetClassSchema,
-  pollToken: AssetClassSchema,
-  upgradeToken: AssetClassSchema,
-  indyAsset: AssetClassSchema,
-  govExecuteValHash: Data.Bytes(),
-  pBiasTime: Data.Integer(),
-  shardValHash: Data.Bytes(),
-  treasuryValHash: Data.Bytes(),
-});
-export type PollManagerParams = Data.Static<typeof PollManagerParamsSchema>;
-export const PollManagerParams =
-  PollManagerParamsSchema as unknown as PollManagerParams;
-
-export function castPollManagerParams(params: PollManagerParams): Data {
-  return Data.castTo(params, PollManagerParams);
-}