@indigo-labs/indigo-sdk 0.5.4 → 0.5.6

package/src/contracts/treasury/queries.ts

@@ -1,100 +0,0 @@
-import { LucidEvolution, UTxO } from '@lucid-evolution/lucid';
-import { option as O, function as F } from 'fp-ts';
-import {
-  AssetClass,
-  assetClassToUnit,
-  assetClassValueOf,
-  getRandomElement,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import { fromSystemParamsAsset, SystemParams } from '../../types/system-params';
-
-export async function findAllTreasuryUtxos(
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-): Promise<UTxO[]> {
-  // We need to consider both with staking credential and without.
-  return lucid.utxosAt({
-    type: 'Script',
-    hash: sysParams.validatorHashes.treasuryHash,
-  });
-}
-
-export async function findRandomTreasuryUtxo(
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-): Promise<UTxO> {
-  // We need to consider both with staking credential and without.
-  const treasuryUtxos = await findAllTreasuryUtxos(lucid, sysParams);
-
-  return F.pipe(
-    O.fromNullable(getRandomElement(treasuryUtxos)),
-    O.match(() => {
-      throw new Error('Expected some treasury UTXOs.');
-    }, F.identity),
-  );
-}
-
-export async function findRandomTreasuryUtxoWithOnlyAda(
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-): Promise<UTxO> {
-  // We need to consider both with staking credential and without.
-  const treasuryUtxos = await findAllTreasuryUtxos(lucid, sysParams);
-
-  const adaOnlyTreasuryUtxos = treasuryUtxos.filter(
-    (utxo) => Object.keys(utxo.assets).length == 1,
-  );
-
-  return F.pipe(
-    O.fromNullable(getRandomElement(adaOnlyTreasuryUtxos)),
-    O.match(() => {
-      throw new Error('Expected some treasury UTXOs.');
-    }, F.identity),
-  );
-}
-
-export async function findRandomTreasuryUtxoWithAsset(
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-  asset: AssetClass,
-  max_number_of_assets: bigint = 2n,
-): Promise<UTxO> {
-  // We need to consider both with staking credential and without.
-  const treasuryUtxos = await lucid.utxosAtWithUnit(
-    { hash: sysParams.validatorHashes.treasuryHash, type: 'Script' },
-    assetClassToUnit(asset),
-  );
-
-  const validTreasuryUtxos = treasuryUtxos.filter(
-    (utxo) => Object.keys(utxo.assets).length <= max_number_of_assets,
-  );
-
-  return F.pipe(
-    O.fromNullable(getRandomElement(validTreasuryUtxos)),
-    O.match(() => {
-      throw new Error('Expected some treasury UTXOs.');
-    }, F.identity),
-  );
-}
-
-export async function findAllTreasuryUtxosWithNonAdaAsset(
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-  includeDaoToken: boolean = true,
-): Promise<UTxO[]> {
-  // We need to consider both with staking credential and without.
-  const treasuryUtxos = await findAllTreasuryUtxos(lucid, sysParams);
-
-  const treasuryUtxosWithNonAdaAsset = treasuryUtxos.filter(
-    (utxo) =>
-      Object.keys(utxo.assets).length !== 1 &&
-      (includeDaoToken
-        ? true
-        : assetClassValueOf(
-            utxo.assets,
-            fromSystemParamsAsset(sysParams.govParams.daoIdentityToken),
-          ) === 0n),
-  );
-
-  return treasuryUtxosWithNonAdaAsset;
-}

package/src/contracts/treasury/scripts.ts

@@ -1,27 +0,0 @@
-import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
-import {
-  fromSysParamsStakeCredential,
-  fromSystemParamsAssetLucid,
-  TreasuryParamsSP,
-} from '../../types/system-params';
-import { _treasuryValidator } from '../../validators/treasury-validator';
-import { castTreasuryParams } from './types';
-
-export const mkTreasuryValidatorFromSP = (
-  params: TreasuryParamsSP,
-): SpendingValidator => {
-  return {
-    type: 'PlutusV3',
-    script: applyParamsToScript(_treasuryValidator.cborHex, [
-      castTreasuryParams({
-        upgradeToken: fromSystemParamsAssetLucid(params.upgradeToken),
-        versionRecordToken: fromSystemParamsAssetLucid(
-          params.versionRecordToken,
-        ),
-        treasuryUtxosStakeCredential: params.treasuryUtxosStakeCredential
-          ? fromSysParamsStakeCredential(params.treasuryUtxosStakeCredential)
-          : null,
-      }),
-    ]),
-  };
-};

package/src/contracts/treasury/transactions.ts

@@ -1,334 +0,0 @@
-import {
-  addAssets,
-  Assets,
-  Data,
-  fromHex,
-  LucidEvolution,
-  OutRef,
-  TxBuilder,
-  UTxO,
-} from '@lucid-evolution/lucid';
-import {
-  fromSystemParamsScriptRef,
-  SystemParams,
-} from '../../types/system-params';
-import { matchSingle } from '../../utils/utils';
-import {
-  adaAssetClass,
-  AssetClass,
-  estimateUtxoMinLovelace,
-  mkAssetsOf,
-  mkLovelacesOf,
-  negateAssets,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import { serialiseTreasuryDatum, serialiseTreasuryRedeemer } from './types-new';
-import { array as A, function as F } from 'fp-ts';
-import { parseExecuteDatumOrThrow } from '../execute/types-new';
-import { getInlineDatumOrThrow } from '../../utils/lucid-utils';
-import { createValueFromWithdrawal } from '../gov/helpers';
-import { mkTreasuryAddr } from './helpers';
-
-export async function treasuryFeeTx(
-  assetToPay: AssetClass,
-  amountToPay: bigint,
-  extraLovelaces: bigint,
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-  tx: TxBuilder,
-  actionOref: OutRef,
-  /**
-   * `undefined` in case using direct treasury payment.
-   */
-  treasuryOref: OutRef | undefined,
-): Promise<UTxO | null> {
-  const [asset, amt, extraLov] = ((): [AssetClass, bigint, bigint] => {
-    if (amountToPay <= 0 && extraLovelaces > 0) {
-      return [adaAssetClass, extraLovelaces, 0n];
-    }
-
-    return [assetToPay, amountToPay, extraLovelaces];
-  })();
-
-  // If no fee is to be collected, do not include treasury collection.
-  if (amt <= 0n) return null;
-
-  let treasuryRefScriptUtxo = null;
-
-  if (treasuryOref !== undefined) {
-    const treasuryUtxo = matchSingle(
-      await lucid.utxosByOutRef([treasuryOref]),
-      (_) => new Error('Expected a single treasury UTXO'),
-    );
-
-    treasuryRefScriptUtxo = matchSingle(
-      await lucid.utxosByOutRef([
-        fromSystemParamsScriptRef(
-          sysParams.scriptReferences.treasuryValidatorRef,
-        ),
-      ]),
-      (_) => new Error('Expected a single treasury Ref Script UTXO'),
-    );
-
-    tx.readFrom([treasuryRefScriptUtxo])
-      .collectFrom(
-        [treasuryUtxo],
-        serialiseTreasuryRedeemer({
-          Collect: {
-            assetToCollect: asset,
-            amountToCollect: amt,
-            extraLovelaces: extraLov,
-            actionInputOref: {
-              txHash: fromHex(actionOref.txHash),
-              outputIndex: BigInt(actionOref.outputIndex),
-            },
-          },
-        }),
-      )
-      .pay.ToContract(
-        mkTreasuryAddr(lucid, sysParams),
-        {
-          kind: 'inline',
-          value: serialiseTreasuryDatum({
-            treasuryInputOref: {
-              txHash: fromHex(treasuryOref.txHash),
-              outputIndex: BigInt(treasuryOref.outputIndex),
-            },
-            actionInputOref: {
-              txHash: fromHex(actionOref.txHash),
-              outputIndex: BigInt(actionOref.outputIndex),
-            },
-          }),
-        },
-        addAssets(
-          treasuryUtxo.assets,
-          mkAssetsOf(asset, amt),
-          mkLovelacesOf(extraLov),
-        ),
-      );
-  } else {
-    tx.pay.ToContract(
-      mkTreasuryAddr(lucid, sysParams),
-      {
-        kind: 'inline',
-        value: serialiseTreasuryDatum({
-          treasuryInputOref: null,
-          actionInputOref: {
-            txHash: fromHex(actionOref.txHash),
-            outputIndex: BigInt(actionOref.outputIndex),
-          },
-        }),
-      },
-      addAssets(mkAssetsOf(asset, amt), mkLovelacesOf(extraLov)),
-    );
-  }
-
-  return treasuryRefScriptUtxo;
-}
-
-export async function treasuryCollect(
-  assetToPay: AssetClass,
-  amountToPay: bigint,
-  extraLovelaces: bigint,
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-  actionOref: OutRef,
-  treasuryOref: OutRef,
-): Promise<TxBuilder> {
-  const treasuryUtxo = matchSingle(
-    await lucid.utxosByOutRef([treasuryOref]),
-    (_) => new Error('Expected a single treasury UTXO'),
-  );
-
-  const treasuryRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.treasuryValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single treasury Ref Script UTXO'),
-  );
-
-  return lucid
-    .newTx()
-    .readFrom([treasuryRefScriptUtxo])
-    .collectFrom(
-      [treasuryUtxo],
-      serialiseTreasuryRedeemer({
-        Collect: {
-          assetToCollect: assetToPay,
-          amountToCollect: amountToPay,
-          extraLovelaces: extraLovelaces,
-          actionInputOref: {
-            txHash: fromHex(actionOref.txHash),
-            outputIndex: BigInt(actionOref.outputIndex),
-          },
-        },
-      }),
-    )
-    .pay.ToContract(
-      mkTreasuryAddr(lucid, sysParams),
-      {
-        kind: 'inline',
-        value: serialiseTreasuryDatum({
-          treasuryInputOref: {
-            txHash: fromHex(treasuryOref.txHash),
-            outputIndex: BigInt(treasuryOref.outputIndex),
-          },
-          actionInputOref: {
-            txHash: fromHex(actionOref.txHash),
-            outputIndex: BigInt(actionOref.outputIndex),
-          },
-        }),
-      },
-      addAssets(
-        treasuryUtxo.assets,
-        mkAssetsOf(assetToPay, amountToPay),
-        mkLovelacesOf(extraLovelaces),
-      ),
-    );
-}
-
-export async function treasuryMerge(
-  treasuryOutRefs: OutRef[],
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-): Promise<TxBuilder> {
-  const treasuryScriptRefUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.treasuryValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single treasury Ref Script UTXO'),
-  );
-
-  const treasuryUtxos = await lucid.utxosByOutRef(treasuryOutRefs);
-
-  const totalAssets = F.pipe(
-    treasuryUtxos,
-    A.reduce<UTxO, Assets>({}, (acc, utxo) => addAssets(acc, utxo.assets)),
-  );
-
-  return lucid
-    .newTx()
-    .readFrom([treasuryScriptRefUtxo])
-    .collectFrom(treasuryUtxos, serialiseTreasuryRedeemer('Merge'))
-    .pay.ToContract(
-      mkTreasuryAddr(lucid, sysParams),
-      { kind: 'inline', value: Data.void() },
-      totalAssets,
-    );
-}
-
-export async function treasurySplit(
-  treasuryOutRef: OutRef,
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-): Promise<TxBuilder> {
-  const treasuryScriptRefUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.treasuryValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single treasury Ref Script UTXO'),
-  );
-
-  const treasuryUtxo = matchSingle(
-    await lucid.utxosByOutRef([treasuryOutRef]),
-    (_) => new Error('Expected a single treasury UTXO'),
-  );
-
-  const [adaAsset, ...nonAdaAssets] = Object.keys(treasuryUtxo.assets);
-
-  const tx = lucid
-    .newTx()
-    .collectFrom([treasuryUtxo], serialiseTreasuryRedeemer('Split'))
-    .readFrom([treasuryScriptRefUtxo]);
-
-  let paidLovelaces = 0n;
-
-  for (const asset of A.reverse(nonAdaAssets.sort())) {
-    const utxoMinLovelace = estimateUtxoMinLovelace(
-      lucid.config().protocolParameters!,
-      mkTreasuryAddr(lucid, sysParams),
-      { [asset]: treasuryUtxo.assets[asset] },
-      { InlineDatum: { datum: Data.void() } },
-    );
-
-    paidLovelaces += utxoMinLovelace;
-
-    tx.pay.ToContract(
-      mkTreasuryAddr(lucid, sysParams),
-      { kind: 'inline', value: Data.void() },
-      addAssets(
-        { [asset]: treasuryUtxo.assets[asset] },
-        mkLovelacesOf(utxoMinLovelace),
-      ),
-    );
-  }
-
-  tx.pay.ToContract(
-    mkTreasuryAddr(lucid, sysParams),
-    { kind: 'inline', value: Data.void() },
-    { [adaAsset]: treasuryUtxo.assets[adaAsset] - paidLovelaces },
-  );
-
-  return tx;
-}
-
-export async function treasuryPrepareWithdrawal(
-  treasuryOutRefs: OutRef[],
-  upgradeOutRef: OutRef,
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-): Promise<TxBuilder> {
-  const treasuryScriptRefUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.treasuryValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single treasury Ref Script UTXO'),
-  );
-
-  const treasuryUtxos = await lucid.utxosByOutRef(treasuryOutRefs);
-
-  const upgradeUtxo = matchSingle(
-    await lucid.utxosByOutRef([upgradeOutRef]),
-    (_) => new Error('Expected a single upgrade UTXO'),
-  );
-
-  const treasuryAddress = mkTreasuryAddr(lucid, sysParams);
-
-  const totalAssets = F.pipe(
-    treasuryUtxos,
-    A.reduce<UTxO, Assets>({}, (acc, utxo) => addAssets(acc, utxo.assets)),
-  );
-  const executeDatum = parseExecuteDatumOrThrow(
-    getInlineDatumOrThrow(upgradeUtxo),
-  );
-  if (!executeDatum.treasuryWithdrawal)
-    throw new Error('Expected a treasury withdrawal in the execute datum');
-  const withdrawalVal = createValueFromWithdrawal(
-    executeDatum.treasuryWithdrawal,
-  );
-  const change = addAssets(totalAssets, negateAssets(withdrawalVal));
-
-  const tx = lucid
-    .newTx()
-    .collectFrom(treasuryUtxos, serialiseTreasuryRedeemer('PrepareWithdraw'))
-    .readFrom([treasuryScriptRefUtxo, upgradeUtxo])
-    .pay.ToContract(
-      treasuryAddress,
-      { kind: 'inline', value: Data.void() },
-      withdrawalVal,
-    )
-    .pay.ToContract(
-      treasuryAddress,
-      { kind: 'inline', value: Data.void() },
-      change,
-    );
-
-  return tx;
-}

