@indigo-labs/indigo-sdk 0.2.1 → 0.2.4

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import * as _lucid_evolution_lucid from '@lucid-evolution/lucid';
 import { Data, Network, OutRef, Credential, LucidEvolution, TxBuilder, Redeemer, Datum, UTxO, SpendingValidator, MintingPolicy, ScriptHash, Address, Assets, PolicyId, Unit } from '@lucid-evolution/lucid';
-import { option } from 'fp-ts';
+import { option, ord } from 'fp-ts';
 import { Core } from '@evolution-sdk/evolution';
 
 declare const AssetClassSchema: _lucid_evolution_lucid.TObject<{
@@ -1504,6 +1504,89 @@ declare function spDiv(a: SPInteger, b: SPInteger): SPInteger;
 declare function openStakingPosition(amount: bigint, params: SystemParams, lucid: LucidEvolution, stakingManagerRef?: OutRef): Promise<TxBuilder>;
 declare function adjustStakingPosition(stakingPositionRef: OutRef, amount: bigint, params: SystemParams, lucid: LucidEvolution, stakingManagerRef?: OutRef): Promise<TxBuilder>;
 declare function closeStakingPosition(stakingPositionRef: OutRef, params: SystemParams, lucid: LucidEvolution, stakingManagerRef?: OutRef): Promise<TxBuilder>;
+declare function distributeAda(stakingManagerRef: OutRef, collectorRefs: OutRef[], params: SystemParams, lucid: LucidEvolution): Promise<TxBuilder>;
+
+declare const StakingParamsSchema: _lucid_evolution_lucid.TObject<{
+    stakingManagerNft: _lucid_evolution_lucid.TObject<{
+        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
+        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
+    }>;
+    stakingToken: _lucid_evolution_lucid.TObject<{
+        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
+        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
+    }>;
+    indyToken: _lucid_evolution_lucid.TObject<{
+        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
+        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
+    }>;
+    pollToken: _lucid_evolution_lucid.TObject<{
+        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
+        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
+    }>;
+    versionRecordToken: _lucid_evolution_lucid.TObject<{
+        currencySymbol: _lucid_evolution_lucid.TUnsafe<string>;
+        tokenName: _lucid_evolution_lucid.TUnsafe<string>;
+    }>;
+    collectorValHash: _lucid_evolution_lucid.TUnsafe<string>;
+}>;
+type StakingParams = Data.Static<typeof StakingParamsSchema>;
+declare const StakingParams: StakingParams;
+declare const StakingRedeemerSchema: _lucid_evolution_lucid.TUnion<(_lucid_evolution_lucid.TLiteral<"UpgradeVersion"> | _lucid_evolution_lucid.TObject<{
+    CreateStakingPosition: _lucid_evolution_lucid.TObject<{
+        creatorPkh: _lucid_evolution_lucid.TUnsafe<string>;
+    }>;
+}> | _lucid_evolution_lucid.TLiteral<"UpdateTotalStake"> | _lucid_evolution_lucid.TLiteral<"Distribute"> | _lucid_evolution_lucid.TObject<{
+    AdjustStakedAmount: _lucid_evolution_lucid.TObject<{
+        adjustAmount: _lucid_evolution_lucid.TUnsafe<bigint>;
+    }>;
+}> | _lucid_evolution_lucid.TLiteral<"Unstake"> | _lucid_evolution_lucid.TLiteral<"Lock">)[]>;
+type StakingRedeemer = Data.Static<typeof StakingRedeemerSchema>;
+declare function serialiseStakingRedeemer(redeemer: StakingRedeemer): Redeemer;
+declare function castStakingParams(params: StakingParams): Data;
+
+declare const StakingPosLockedAmtSchema: Core.TSchema.Map<Core.TSchema.Integer, Core.TSchema.Struct<{
+    voteAmt: Core.TSchema.Integer;
+    votingEnd: Core.TSchema.Integer;
+}>>;
+type StakingPosLockedAmt = typeof StakingPosLockedAmtSchema.Type;
+declare const StakingPositionSchema: Core.TSchema.Struct<{
+    owner: Core.TSchema.ByteArray;
+    lockedAmount: Core.TSchema.Map<Core.TSchema.Integer, Core.TSchema.Struct<{
+        voteAmt: Core.TSchema.Integer;
+        votingEnd: Core.TSchema.Integer;
+    }>>;
+    positionSnapshot: Core.TSchema.Struct<{
+        snapshotAda: Core.TSchema.Integer;
+    }>;
+}>;
+type StakingPosition = typeof StakingPositionSchema.Type;
+declare const StakingManagerSchema: Core.TSchema.Struct<{
+    totalStake: Core.TSchema.Integer;
+    managerSnapshot: Core.TSchema.Struct<{
+        snapshotAda: Core.TSchema.Integer;
+    }>;
+}>;
+type StakingManager = typeof StakingManagerSchema.Type;
+declare const StakingDatumSchema: Core.TSchema.Union<[Core.TSchema.Struct<{
+    totalStake: Core.TSchema.Integer;
+    managerSnapshot: Core.TSchema.Struct<{
+        snapshotAda: Core.TSchema.Integer;
+    }>;
+}>, Core.TSchema.Struct<{
+    owner: Core.TSchema.ByteArray;
+    lockedAmount: Core.TSchema.Map<Core.TSchema.Integer, Core.TSchema.Struct<{
+        voteAmt: Core.TSchema.Integer;
+        votingEnd: Core.TSchema.Integer;
+    }>>;
+    positionSnapshot: Core.TSchema.Struct<{
+        snapshotAda: Core.TSchema.Integer;
+    }>;
+}>]>;
+type StakingDatum = typeof StakingDatumSchema.Type;
+declare function parseStakingPosition(datum: string): option.Option<StakingPosition>;
+declare function parseStakingPositionOrThrow(datum: string): StakingPosition;
+declare function parseStakingManagerDatum(datum: string): StakingManager;
+declare function serialiseStakingDatum(d: StakingDatum): string;
 
 declare function startInterestOracle(initialUnitaryInterest: bigint, initialInterestRate: bigint, initialLastInterestUpdate: bigint, oracleParams: InterestOracleParams, lucid: LucidEvolution, interestTokenName?: string, withScriptRef?: boolean, refOutRef?: OutRef): Promise<[TxBuilder, AssetClass]>;
 declare function feedInterestOracle(params: InterestOracleParams, newInterestRate: bigint, lucid: LucidEvolution, assetClass?: AssetClass, utxo?: UTxO, scriptRef?: UTxO): Promise<TxBuilder>;
@@ -1525,15 +1608,6 @@ declare const mkVersionRegistryValidator: () => SpendingValidator;
 
 declare function treasuryFeeTx(fee: bigint, lucid: LucidEvolution, sysParams: SystemParams, tx: TxBuilder, treasuryOref: OutRef): Promise<void>;
 
-/**
- * Accept only a single item in the array and return it.
- * When not exclusively a single item, throw an error.
- */
-declare function matchSingle<T>(xs: T[], mkErr: (xs: T[]) => Error): T;
-declare function loadSystemParamsFromFile(file: string): SystemParams;
-declare function loadSystemParamsFromUrl(url: string): Promise<SystemParams>;
-declare const getRandomElement: <T>(arr: T[]) => T | undefined;
-
 /**
  * Returns the inline datum.
  * Throws when the UTXO doesn't have an inline datum
@@ -1908,16 +1982,53 @@ declare const LRPRedeemerSchema: _lucid_evolution_lucid.TUnion<(_lucid_evolution
     }>;
 }> | _lucid_evolution_lucid.TLiteral<"Cancel">)[]>;
 type LRPRedeemer = Data.Static<typeof LRPRedeemerSchema>;
-declare function parseLrpDatum(datum: Datum): LRPDatum;
+declare function parseLrpDatum(datum: Datum): option.Option<LRPDatum>;
+declare function parseLrpDatumOrThrow(datum: Datum): LRPDatum;
 declare function serialiseLrpDatum(datum: LRPDatum): Datum;
 declare function serialiseLrpRedeemer(redeemer: LRPRedeemer): Redeemer;
 declare function castLrpParams(params: LRPParams): Data;
+type LrpOutput = {
+    datum: LRPDatum;
+    utxo: UTxO;
+};
 
-declare function openLrp(assetTokenName: string, lovelacesAmt: bigint, maxPrice: OnChainDecimal, lucid: LucidEvolution, lrpScriptHash: ScriptHash, network: Network, lrpStakeCredential?: Credential): Promise<TxBuilder>;
-declare function cancelLrp(lrpOutRef: OutRef, lrpRefScriptOutRef: OutRef, lucid: LucidEvolution): Promise<TxBuilder>;
+declare const MIN_LRP_COLLATERAL_AMT = 2000000n;
+/**
+ * Calculate the actually redeemable lovelaces taking into account:
+ *  - LRP datum
+ *  - UTXO's value
+ *  - min redemption
+ *
+ * This helps to handle incorrectly initialised LRPs, too.
+ */
+declare function lrpRedeemableLovelacesInclReimb(lrp: [UTxO, LRPDatum], lrpParams: LrpParamsSP): bigint;
+declare function buildRedemptionsTx(
+/** The tuple represents the LRP UTXO and the amount of iAssets to redeem against it. */
+redemptions: [UTxO, bigint][], price: OnChainDecimal, redemptionReimbursementPercentage: OnChainDecimal, sysParams: SystemParams, tx: TxBuilder, 
+/**
+ * The number of Tx outputs before these.
+ */
+txOutputsBeforeCount: bigint): TxBuilder;
+/**
+ * Given all available LRP UTXOs, calculate total available ADA that can be redeemed (including reimbursement fee).
+ * Taking into account ncorrectly initialised LRPs (without base collateral).
+ */
+declare function calculateTotalAdaForRedemption(iasset: string, iassetPrice: OnChainDecimal, lrpParams: LrpParamsSP, allLrps: [UTxO, LRPDatum][], 
+/**
+ * How many LRPs can be redeemed in a single Tx.
+ */
+maxLrpsInTx: number): bigint;
+declare function randomLrpsSubsetSatisfyingTargetLovelaces(iasset: string, targetLovelacesToSpend: bigint, iassetPrice: OnChainDecimal, allLrps: [UTxO, LRPDatum][], lrpParams: LrpParamsSP, 
+/**
+ * How many LRPs can be redeemed in a single Tx.
+ */
+maxLrpsInTx: number, randomiseFn?: (arr: [UTxO, LRPDatum][]) => [UTxO, LRPDatum][]): [UTxO, LRPDatum][];
+
+declare function openLrp(assetTokenName: string, lovelacesAmt: bigint, maxPrice: OnChainDecimal, lucid: LucidEvolution, sysParams: SystemParams, lrpStakeCredential?: Credential): Promise<TxBuilder>;
+declare function cancelLrp(lrpOutRef: OutRef, sysParams: SystemParams, lucid: LucidEvolution): Promise<TxBuilder>;
 declare function redeemLrp(
 /** The tuple represents the LRP outref and the amount of iAssets to redeem against it. */
-redemptionLrpsData: [OutRef, bigint][], lrpRefScriptOutRef: OutRef, priceOracleOutRef: OutRef, iassetOutRef: OutRef, lucid: LucidEvolution, lrpParams: LRPParams, network: Network): Promise<TxBuilder>;
+redemptionLrpsData: [OutRef, bigint][], priceOracleOutRef: OutRef, iassetOutRef: OutRef, lucid: LucidEvolution, sysParams: SystemParams): Promise<TxBuilder>;
 /**
  * Create Tx adjusting the LRP and claiming the received iAssets
  */
