@indigo-labs/indigo-sdk 0.2.41 → 0.3.0

package/src/types/system-params.ts

@@ -1,10 +1,130 @@
-import { Credential, fromText, OutRef, toText } from '@lucid-evolution/lucid';
-import { AssetClass, CurrencySymbol, TokenName } from './generic';
+import { AssetClass } from '@3rd-eye-labs/cardano-offchain-common';
+import {
+  Credential,
+  fromHex,
+  fromText,
+  OutRef,
+  toHex,
+  toText,
+} from '@lucid-evolution/lucid';
+import { AssetClassD, StakeCredential } from './generic';
+import {
+  DerivedPythPrice,
+  PythFeedParams,
+  toDataDerivedPythPrice,
+} from '../contracts/pyth-feed/types';
+import { match } from 'ts-pattern';
+import { P } from 'ts-pattern';
+
+export interface CurrencySymbolSP {
+  unCurrencySymbol: string;
+}
+
+export interface TokenNameSP {
+  unTokenName: string;
+}
 
 /**
  * AssetClassSP used in System Params
  */
-export type AssetClassSP = [CurrencySymbol, TokenName];
+export type AssetClassSP = [CurrencySymbolSP, TokenNameSP];
+
+export type PythPriceConfigurationSP = {
+  priceFeedId: number;
+};
+
+export type DerivedPythPriceSP =
+  | {
+      tag: 'value';
+      val: PythPriceConfigurationSP;
+    }
+  | {
+      tag: 'inverse';
+      val: DerivedPythPriceSP;
+    }
+  | {
+      tag: 'divide';
+      val: [DerivedPythPriceSP, DerivedPythPriceSP];
+    };
+
+export type PythFeedParamsSP = {
+  config: DerivedPythPriceSP;
+  pythStatePolicyId: CurrencySymbolSP;
+};
+
+export function fromSysParamsDerivedPythPrice(
+  cfg: DerivedPythPriceSP,
+): DerivedPythPrice {
+  return match(cfg)
+    .returnType<DerivedPythPrice>()
+    .with({ tag: 'value', val: P.select() }, (val) => {
+      return {
+        Value: {
+          configuration: {
+            priceFeedId: BigInt(val.priceFeedId),
+          },
+        },
+      };
+    })
+    .with({ tag: 'inverse', val: P.select() }, (val) => {
+      return {
+        Inverse: {
+          value: toDataDerivedPythPrice(fromSysParamsDerivedPythPrice(val)),
+        },
+      };
+    })
+    .with({ tag: 'divide', val: P.select() }, (val) => {
+      return {
+        Divide: {
+          x: toDataDerivedPythPrice(fromSysParamsDerivedPythPrice(val[0])),
+          y: toDataDerivedPythPrice(fromSysParamsDerivedPythPrice(val[1])),
+        },
+      };
+    })
+    .exhaustive();
+}
+
+export function fromSysParamsPythFeedParams(
+  params: PythFeedParamsSP,
+): PythFeedParams {
+  return {
+    config: fromSysParamsDerivedPythPrice(params.config),
+    pythStatePolicyId: fromHex(params.pythStatePolicyId.unCurrencySymbol),
+  };
+}
+
+export type PythFeedConfig = {
+  params: PythFeedParamsSP;
+  pythFeedValHash: string;
+  pythFeedValScriptRef: ScriptReference;
+};
+
+export type PythConfig = {
+  pythStateAssetClass: AssetClassSP;
+  /**
+   * Key is in the format: "iAsset.ascii/Collateral.currency.hex.Collateral.tokenName.hex".
+   * Use the `getPythFeedConfig` helper to querying.
+   */
+  pythFeeds: {
+    [key: string]: PythFeedConfig;
+  };
+};
+
+export function getPythFeedConfig(
+  cfg: PythConfig,
+  iasset: Uint8Array<ArrayBufferLike>,
+  collateralAsset: AssetClass,
+): PythFeedConfig {
+  const res =
+    cfg.pythFeeds[
+      `${toText(toHex(iasset))}/${toHex(collateralAsset.currencySymbol)}.${toHex(collateralAsset.tokenName)}`
+    ];
+
+  if (res == null)
+    throw new Error('No Pyth config known for such assets combination');
+
+  return res;
+}
 
 export interface SystemParams {
   versionRecordParams: VersionRecordParams;
@@ -13,31 +133,38 @@ export interface SystemParams {
   startTime: StartTime;
   stakingParams: StakingParamsSP;
   stabilityPoolParams: StabilityPoolParamsSP;
+  stableswapParams: StableswapParamsSP;
   scriptReferences: ScriptReferences;
   pollShardParams: PollShardParamsSP;
   pollManagerParams: PollManagerParamsSP;
-  lrpParams: LrpParamsSP;
+  robParams: RobParamsSP;
+  interestCollectionParams: InterestCollectionParamsSP;
   indyToken: AssetClassSP;
   govParams: GovParamsSP;
   executeParams: ExecuteParamsSP;
-  distributionParams: DistributionParams;
   collectorParams: CollectorParamsSP;
   cdpParams: CdpParamsSP;
   cdpCreatorParams: CDPCreatorParamsSP;
+  cdpRedeemParams: CdpRedeemParamsSP;
+  iassetParams: IAssetParamsSP;
+  pythConfig: PythConfig;
 }
 export type ValidatorHashes = {
   versionRegistryHash: string;
   treasuryHash: string;
+  stableswapHash: string;
   stakingHash: string;
   stabilityPoolHash: string;
   pollShardHash: string;
   pollManagerHash: string;
-  lrpHash: string;
+  robHash: string;
+  interestCollectionHash: string;
   govHash: string;
   executeHash: string;
   collectorHash: string;
   cdpHash: string;
   cdpCreatorHash: string;
+  iassetHash: string;
 };
 export interface AddressCredential {
   tag: string;
@@ -60,7 +187,7 @@ export interface VersionRecordParams {
 export interface TreasuryParamsSP {
   upgradeToken: AssetClassSP;
   versionRecordToken: AssetClassSP;
-  treasuryUtxosStakeCredential?: ScriptCredential;
+  treasuryUtxosStakeCredential: ScriptCredential | undefined;
 }
 export interface StartTime {
   slot: number;
@@ -78,32 +205,43 @@ export interface StabilityPoolParamsSP {
   versionRecordToken: AssetClassSP;
   stabilityPoolToken: AssetClassSP;
   snapshotEpochToScaleToSumToken: AssetClassSP;
-  requestCollateralLovelaces: number;
   iAssetAuthToken: AssetClassSP;
-  govNFT: AssetClassSP;
-  collectorValHash: string;
+  iassetValHash: string;
   cdpToken: AssetClassSP;
-  assetSymbol: CurrencySymbol;
+  assetSymbol: CurrencySymbolSP;
   accountToken: AssetClassSP;
   accountCreateFeeLovelaces: number;
-  accountAdjustmentFeeLovelaces: number;
+  accountProcessingCooldownMs: number;
+  accountProcessingBiasMs: number;
+  stakeCredential: ScriptCredential | undefined;
+}
+
+export interface StableswapParamsSP {
+  iassetSymbol: CurrencySymbolSP;
+  cdpToken: AssetClassSP;
+  versionRecordToken: AssetClassSP;
+  cdpValHash: string;
+  treasuryValHash: string;
 }
 
 export interface ScriptReferences {
   versionRegistryValidatorRef: ScriptReference;
-  versionRecordTokenPolicyRef: ScriptReference;
   treasuryValidatorRef: ScriptReference;
   stakingValidatorRef: ScriptReference;
   stabilityPoolValidatorRef: ScriptReference;
+  stableswapValidatorRef: ScriptReference;
   pollShardValidatorRef: ScriptReference;
   pollManagerValidatorRef: ScriptReference;
-  lrpValidatorRef: ScriptReference;
+  robValidatorRef: ScriptReference;
+  interestCollectionValidatorRef: ScriptReference;
   iAssetTokenPolicyRef: ScriptReference;
   governanceValidatorRef: ScriptReference;
   executeValidatorRef: ScriptReference;
   collectorValidatorRef: ScriptReference;
   cdpValidatorRef: ScriptReference;
   cdpCreatorValidatorRef: ScriptReference;
+  cdpRedeemValidatorRef: ScriptReference;
+  iassetValidatorRef: ScriptReference;
   authTokenPolicies: AuthTokenPolicies;
 }
 export interface Output {
@@ -125,7 +263,9 @@ export interface AddressCredentialOrDatum {
   contents: string;
 }
 export interface Amount {
-  getValue?: ((CurrencySymbol | (number[] | null)[] | null)[] | null)[] | null;
+  getValue?:
+    | ((CurrencySymbolSP | (number[] | null)[] | null)[] | null)[]
+    | null;
 }
 export interface AddressSP {
   addressStakingCredential?: null;
@@ -150,15 +290,29 @@ export interface AuthTokenPolicies {
   pollManagerTokenRef: ScriptReference;
   iAssetAuthTokenRef: ScriptReference;
   iAssetTokenRef: ScriptReference;
+  collateralAssetTokenRef: ScriptReference;
   cdpAuthTokenRef: ScriptReference;
   accountTokenRef: ScriptReference;
+  versionRecordTokenPolicyRef: ScriptReference;
 }
 
-export interface LrpParamsSP {
+export interface RobParamsSP {
   versionRecordToken: AssetClassSP;
-  iassetNft: AssetClassSP;
-  iassetPolicyId: CurrencySymbol;
-  minRedemptionLovelacesAmt: bigint;
+  iassetAuthToken: AssetClassSP;
+  collateralAssetAuthToken: AssetClassSP;
+  iassetValHash: string;
+  iassetPolicyId: CurrencySymbolSP;
+}
+
+export interface InterestCollectionParamsSP {
+  versionRecordNft: AssetClassSP;
+  multisigUtxoNft: AssetClassSP;
+  cdpAuthTk: AssetClassSP;
+  collateralAssetAuthTk: AssetClassSP;
+  govAuthTk: AssetClassSP;
+  cdpAssetSymbol: CurrencySymbolSP;
+  cdpBiasTime: bigint;
+  interestSettlementCooldown: bigint;
 }
 
 export interface PollShardParamsSP {
@@ -174,7 +328,6 @@ export interface PollManagerParamsSP {
   shardsValHash: string;
   pollToken: AssetClassSP;
   pBiasTime: bigint;
-  initialIndyDistribution: bigint;
   indyAsset: AssetClassSP;
   govNFT: AssetClassSP;
   govExecuteValHash: string;
@@ -185,71 +338,97 @@ export interface GovParamsSP {
   upgradeToken: AssetClassSP;
   pollToken: AssetClassSP;
   pollManagerValHash: string;
+  iassetValHash: string;
   indyAsset: AssetClassSP;
   iAssetAuthToken: AssetClassSP;
   govNFT: AssetClassSP;
   gBiasTime: bigint;
   daoIdentityToken: AssetClassSP;
+  iassetSymbol: CurrencySymbolSP;
 }
 
 export interface ExecuteParamsSP {
   govNFT: AssetClassSP;
   upgradeToken: AssetClassSP;
   iAssetToken: AssetClassSP;
+  collateralAssetToken: AssetClassSP;
   stabilityPoolToken: AssetClassSP;
+  cdpCreatorToken: AssetClassSP;
+  cdpToken: AssetClassSP;
   versionRecordToken: AssetClassSP;
+  iassetValHash: string;
   cdpValHash: string;
   sPoolValHash: string;
   versionRegistryValHash: string;
   treasuryValHash: string;
-  indyAsset: AssetClassSP;
-}
-export interface DistributionParams {
-  treasuryIndyAmount: number;
-  totalINDYSupply: number;
-  initialIndyDistribution: number;
 }
 export interface CollectorParamsSP {
   versionRecordToken: AssetClassSP;
   stakingToken: AssetClassSP;
   stakingManagerNFT: AssetClassSP;
 }
+export interface CdpRedeemParamsSP {
+  treasuryValHash: string;
+  iassetValHash: string;
+  partialRedemptionExtraFeeLovelace: number;
+  iAssetAuthToken: AssetClassSP;
+  collateralAssetAuthToken: AssetClassSP;
+  govNFT: AssetClassSP;
+  interestCollectorValHash: string;
+  cdpAuthToken: AssetClassSP;
+  cdpAssetSymbol: CurrencySymbolSP;
+  biasTime: bigint;
+}
 export interface CdpParamsSP {
-  versionRecordToken: AssetClassSP;
   upgradeToken: AssetClassSP;
+  versionRecordToken: AssetClassSP;
   treasuryValHash: string;
   stabilityPoolAuthToken: AssetClassSP;
   spValHash: string;
-  partialRedemptionExtraFeeLovelace: number;
-  minCollateralInLovelace: number;
+  iassetValHash: string;
   iAssetAuthToken: AssetClassSP;
-  govNFT: AssetClassSP;
-  collectorValHash: string;
+  collateralAssetAuthToken: AssetClassSP;
+  interestCollectorValHash: string;
+  cdpRedeemValHash: string;
   cdpAuthToken: AssetClassSP;
-  cdpAssetSymbol: CurrencySymbol;
-  biasTime: number;
+  cdpAssetSymbol: CurrencySymbolSP;
+  biasTime: bigint;
+}
+
+export interface IAssetParamsSP {
+  upgradeToken: AssetClassSP;
+  versionRecordToken: AssetClassSP;
 }
 
 export interface CDPCreatorParamsSP {
   versionRecordToken: AssetClassSP;
-  minCollateralInLovelace: number;
+  upgradeToken: AssetClassSP;
   iAssetAuthTk: AssetClassSP;
-  collectorValHash: string;
+  collateralAssetAuthTk: AssetClassSP;
+  treasuryValHash: string;
   cdpScriptHash: string;
+  iassetValHash: string;
   cdpCreatorNft: AssetClassSP;
   cdpAuthTk: AssetClassSP;
-  cdpAssetCs: CurrencySymbol;
+  cdpAssetCs: CurrencySymbolSP;
   biasTime: bigint;
 }
 
 export function toSystemParamsAsset(asset: AssetClass): AssetClassSP {
   return [
-    { unCurrencySymbol: asset.currencySymbol },
-    { unTokenName: toText(asset.tokenName) },
+    { unCurrencySymbol: toHex(asset.currencySymbol) },
+    { unTokenName: toText(toHex(asset.tokenName)) },
   ];
 }
 
 export function fromSystemParamsAsset(asset: AssetClassSP): AssetClass {
+  return {
+    currencySymbol: fromHex(asset[0].unCurrencySymbol),
+    tokenName: fromHex(fromText(asset[1].unTokenName)),
+  };
+}
+
+export function fromSystemParamsAssetLucid(asset: AssetClassSP): AssetClassD {
   return {
     currencySymbol: asset[0].unCurrencySymbol,
     tokenName: fromText(asset[1].unTokenName),
@@ -260,8 +439,25 @@ export function fromSystemParamsScriptRef(ref: ScriptReference): OutRef {
   return { outputIndex: ref.input.index, txHash: ref.input.transactionId };
 }
 
-export function fromSysParamsScriptCredential(
-  cred: ScriptCredential,
-): Credential {
+export function fromSysParamsCredential(cred: ScriptCredential): Credential {
+  if (cred.contents.tag === 'PublicKeyCredential') {
+    return { type: 'Key', hash: cred.contents.contents };
+  }
   return { type: 'Script', hash: cred.contents.contents };
 }
+
+export function fromSysParamsStakeCredential(
+  cred: ScriptCredential,
+): StakeCredential {
+  return {
+    Inline: [
+      cred.contents.tag === 'PublicKeyCredential'
+        ? {
+            PublicKeyCredential: [cred.contents.contents],
+          }
+        : {
+            ScriptCredential: [cred.contents.contents],
+          },
+    ],
+  };
+}

package/src/utils/array-utils.ts

@@ -1,4 +1,11 @@
-import { array as A, ord as Ord } from 'fp-ts';
+import {
+  array as A,
+  ord as Ord,
+  readonlyArray as RA,
+  option as O,
+  function as F,
+} from 'fp-ts';
+import { Predicate } from 'fp-ts/lib/Predicate';
 
 export function shuffle<T>(arr: T[]): T[] {
   const source = [...arr];
@@ -37,3 +44,65 @@ export function insertSorted<T>(arr: T[], item: T, ord: Ord.Ord<T>): T[] {
 
   return [...arr, item];
 }
+
+/**
+ * Replace when existent, otherwise add at the end.
+ */
+export const repsertReadonlyArr =
+  <K, V>(predicate: Predicate<K>, val: V, mkKey: () => K) =>
+  (arr: ReadonlyArray<readonly [K, V]>): ReadonlyArray<readonly [K, V]> => {
+    const idx = F.pipe(
+      arr,
+      RA.findIndex(([key, _]) => predicate(key)),
+    );
+
+    const res = F.pipe(
+      idx,
+      O.chain((i) =>
+        F.pipe(
+          arr,
+          RA.modifyAt(i, ([key, _]) => [key, val]),
+        ),
+      ),
+    );
+
+    return F.pipe(
+      res,
+      O.getOrElse<ReadonlyArray<readonly [K, V]>>(() => [
+        ...arr,
+        [mkKey(), val],
+      ]),
+    );
+  };
+
+export const repsertWithReadonlyArr =
+  <K, V>(
+    predicate: Predicate<K>,
+    replaceVal: (oldVal: V) => V,
+    newVal: () => V,
+    mkKey: () => K,
+  ) =>
+  (arr: ReadonlyArray<readonly [K, V]>): ReadonlyArray<readonly [K, V]> => {
+    const idx = F.pipe(
+      arr,
+      RA.findIndex(([key, _]) => predicate(key)),
+    );
+
+    const res = F.pipe(
+      idx,
+      O.chain((i) =>
+        F.pipe(
+          arr,
+          RA.modifyAt(i, ([key, oldVal]) => [key, replaceVal(oldVal)]),
+        ),
+      ),
+    );
+
+    return F.pipe(
+      res,
+      O.getOrElse<ReadonlyArray<readonly [K, V]>>(() => [
+        ...arr,
+        [mkKey(), newVal()],
+      ]),
+    );
+  };

package/src/utils/bigint-utils.ts

@@ -1,6 +1,14 @@
 import Decimal from 'decimal.js';
 import { array as A, ord as Ord } from 'fp-ts';
 
+/**
+ * Plutus division behaves differently when working with negative numbers vs positive ones.
+ */
+export function divideOnChainCompatible(a: bigint, b: bigint): bigint {
+  const res = a / b;
+  return res + (res < 0n ? -1n : 0n);
+}
+
 export function bigintMax(a: bigint, b: bigint): bigint {
   return a > b ? a : b;
 }
@@ -17,6 +25,10 @@ export function fromDecimal(val: Decimal): bigint {
   return BigInt(val.toString());
 }
 
+export function zeroNegatives(a: bigint): bigint {
+  return bigintMax(0n, a);
+}
+
 export const BigIntOrd: Ord.Ord<bigint> = {
   equals: (x, y) => x === y,
   compare: (first, second) => (first < second ? -1 : first > second ? 1 : 0),

package/src/utils/indigo-helpers.ts

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

package/src/utils/lucid-utils.ts

@@ -2,53 +2,26 @@ import {
   addAssets,
   Address,
   Assets,
+  calculateMinLovelaceFromUTxO,
   Credential,
   credentialToAddress,
+  Data,
   Datum,
   LucidEvolution,
   Network,
+  OutputDatum,
   OutRef,
   paymentCredentialOf,
+  ProtocolParameters,
+  Script,
   ScriptHash,
   scriptHashToCredential,
-  SLOT_CONFIG_NETWORK,
   stakeCredentialOf,
+  TxBuilder,
   UTxO,
 } from '@lucid-evolution/lucid';
 import { ScriptReference } from '../types/system-params';
-import { matchSingle } from './utils';
-
-/**
- * Union type accepting either a full UTxO or just an OutRef.
- * When a full UTxO is provided, no network fetch is needed.
- * When only an OutRef is provided, the UTxO will be fetched via utxosByOutRef.
- */
-export type UtxoOrOutRef = UTxO | OutRef;
-
-/**
- * Resolves a UTxOOrOutRef to a full UTxO.
- * If the input is already a UTxO (has 'address' property), returns it directly.
- * If the input is an OutRef, fetches the UTxO from the network.
- *
- * @param input - Either a full UTxO or an OutRef
- * @param lucid - The LucidEvolution instance for network queries
- * @param errorMsg - Custom error message if the UTxO cannot be found
- * @returns The resolved UTxO
- */
-export async function resolveUtxo(
-  input: UtxoOrOutRef,
-  lucid: LucidEvolution,
-  errorMsg: string = 'Expected a single UTXO',
-): Promise<UTxO> {
-  // UTxO has 'address' property, OutRef only has 'txHash' and 'outputIndex'
-  if ('address' in input) {
-    return input;
-  }
-  return matchSingle(
-    await lucid.utxosByOutRef([input]),
-    (_) => new Error(errorMsg),
-  );
-}
+import { match, P } from 'ts-pattern';
 
 /**
  * Returns the inline datum.
@@ -73,12 +46,14 @@ export async function addrDetails(
   lucid: LucidEvolution,
 ): Promise<[Credential, Credential | undefined]> {
   const addr = await lucid.wallet().address();
+
   let stakeCredential = undefined;
   try {
     stakeCredential = stakeCredentialOf(addr);
   } catch (_) {
     // No stake credential
   }
+
   return [paymentCredentialOf(addr), stakeCredential];
 }
 
@@ -105,14 +80,46 @@ export async function scriptRef(
   return utxos[0];
 }
 
+/**
+ * Complete, sign with wallet, submit a tx and wait for confirmation.
+ */
+export async function submitTx(
+  lucid: LucidEvolution,
+  tx: TxBuilder,
+): Promise<void> {
+  const txHash = await tx
+    .complete()
+    .then((t) => t.sign.withWallet().complete())
+    .then((t) => t.submit());
+  await lucid.awaitTx(txHash);
+}
+
 export function balance(utxos: UTxO[]): Assets {
   return utxos.reduce((acc, utxo) => addAssets(acc, utxo.assets), {});
 }
 
-export function updateSlotConfigNetwork(
-  slotConfigNetwork: typeof SLOT_CONFIG_NETWORK,
-) {
-  for (const [key, value] of Object.entries(slotConfigNetwork)) {
-    SLOT_CONFIG_NETWORK[key as keyof typeof SLOT_CONFIG_NETWORK] = value;
-  }
+/**
+ * Estimate the min lovelace for a UTXO so it can be created.
+ */
+export function estimateUtxoMinLovelace(
+  protocolParameters: ProtocolParameters,
+  destinationAddr: string,
+  assets: Assets,
+  destinationDatum: OutputDatum | undefined = undefined,
+  scriptRef: Script | undefined = undefined,
+): bigint {
+  return calculateMinLovelaceFromUTxO(protocolParameters.coinsPerUtxoByte, {
+    address: destinationAddr,
+    datumHash: match(destinationDatum)
+      .with({ kind: 'hash', value: P.select() }, (dHash) => dHash)
+      .otherwise(() => null),
+    datum: match(destinationDatum)
+      .with({ kind: 'inline', value: P.select() }, (data) => Data.to(data))
+      .otherwise(() => null),
+    assets: assets,
+    // Use dummy tx hash and out idx
+    txHash: '0000000000000000000000000000000000000000000000000000000000000000',
+    outputIndex: 0,
+    scriptRef: scriptRef ?? null,
+  } satisfies UTxO);
 }