package/src/contracts/treasury/types-new.ts

@@ -1,69 +0,0 @@
-import { TSchema, Data } from '@evolution-sdk/evolution';
-import {
-  AssetClassSchema,
-  OutputReferenceSchema,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
-
-const WithdrawalOutputDatumSchema = TSchema.Tuple([
-  TSchema.ByteArray,
-  OutputReferenceSchema,
-]);
-
-export type WithdrawalOutputDatum = typeof WithdrawalOutputDatumSchema.Type;
-
-const TreasuryDatumSchema = TSchema.Struct(
-  {
-    treasuryInputOref: TSchema.NullOr(OutputReferenceSchema),
-    actionInputOref: OutputReferenceSchema,
-  },
-  { flatFields: true },
-);
-
-export type TreasuryDatum = typeof TreasuryDatumSchema.Type;
-
-const TreasuryRedeemerSchema = TSchema.Union(
-  TSchema.Literal('Withdraw', { flatInUnion: true }),
-  TSchema.Literal('PrepareWithdraw', { flatInUnion: true }),
-  TSchema.Literal('Split', { flatInUnion: true }),
-  TSchema.Literal('Merge', { flatInUnion: true }),
-  TSchema.Struct(
-    {
-      Collect: TSchema.Struct(
-        {
-          assetToCollect: AssetClassSchema,
-          amountToCollect: TSchema.Integer,
-          extraLovelaces: TSchema.Integer,
-          actionInputOref: OutputReferenceSchema,
-        },
-        { flatFields: true },
-      ),
-    },
-    { flatInUnion: true },
-  ),
-  TSchema.Literal('UpgradeVersion', { flatInUnion: true }),
-);
-
-export type TreasuryRedeemer = typeof TreasuryRedeemerSchema.Type;
-
-export function serialiseTreasuryRedeemer(r: TreasuryRedeemer): string {
-  return Data.withSchema(
-    TreasuryRedeemerSchema,
-    DEFAULT_SCHEMA_OPTIONS,
-  ).toCBORHex(r);
-}
-
-export function serialiseWithdrawalOutputDatum(
-  d: WithdrawalOutputDatum,
-): string {
-  return Data.withSchema(
-    WithdrawalOutputDatumSchema,
-    DEFAULT_SCHEMA_OPTIONS,
-  ).toCBORHex(d);
-}
-
-export function serialiseTreasuryDatum(d: TreasuryDatum): string {
-  return Data.withSchema(TreasuryDatumSchema, DEFAULT_SCHEMA_OPTIONS).toCBORHex(
-    d,
-  );
-}

package/src/contracts/treasury/types.ts

@@ -1,14 +0,0 @@
-import { Data } from '@lucid-evolution/lucid';
-import { AssetClassSchema, StakeCredentialSchema } from '../../types/generic';
-
-export const TreasuryParamsSchema = Data.Object({
-  upgradeToken: AssetClassSchema,
-  versionRecordToken: AssetClassSchema,
-  treasuryUtxosStakeCredential: Data.Nullable(StakeCredentialSchema),
-});
-export type TreasuryParams = Data.Static<typeof TreasuryParamsSchema>;
-export const TreasuryParams = TreasuryParamsSchema as unknown as TreasuryParams;
-
-export function castTreasuryParams(params: TreasuryParams): Data {
-  return Data.castTo(params, TreasuryParams);
-}

package/src/contracts/version-registry/scripts.ts

@@ -1,29 +0,0 @@
-import {
-  applyParamsToScript,
-  MintingPolicy,
-  SpendingValidator,
-} from '@lucid-evolution/lucid';
-import {
-  castVersionRecordTokenParams,
-  VersionRecordTokenParams,
-} from './types';
-import { _versionRecordTokenPolicy } from '../../validators/version-record-policy';
-import { _versionRegistryValidator } from '../../validators/version-registry-validator';
-
-export function mkVersionRecordTokenPolicy(
-  params: VersionRecordTokenParams,
-): MintingPolicy {
-  return {
-    type: 'PlutusV3',
-    script: applyParamsToScript(_versionRecordTokenPolicy.cborHex, [
-      castVersionRecordTokenParams(params),
-    ]),
-  };
-}
-
-export const mkVersionRegistryValidator = (): SpendingValidator => {
-  return {
-    type: 'PlutusV3',
-    script: _versionRegistryValidator.cborHex,
-  };
-};

package/src/contracts/version-registry/types-new.ts

@@ -1,18 +0,0 @@
-import { TSchema, Data } from '@evolution-sdk/evolution';
-import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
-
-const VersionRecordDatumSchema = TSchema.Struct({
-  upgradeId: TSchema.Integer,
-  /// Underlying representation of the following mapping: ValidatorHash -> UpgradePath
-  upgradePaths: TSchema.Array(
-    TSchema.Tuple([TSchema.ByteArray, TSchema.ByteArray]),
-  ),
-});
-export type VersionRecordDatum = typeof VersionRecordDatumSchema.Type;
-
-export function serialiseVersionRecordDatum(d: VersionRecordDatum): string {
-  return Data.withSchema(
-    VersionRecordDatumSchema,
-    DEFAULT_SCHEMA_OPTIONS,
-  ).toCBORHex(d);
-}

package/src/contracts/version-registry/types.ts

@@ -1,17 +0,0 @@
-import { Data } from '@lucid-evolution/lucid';
-import { AssetClassSchema } from '../../types/generic';
-
-const VersionRecordTokenParamsSchema = Data.Object({
-  upgradeToken: AssetClassSchema,
-});
-export type VersionRecordTokenParams = Data.Static<
-  typeof VersionRecordTokenParamsSchema
->;
-export const VersionRecordTokenParams =
-  VersionRecordTokenParamsSchema as unknown as VersionRecordTokenParams;
-
-export function castVersionRecordTokenParams(
-  params: VersionRecordTokenParams,
-): Data {
-  return Data.castTo(params, VersionRecordTokenParams);
-}