@@ -1926,11 +2037,11 @@ declare function adjustLrp(lucid: LucidEvolution, lrpOutRef: OutRef,
  * A positive amount increases the lovelaces in the LRP,
  * and a negative amount takes lovelaces from the LRP.
  */
-lovelacesAdjustAmt: bigint, lrpRefScriptOutRef: OutRef, lrpParams: LRPParams): Promise<TxBuilder>;
+lovelacesAdjustAmt: bigint, sysParams: SystemParams): Promise<TxBuilder>;
 /**
  * Create Tx claiming the received iAssets.
  */
-declare function claimLrp(lucid: LucidEvolution, lrpOutRef: OutRef, lrpRefScriptOutRef: OutRef, lrpParams: LRPParams): Promise<TxBuilder>;
+declare function claimLrp(lucid: LucidEvolution, lrpOutRef: OutRef, sysParams: SystemParams): Promise<TxBuilder>;
 
 declare const mkLrpValidator: (params: LRPParams) => SpendingValidator;
 declare const mkLrpValidatorFromSP: (params: LrpParamsSP) => SpendingValidator;
@@ -1956,6 +2067,21 @@ type OneShotParams = Data.Static<typeof OneShotParamsSchema>;
 declare function oneShotMintTx(lucid: LucidEvolution, params: OneShotParams): Promise<[TxBuilder, PolicyId]>;
 declare function runOneShotMintTx(lucid: LucidEvolution, params: OneShotParams): Promise<PolicyId>;
 
+/**
+ * Accept only a single item in the array and return it.
+ * When not exclusively a single item, throw an error.
+ */
+declare function matchSingle<T>(xs: T[], mkErr: (xs: T[]) => Error): T;
+declare function loadSystemParamsFromFile(file: string): SystemParams;
+declare function loadSystemParamsFromUrl(url: string): Promise<SystemParams>;
+declare const getRandomElement: <T>(arr: T[]) => T | undefined;
+
+declare function shuffle<T>(arr: T[]): T[];
+/**
+ * The parameter `arr` should be sorted for correct results.
+ */
+declare function insertSorted<T>(arr: T[], item: T, ord: ord.Ord<T>): T[];
+
 declare function mkLovelacesOf(amount: bigint): Assets;
 declare function lovelacesAmt(assets: Assets): bigint;
 declare function assetClassToUnit(ac: AssetClass): Unit;
@@ -1964,4 +2090,106 @@ declare function assetClassValueOf(assets: Assets, assetClass: AssetClass): bigi
 declare function negateAssets(assets: Assets): Assets;
 declare function isAssetsZero(assets: Assets): boolean;
 
-export { type AccountAction, type AccountContent, AccountContentSchema, ActionReturnDatum, ActionReturnDatumSchema, type AddressCredential, type AddressCredentialOrDatum, AddressD, type AddressSP, AddressSchema, type Amount, type AssetClass, type AssetClassSP, AssetClassSchema, type AuthTokenPolicies, type CDPContent, CDPContentSchema, CDPCreatorParams, type CDPCreatorParamsSP, CDPCreatorRedeemer, type CDPDatum, CDPDatumSchema, type CDPFees, CDPFeesSchema, type CDPRedeemer, type CdpParams, type CdpParamsSP, type CollectorParamsSP, CredentialD, CredentialSchema, type CurrencySymbol, type DistributionParams, type EpochToScaleToSum, EpochToScaleToSumSchema, ExecuteDatum, ExecuteParams, type ExecuteParamsSP, type FeedInterestOracleRedeemer, FeedInterestOracleRedeemerSchema, type GovDatum, GovParams, type GovParamsSP, GovRedeemer, type IAssetContent, IAssetContentSchema, type IAssetOutput, IAssetPriceInfoSchema, type Input, type InterestOracleDatum, InterestOracleDatumSchema, type InterestOracleParams, InterestOracleParamsSchema, type LRPDatum, LRPDatumSchema, type LRPParams, LRPParamsSchema, type LRPRedeemer, LRPRedeemerSchema, type LrpParamsSP, ONE_DAY, ONE_HOUR, ONE_SECOND, ONE_YEAR, type OracleAssetNft, OracleAssetNftSchema, type Output, type OutputReference, OutputReferenceSchema, PollManagerParams, type PollManagerParamsSP, PollManagerRedeemer, PollShardParams, type PollShardParamsSP, PollShardRedeemer, type PriceOracleDatum, PriceOracleDatumSchema, type PriceOracleParams, PriceOracleParamsSchema, type PriceOracleRedeemer, type PubKeyHash, type SPInteger, SPIntegerSchema, type ScriptCredential, type ScriptOutput, type ScriptRef, type ScriptReference, type ScriptReferences, type SnapshotEpochToScaleToSumContent, SnapshotEpochToScaleToSumContentSchema, type StabilityPoolContent, StabilityPoolContentSchema, StabilityPoolDatumSchema, StabilityPoolParams, type StabilityPoolParamsSP, type StabilityPoolRedeemer, StabilityPoolRedeemerSchema, type StabilityPoolSnapshot, StakeCredentialSchema, type StakingParamsSP, type StartTime, type SystemParams, type TokenName, type TreasuryParamsSP, type TreasuryWithdrawal, type TreasuryWithdrawalItem, TreasuryWithdrawalSchema, type ValidatorHashes, VerificationKeyHashSchema, type VersionRecordParams, VersionRecordTokenParams, type VoteOption, addrDetails, addressFromBech32, addressToBech32, adjust, adjustLrp, adjustSpAccount, adjustStakingPosition, adjustmentHelper, assetClassToUnit, assetClassValueOf, balance, burnCdp, calculateIAssetRedemptionAmt, calculateMinCollateralCappedIAssetRedemptionAmt, cancelLrp, castCDPCreatorParams, castCdpParams, castExecuteParams, castGovParams, castInterestOracleParams, castLrpParams, castPollManagerParams, castPollShardParams, castPriceOracleParams, castStabilityPoolParams, castVersionRecordTokenParams, cdpCollateralRatioPercentage, claimLrp, closeCdp, closeSpAccount, closeStakingPosition, collectorFeeTx, createProposal, createScriptAddress, createShardsChunks, createSpAccount, depositCdp, endProposal, executeProposal, feedInterestOracle, freezeCdp, fromSPInteger, fromSysParamsScriptCredential, fromSystemParamsAsset, fromSystemParamsScriptRef, getAccountFund, getAccountReward, getInlineDatumOrThrow, getRandomElement, getSumFromEpochToScaleToSum, initEpochToScaleToSumMap, initSpSnapshot, isAssetsZero, liquidateCdp, liquidationHelper, loadSystemParamsFromFile, loadSystemParamsFromUrl, lovelacesAmt, matchSingle, mergeCdps, mergeShards, mintCdp, mkAssetsOf, mkCDPCreatorValidator, mkCDPCreatorValidatorFromSP, mkCdpValidatorFromSP, mkCollectorValidatorFromSP, mkExecuteValidator, mkExecuteValidatorFromSP, mkInterestOracleValidator, mkLovelacesOf, mkLrpValidator, mkLrpValidatorFromSP, mkPollManagerValidator, mkPollManagerValidatorFromSP, mkPollShardValidator, mkPollShardValidatorFromSP, mkSPInteger, mkTreasuryValidatorFromSP, mkVersionRecordTokenPolicy, mkVersionRegistryValidator, negateAssets, oneShotMintTx, openCdp, openLrp, openStakingPosition, parseAccountDatum, parseCdpDatum, parseCdpDatumOrThrow, parseExecuteDatum, parseExecuteDatumOrThrow, parseGovDatum, parseGovDatumOrThrow, parseIAssetDatum, parseIAssetDatumOrThrow, parseInterestOracleDatum, parseLrpDatum, parsePriceOracleDatum, parseSnapshotEpochToScaleToSumDatum, parseStabilityPoolDatum, processSpRequest, redeemCdp, redeemLrp, runCreateScriptRefTx, runOneShotMintTx, scriptRef, serialiseCDPCreatorDatum, serialiseCDPCreatorRedeemer, serialiseCdpDatum, serialiseCdpRedeemer, serialiseExecuteDatum, serialiseFeedInterestOracleRedeemer, serialiseGovDatum, serialiseGovRedeemer, serialiseIAssetDatum, serialiseInterestOracleDatum, serialiseLrpDatum, serialiseLrpRedeemer, serialisePollManagerRedeemer, serialisePollShardRedeemer, serialisePriceOracleDatum, serialisePriceOracleRedeemer, serialiseStabilityPoolDatum, serialiseStabilityPoolRedeemer, setSumInEpochToScaleToSum, spAdd, spDiv, spMul, spSub, startInterestOracle, toSystemParamsAsset, treasuryFeeTx, updatePoolSnapshotWithdrawalFee, vote, withdrawCdp };
+declare function leverageCdpWithLrp(leverage: number, baseCollateral: bigint, priceOracleOutRef: OutRef, iassetOutRef: OutRef, cdpCreatorOref: OutRef, interestOracleOref: OutRef, collectorOref: OutRef, sysParams: SystemParams, lucid: LucidEvolution, allLrps: [UTxO, LRPDatum][], currentSlot: number): Promise<TxBuilder>;
+
+/**
+ * The following is the math related to the leverage calculations.
+ *
+ * Leverage is the multiplier you apply to the base deposit and you get the amount of final collateral
+ * the CDP should have. Additionally, the minted amount is used to pay for fees. The leverage a user picks, is
+ * already taking into account the fees, i.e. the fees are paid from the borrowed assets.
+ *
+ * There's a direct relationship between collateral ratio and leverage multiplier. Each leverage multiplier
+ * results in a single collateral ratio and vice versa. Maximum potential leverage is the leverage that
+ * results in collateral ratio being the maintenance collateral ratio of the corresponding iAsset.
+ *
+ * `d` = base deposit
+ * `b` = total borrowed value (including the fees)
+ * `L` = leverage
+ * `f_m` = debt minting fee
+ * `f_r` = reimbursement fee
+ * `c` = collateral ratio
+ *
+ * The following is a detailed derivation of the math:
+ *
+ *  1.  Since the redemption fee is proportional to the borrowed amount,
+ *      we can express the ADA we get from the order book as `b'=b*(1-f_r)`,
+ *      since some of the borrowed amount goes back to the order book.
+ *
+ *  2.  Since all the minted iAsset are used to get borrowed ADA,
+ *      the value of the minted asset will be `b`.
+ *
+ *  3.  The minting fee is a percentage of the value of the minted iAsset.
+ *      Therefore the available ADA to add as collateral is `b''=b' - b*f_m = b*(1 - f_r - f_m)`.
+ *
+ *  4.  The collateral ratio can now be expressed as `c = (d + b * (1 - f_r - f_m)) / b`.
+ *
+ *  5.  Working out the expression, we can express `b` in terms of everything else: `b = d / (c - 1 + f_r + f_m)`.
+ *
+ *  6.  The minted amount will be `b / asset_price`.
+ *
+ *  7.  Collateral amount of the CDP is `d + b * (1 - f_r - f_m)`
+ *
+ *  8.  Leverage calculation: `L = (d + b * (1 - f_r - f_m)) / d`.
+ *
+ *      Plugging in the `b` formula we get: `L = (d + (d / (c - 1 + f_r + f_m)) * (1 - f_r - f_m)) / d`.
+ *
+ *      Simplified, yields the following:
+ *      `L = 1 + ((1 - f_r - f_m) / (c - 1 + f_r + f_m))`
+ *
+ *  9.  `b'' = b * (1 - f_r - f_m)`
+ *      Solved for `b` yields the following:
+ *      `b = b'' / (1 - f_r - f_m)`
+ *
+ *  10. Having leverage and base deposit, we can find `b''`:
+ *      `b’’ = d(L - 1)`
+ */
+
+/**
+ * How many LRP redemptions can we fit into a TX with CDP open.
+ */
+declare const MAX_REDEMPTIONS_WITH_CDP_OPEN = 4;
+type LRPRedemptionDetails = {
+    utxo: UTxO;
+    /**
+     * This is including the reimbursement fee.
+     **/
+    redemptionLovelacesAmtInclReimbursement: bigint;
+    iassetsForRedemptionAmt: bigint;
+    reimbursementLovelacesAmt: bigint;
+};
+type ApproximateLeverageRedemptionsResult = {
+    leverage: number;
+    collateralRatio: OnChainDecimal;
+    lovelacesForRedemptionWithReimbursement: bigint;
+};
+/**
+ * We assume exact precision. However, actual redemptions include rounding and
+ * the rounding behaviour changes based on the number of redemptions.
+ * This may slightly tweak the numbers and the result can be different.
+ *
+ * The math is described at the top of this code file.
+ */
+declare function approximateLeverageRedemptions(baseCollateral: bigint, targetLeverage: number, redemptionReimbursementPercentage: OnChainDecimal, debtMintingFeePercentage: OnChainDecimal): ApproximateLeverageRedemptionsResult;
+declare function summarizeActualLeverageRedemptions(lovelacesForRedemptionWithReimbursement: bigint, redemptionReimbursementPercentage: OnChainDecimal, iassetPrice: OnChainDecimal, lrpParams: LrpParamsSP, redemptionLrps: [UTxO, LRPDatum][]): {
+    redemptions: LRPRedemptionDetails[];
+    /**
+     * The actual amount received from redemptions (i.e. without the reimbursement fee).
+     */
+    totalRedeemedLovelaces: bigint;
+    /**
+     * Total lovelaces amt that has been reimbursted
+     */
+    totalReimbursementLovelaces: bigint;
+    totalRedemptionIAssets: bigint;
+};
+/**
+ * The math is described at the top of this code file.
+ */
+declare function calculateCollateralRatioFromLeverage(iasset: string, leverage: number, baseCollateral: bigint, iassetPrice: OnChainDecimal, debtMintingFeePercentage: OnChainDecimal, redemptionReimbursementPercentage: OnChainDecimal, lrpParams: LrpParamsSP, allLrps: [UTxO, LRPDatum][]): OnChainDecimal | undefined;
+/**
+ * The math is described at the top of this code file.
+ */
+declare function calculateLeverageFromCollateralRatio(iasset: string, collateralRatioPercentage: OnChainDecimal, baseCollateral: bigint, iassetPrice: OnChainDecimal, debtMintingFeePercentage: OnChainDecimal, redemptionReimbursementPercentage: OnChainDecimal, lrpParams: LrpParamsSP, allLrps: [UTxO, LRPDatum][]): number | undefined;
+
+export { type AccountAction, type AccountContent, AccountContentSchema, ActionReturnDatum, ActionReturnDatumSchema, type AddressCredential, type AddressCredentialOrDatum, AddressD, type AddressSP, AddressSchema, type Amount, type AssetClass, type AssetClassSP, AssetClassSchema, type AuthTokenPolicies, type CDPContent, CDPContentSchema, CDPCreatorParams, type CDPCreatorParamsSP, CDPCreatorRedeemer, type CDPDatum, CDPDatumSchema, type CDPFees, CDPFeesSchema, type CDPRedeemer, type CdpParams, type CdpParamsSP, type CollectorParamsSP, CredentialD, CredentialSchema, type CurrencySymbol, type DistributionParams, type EpochToScaleToSum, EpochToScaleToSumSchema, ExecuteDatum, ExecuteParams, type ExecuteParamsSP, type FeedInterestOracleRedeemer, FeedInterestOracleRedeemerSchema, type GovDatum, GovParams, type GovParamsSP, GovRedeemer, type IAssetContent, IAssetContentSchema, type IAssetOutput, IAssetPriceInfoSchema, type Input, type InterestOracleDatum, InterestOracleDatumSchema, type InterestOracleParams, InterestOracleParamsSchema, type LRPDatum, LRPDatumSchema, type LRPParams, LRPParamsSchema, type LRPRedeemer, LRPRedeemerSchema, type LrpOutput, type LrpParamsSP, MAX_REDEMPTIONS_WITH_CDP_OPEN, MIN_LRP_COLLATERAL_AMT, ONE_DAY, ONE_HOUR, ONE_SECOND, ONE_YEAR, type OracleAssetNft, OracleAssetNftSchema, type Output, type OutputReference, OutputReferenceSchema, PollManagerParams, type PollManagerParamsSP, PollManagerRedeemer, PollShardParams, type PollShardParamsSP, PollShardRedeemer, type PriceOracleDatum, PriceOracleDatumSchema, type PriceOracleParams, PriceOracleParamsSchema, type PriceOracleRedeemer, type PubKeyHash, type SPInteger, SPIntegerSchema, type ScriptCredential, type ScriptOutput, type ScriptRef, type ScriptReference, type ScriptReferences, type SnapshotEpochToScaleToSumContent, SnapshotEpochToScaleToSumContentSchema, type StabilityPoolContent, StabilityPoolContentSchema, StabilityPoolDatumSchema, StabilityPoolParams, type StabilityPoolParamsSP, type StabilityPoolRedeemer, StabilityPoolRedeemerSchema, type StabilityPoolSnapshot, StakeCredentialSchema, type StakingManager, type StakingParamsSP, type StakingPosLockedAmt, type StakingPosition, type StakingRedeemer, type StartTime, type SystemParams, type TokenName, type TreasuryParamsSP, type TreasuryWithdrawal, type TreasuryWithdrawalItem, TreasuryWithdrawalSchema, type ValidatorHashes, VerificationKeyHashSchema, type VersionRecordParams, VersionRecordTokenParams, type VoteOption, addrDetails, addressFromBech32, addressToBech32, adjust, adjustLrp, adjustSpAccount, adjustStakingPosition, adjustmentHelper, approximateLeverageRedemptions, assetClassToUnit, assetClassValueOf, balance, buildRedemptionsTx, burnCdp, calculateCollateralRatioFromLeverage, calculateIAssetRedemptionAmt, calculateLeverageFromCollateralRatio, calculateMinCollateralCappedIAssetRedemptionAmt, calculateTotalAdaForRedemption, cancelLrp, castCDPCreatorParams, castCdpParams, castExecuteParams, castGovParams, castInterestOracleParams, castLrpParams, castPollManagerParams, castPollShardParams, castPriceOracleParams, castStabilityPoolParams, castStakingParams, castVersionRecordTokenParams, cdpCollateralRatioPercentage, claimLrp, closeCdp, closeSpAccount, closeStakingPosition, collectorFeeTx, createProposal, createScriptAddress, createShardsChunks, createSpAccount, depositCdp, distributeAda, endProposal, executeProposal, feedInterestOracle, freezeCdp, fromSPInteger, fromSysParamsScriptCredential, fromSystemParamsAsset, fromSystemParamsScriptRef, getAccountFund, getAccountReward, getInlineDatumOrThrow, getRandomElement, getSumFromEpochToScaleToSum, initEpochToScaleToSumMap, initSpSnapshot, insertSorted, isAssetsZero, leverageCdpWithLrp, liquidateCdp, liquidationHelper, loadSystemParamsFromFile, loadSystemParamsFromUrl, lovelacesAmt, lrpRedeemableLovelacesInclReimb, matchSingle, mergeCdps, mergeShards, mintCdp, mkAssetsOf, mkCDPCreatorValidator, mkCDPCreatorValidatorFromSP, mkCdpValidatorFromSP, mkCollectorValidatorFromSP, mkExecuteValidator, mkExecuteValidatorFromSP, mkInterestOracleValidator, mkLovelacesOf, mkLrpValidator, mkLrpValidatorFromSP, mkPollManagerValidator, mkPollManagerValidatorFromSP, mkPollShardValidator, mkPollShardValidatorFromSP, mkSPInteger, mkTreasuryValidatorFromSP, mkVersionRecordTokenPolicy, mkVersionRegistryValidator, negateAssets, oneShotMintTx, openCdp, openLrp, openStakingPosition, parseAccountDatum, parseCdpDatum, parseCdpDatumOrThrow, parseExecuteDatum, parseExecuteDatumOrThrow, parseGovDatum, parseGovDatumOrThrow, parseIAssetDatum, parseIAssetDatumOrThrow, parseInterestOracleDatum, parseLrpDatum, parseLrpDatumOrThrow, parsePriceOracleDatum, parseSnapshotEpochToScaleToSumDatum, parseStabilityPoolDatum, parseStakingManagerDatum, parseStakingPosition, parseStakingPositionOrThrow, processSpRequest, randomLrpsSubsetSatisfyingTargetLovelaces, redeemCdp, redeemLrp, runCreateScriptRefTx, runOneShotMintTx, scriptRef, serialiseCDPCreatorDatum, serialiseCDPCreatorRedeemer, serialiseCdpDatum, serialiseCdpRedeemer, serialiseExecuteDatum, serialiseFeedInterestOracleRedeemer, serialiseGovDatum, serialiseGovRedeemer, serialiseIAssetDatum, serialiseInterestOracleDatum, serialiseLrpDatum, serialiseLrpRedeemer, serialisePollManagerRedeemer, serialisePollShardRedeemer, serialisePriceOracleDatum, serialisePriceOracleRedeemer, serialiseStabilityPoolDatum, serialiseStabilityPoolRedeemer, serialiseStakingDatum, serialiseStakingRedeemer, setSumInEpochToScaleToSum, shuffle, spAdd, spDiv, spMul, spSub, startInterestOracle, summarizeActualLeverageRedemptions, toSystemParamsAsset, treasuryFeeTx, updatePoolSnapshotWithdrawalFee, vote, withdrawCdp };