@indigo-labs/indigo-sdk 0.1.18 → 0.1.20

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

@@ -0,0 +1,115 @@
+import { Core as EvoCore } from '@evolution-sdk/evolution';
+import { Data } from '@lucid-evolution/lucid';
+import { OracleAssetNftSchema } from '../price-oracle/types';
+import { AssetClassSchema } from '../../types/generic';
+import { OnChainDecimalSchema } from '../../types/on-chain-decimal';
+import { IAssetPriceInfoSchema } from '../cdp/types';
+import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
+
+export const ProtocolParamsSchema = Data.Object({
+  proposalDeposit: Data.Integer(),
+  votingPeriod: Data.Integer(),
+  effectiveDelay: Data.Integer(),
+  expirationPeriod: Data.Integer(),
+  collateralFeePercentage: OnChainDecimalSchema,
+  proposingPeriod: Data.Integer(),
+  /// Total numer of shards used for voting.
+  totalShards: Data.Integer(),
+  /// The minimum number of votes (yes + no votes) for a proposal to be possible to pass.
+  minimumQuorum: Data.Integer(),
+  /// Maximum amount of lovelaces that can be spent at once from the treasury.
+  maxTreasuryLovelaceSpend: Data.Integer(),
+  /// Maximum amount of INDY that can be spent at once from the treasury.
+  maxTreasuryIndySpend: Data.Integer(),
+});
+
+export type ProtocolParams = Data.Static<typeof ProtocolParamsSchema>;
+export const ProtocolParams = ProtocolParamsSchema as unknown as ProtocolParams;
+
+const ProposeAssetContentSchema = Data.Object({
+  asset: Data.Bytes(),
+  priceOracleNft: OracleAssetNftSchema,
+  interestOracleNft: AssetClassSchema,
+  redemptionRatioPercentage: OnChainDecimalSchema,
+  maintenanceRatioPercentage: OnChainDecimalSchema,
+  liquidationRatioPercentage: OnChainDecimalSchema,
+  debtMintingFeePercentage: OnChainDecimalSchema,
+  liquidationProcessingFeePercentage: OnChainDecimalSchema,
+  stabilityPoolWithdrawalFeePercentage: OnChainDecimalSchema,
+  redemptionReimbursementPercentage: OnChainDecimalSchema,
+  redemptionProcessingFeePercentage: OnChainDecimalSchema,
+  interestCollectorPortionPercentage: OnChainDecimalSchema,
+});
+export type ProposeAssetContent = Data.Static<typeof ProposeAssetContentSchema>;
+
+export const ProposalContentSchema = Data.Enum([
+  Data.Object({
+    ProposeAsset: ProposeAssetContentSchema,
+  }),
+  Data.Object({
+    ModifyAsset: Data.Object({
+      asset: Data.Bytes(),
+      newAssetPriceInfo: IAssetPriceInfoSchema,
+      newInterestOracleNft: AssetClassSchema,
+      newRedemptionRatioPercentage: OnChainDecimalSchema,
+      newMaintenanceRatioPercentage: OnChainDecimalSchema,
+      newLiquidationRatioPercentage: OnChainDecimalSchema,
+      newDebtMintingFeePercentage: OnChainDecimalSchema,
+      newLiquidationProcessingFeePercentage: OnChainDecimalSchema,
+      newStabilityPoolWithdrawalFeePercentage: OnChainDecimalSchema,
+      newRedemptionReimbursementPercentage: OnChainDecimalSchema,
+      newRedemptionProcessingFeePercentage: OnChainDecimalSchema,
+      newInterestCollectorPortionPercentage: OnChainDecimalSchema,
+    }),
+  }),
+  Data.Object({
+    ModifyProtocolParams: Data.Object({
+      newParams: ProtocolParamsSchema,
+    }),
+  }),
+  Data.Object({
+    UpgradeProtocol: Data.Object({
+      content:
+        // NOTICE: This is replaced by evolution-sdk encoding of `UpgradePathsSchema` defined in this file.
+        Data.Any(),
+    }),
+  }),
+  Data.Object({
+    TextProposal: Data.Object({
+      bytes: Data.Bytes(),
+    }),
+  }),
+]);
+export type ProposalContent = Data.Static<typeof ProposalContentSchema>;
+export const ProposalContent =
+  ProposalContentSchema as unknown as ProposalContent;
+
+const UpgradePathSchema = EvoCore.TSchema.Struct({
+  upgradeSymbol: EvoCore.TSchema.ByteArray,
+});
+
+const UpgradePathsSchema = EvoCore.TSchema.Struct({
+  upgradeId: EvoCore.TSchema.Integer,
+  /// Underlying representation of the following mapping: ValidatorHash -> UpgradePath
+  upgradePaths: EvoCore.TSchema.Map(
+    EvoCore.TSchema.ByteArray,
+    UpgradePathSchema,
+  ),
+});
+export type UpgradePaths = typeof UpgradePathsSchema.Type;
+
+export function serialiseUpgradePaths(d: UpgradePaths): Data {
+  return Data.from(
+    EvoCore.Data.withSchema(
+      UpgradePathsSchema,
+      DEFAULT_SCHEMA_OPTIONS,
+    ).toCBORHex(d),
+  );
+}
+
+export function parseUpgradePaths(d: Data): UpgradePaths {
+  return EvoCore.Data.withSchema(
+    UpgradePathsSchema,
+    DEFAULT_SCHEMA_OPTIONS,
+  ).fromCBORHex(Data.to(d));
+}

package/src/contracts/gov/types.ts

@@ -0,0 +1,89 @@
+import { Data, Datum, Redeemer } from '@lucid-evolution/lucid';
+import { AddressSchema, AssetClassSchema } from '../../types/generic';
+import { option as O, function as F } from 'fp-ts';
+import { ProposalContentSchema, ProtocolParamsSchema } from './types-new';
+
+const GovDatumSchema = Data.Object({
+  currentProposal: Data.Integer(),
+  protocolParams: ProtocolParamsSchema,
+  currentVersion: Data.Integer(),
+  iassetsCount: Data.Integer(),
+  activeProposals: Data.Integer(),
+  treasuryIndyWithdrawnAmt: Data.Integer(),
+});
+export type GovDatum = Data.Static<typeof GovDatumSchema>;
+const GovDatum = GovDatumSchema as unknown as GovDatum;
+
+const GovParamsSchema = Data.Object({
+  govNFT: AssetClassSchema,
+  pollToken: AssetClassSchema,
+  upgradeToken: AssetClassSchema,
+  indyAsset: AssetClassSchema,
+  versionRecordToken: AssetClassSchema,
+  pollManagerValHash: Data.Bytes(),
+  gBiasTime: Data.Integer(),
+  daoIdentityToken: AssetClassSchema,
+  iAssetAuthToken: AssetClassSchema,
+});
+export type GovParams = Data.Static<typeof GovParamsSchema>;
+export const GovParams = GovParamsSchema as unknown as GovParams;
+
+const ValueWithdrawalItemSchema = Data.Tuple(
+  [Data.Bytes(), Data.Bytes(), Data.Integer()],
+  { hasConstr: true },
+);
+export type TreasuryWithdrawalItem = Data.Static<
+  typeof ValueWithdrawalItemSchema
+>;
+
+export const TreasuryWithdrawalSchema = Data.Object({
+  destination: AddressSchema,
+  value: Data.Array(ValueWithdrawalItemSchema),
+});
+export type TreasuryWithdrawal = Data.Static<typeof TreasuryWithdrawalSchema>;
+
+const GovRedeemerSchema = Data.Enum([
+  Data.Object({
+    CreatePoll: Data.Object({
+      currentTime: Data.Integer(),
+      proposalOwner: Data.Bytes(),
+      content: ProposalContentSchema,
+      treasuryWithdrawal: Data.Nullable(TreasuryWithdrawalSchema),
+    }),
+  }),
+  Data.Object({ WitnessEndPoll: Data.Object({ currentTime: Data.Integer() }) }),
+  Data.Literal('UpgradeGov'),
+  Data.Literal('UpgradeVersion'),
+]);
+
+export type GovRedeemer = Data.Static<typeof GovRedeemerSchema>;
+export const GovRedeemer = GovRedeemerSchema as unknown as GovRedeemer;
+
+export function parseGovDatum(datum: Datum): O.Option<GovDatum> {
+  try {
+    return O.some(Data.from<GovDatum>(datum, GovDatum));
+  } catch (_) {
+    return O.none;
+  }
+}
+
+export function parseGovDatumOrThrow(datum: Datum): GovDatum {
+  return F.pipe(
+    parseGovDatum(datum),
+    O.match(() => {
+      throw new Error('Expected a Gov datum.');
+    }, F.identity),
+  );
+}
+
+export function serialiseGovDatum(d: GovDatum): Datum {
+  return Data.to<GovDatum>(d, GovDatum);
+}
+
+export function serialiseGovRedeemer(redeemer: GovRedeemer): Redeemer {
+  return Data.to<GovRedeemer>(redeemer, GovRedeemer);
+}
+
+export function castGovParams(params: GovParams): Data {
+  return Data.castTo(params, GovParams);
+}

package/src/{helpers/interest-oracle.ts → contracts/interest-oracle/helpers.ts}

@@ -1,8 +1,14 @@
-import { InterestOracleDatum } from '../types/indigo/interest-oracle';
-import { oneYear } from '../helpers/time-helpers';
+import { InterestOracleDatum } from './types';
+import { ONE_YEAR } from '../../utils/time-helpers';
+import {
+  OCD_DECIMAL_UNIT,
+  ocdAdd,
+  ocdCeil,
+  ocdMul,
+  OnChainDecimal,
+} from '../../types/on-chain-decimal';
 
 const unitaryInterestPrecision = 1_000_000_000_000_000_000n;
-const decimalUnit = 1_000_000n;
 
 export function calculateUnitaryInterest(
   timePeriod: bigint,
@@ -10,8 +16,8 @@ export function calculateUnitaryInterest(
 ): bigint {
   return (
     (timePeriod * interestRate * unitaryInterestPrecision) /
-    oneYear /
-    decimalUnit
+    ONE_YEAR /
+    OCD_DECIMAL_UNIT
   );
 }
 
@@ -41,8 +47,8 @@ export function calculateAccruedInterest(
       ((now - interestOracleDatum.lastUpdated) *
         interestOracleDatum.interestRate.getOnChainInt *
         mintedAmount) /
-      oneYear /
-      decimalUnit;
+      ONE_YEAR /
+      OCD_DECIMAL_UNIT;
 
     return interestFromPreviousRates + lastRateInterest;
   } else {
@@ -50,8 +56,30 @@ export function calculateAccruedInterest(
       ((now - interestLastSettled) *
         interestOracleDatum.interestRate.getOnChainInt *
         mintedAmount) /
-      oneYear /
-      decimalUnit
+      ONE_YEAR /
+      OCD_DECIMAL_UNIT
     );
   }
 }
+
+/**
+ * Calculate the amount of interest needed to achieve 100% collateral ratio.
+ */
+export function computeInterestLovelacesFor100PercentCR(
+  collateral: bigint,
+  mintedAmt: bigint,
+  price: OnChainDecimal,
+): bigint {
+  const amt = ocdCeil(
+    ocdAdd(
+      { getOnChainInt: collateral * OCD_DECIMAL_UNIT },
+      ocdMul({ getOnChainInt: -mintedAmt * OCD_DECIMAL_UNIT }, price),
+    ),
+  );
+
+  if (amt <= 0) {
+    return 0n;
+  } else {
+    return amt;
+  }
+}

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

@@ -0,0 +1,18 @@
+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: 'PlutusV2',
+    script: applyParamsToScript(_interestOracleValidator.cborHex, [
+      castInterestOracleParams(params),
+    ]),
+  };
+}

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

@@ -0,0 +1,149 @@
+import {
+  fromText,
+  LucidEvolution,
+  OutRef,
+  toUnit,
+  TxBuilder,
+  UTxO,
+  validatorToAddress,
+} from '@lucid-evolution/lucid';
+import { AssetClass } from '../../types/generic';
+import {
+  InterestOracleParams,
+  parseInterestOracleDatum,
+  serialiseFeedInterestOracleRedeemer,
+  serialiseInterestOracleDatum,
+} 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';
+
+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: policyId,
+      tokenName: 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(Date.now());
+  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/{types/indigo/interest-oracle.ts → contracts/interest-oracle/types.ts}

@@ -1,5 +1,5 @@
 import { Data, Datum } from '@lucid-evolution/lucid';
-import { OnChainDecimalSchema } from '../on-chain-decimal';
+import { OnChainDecimalSchema } from '../../types/on-chain-decimal';
 
 export const InterestOracleDatumSchema = Data.Object({
   unitaryInterest: Data.Integer(),

package/src/contracts/lrp/scripts.ts

@@ -0,0 +1,27 @@
+import { applyParamsToScript, SpendingValidator } from '@lucid-evolution/lucid';
+import { castLrpParams, LRPParams } from './types';
+import { fromSystemParamsAsset, LrpParamsSP } from '../../types/system-params';
+import { _lrpValidator } from '../../validators/lrp-validator';
+
+export const mkLrpValidator = (params: LRPParams): SpendingValidator => {
+  return {
+    type: 'PlutusV2',
+    script: applyParamsToScript(_lrpValidator.cborHex, [castLrpParams(params)]),
+  };
+};
+
+export const mkLrpValidatorFromSP = (
+  params: LrpParamsSP,
+): SpendingValidator => {
+  return {
+    type: 'PlutusV2',
+    script: applyParamsToScript(_lrpValidator.cborHex, [
+      castLrpParams({
+        versionRecordToken: fromSystemParamsAsset(params.versionRecordToken),
+        iassetNft: fromSystemParamsAsset(params.iassetNft),
+        minRedemptionLovelacesAmt: BigInt(params.minRedemptionLovelacesAmt),
+        iassetPolicyId: params.iassetPolicyId.unCurrencySymbol,
+      }),
+    ]),
+  };
+};

package/src/contracts/{lrp.ts → lrp/transactions.ts}

@@ -9,13 +9,12 @@ import {
   addAssets,
   unixTimeToSlot,
   slotToUnixTime,
-  toUnit,
 } from '@lucid-evolution/lucid';
 import {
   addrDetails,
   createScriptAddress,
   getInlineDatumOrThrow,
-} from '../helpers/lucid-utils';
+} from '../../utils/lucid-utils';
 import { match, P } from 'ts-pattern';
 import { unzip, zip } from 'fp-ts/lib/Array';
 import { reduceWithIndex } from 'fp-ts/lib/Array';
@@ -25,18 +24,18 @@ import {
   parseLrpDatum,
   serialiseLrpDatum,
   serialiseLrpRedeemer,
-} from '../types/indigo/lrp';
-import { parsePriceOracleDatum } from '../types/indigo/price-oracle';
-import { ocdMul, OnChainDecimal } from '../types/on-chain-decimal';
-import { parseIAssetDatum } from '../types/indigo/cdp';
+} from './types';
+import { parsePriceOracleDatum } from '../price-oracle/types';
+import { ocdMul, OnChainDecimal } from '../../types/on-chain-decimal';
+import { parseIAssetDatumOrThrow } from '../cdp/types';
 import {
   assetClassValueOf,
   mkAssetsOf,
   mkLovelacesOf,
-} from '../helpers/value-helpers';
-import { calculateFeeFromPercentage } from '../helpers/indigo-helpers';
-import { matchSingle } from '../helpers/helpers';
-import { AssetClass } from '../types/generic';
+} from '../../utils/value-helpers';
+import { calculateFeeFromPercentage } from '../../utils/indigo-helpers';
+import { matchSingle } from '../../utils/utils';
+import { AssetClass } from '../../types/generic';
 
 const MIN_UTXO_COLLATERAL_AMT = 2_000_000n;
 
@@ -117,7 +116,9 @@ export async function redeemLrp(
     (_) => new Error('Expected a single IAsset UTXO'),
   );
 
-  const iassetDatum = parseIAssetDatum(getInlineDatumOrThrow(iassetUtxo));
+  const iassetDatum = parseIAssetDatumOrThrow(
+    getInlineDatumOrThrow(iassetUtxo),
+  );
 
   const [lrpsToRedeemOutRefs, lrpRedemptionIAssetAmt] =
     unzip(redemptionLrpsData);
@@ -153,32 +154,12 @@ export async function redeemLrp(
         },
         priceOracleDatum.price,
       ).getOnChainInt;
-
-      console.log(lovelacesForRedemption, redeemIAssetAmt, priceOracleDatum.price);
       const reimburstmentLovelaces = calculateFeeFromPercentage(
         iassetDatum.redemptionReimbursementPercentage,
         lovelacesForRedemption,
       );
 
-      console.log(reimburstmentLovelaces, iassetDatum.redemptionReimbursementPercentage, lovelacesForRedemption);
-
       const lrpDatum = parseLrpDatum(getInlineDatumOrThrow(lrpUtxo));
-      const outputLovelacesAmt = lrpUtxo.assets.lovelace - lovelacesForRedemption + reimburstmentLovelaces;
-      const assetUnit = toUnit(lrpParams.iassetPolicyId, mainLrpDatum.iasset);
-
-      console.log(lrpUtxo.address,
-        {
-          kind: 'inline',
-          value: serialiseLrpDatum({
-            ...lrpDatum,
-            lovelacesToSpend:
-              lrpDatum.lovelacesToSpend - lovelacesForRedemption,
-          }),
-        },
-        {
-          lovelace: outputLovelacesAmt,
-          [assetUnit]: redeemIAssetAmt + (lrpUtxo.assets[assetUnit] ?? 0n),
-        });
 
       return acc
         .collectFrom(
@@ -211,10 +192,17 @@ export async function redeemLrp(
                 lrpDatum.lovelacesToSpend - lovelacesForRedemption,
             }),
           },
-          {
-            lovelace: outputLovelacesAmt,
-            [assetUnit]: redeemIAssetAmt + (lrpUtxo.assets[assetUnit] ?? 0n),
-          }
+          addAssets(
+            lrpUtxo.assets,
+            mkLovelacesOf(-lovelacesForRedemption + reimburstmentLovelaces),
+            mkAssetsOf(
+              {
+                currencySymbol: lrpParams.iassetPolicyId,
+                tokenName: mainLrpDatum.iasset,
+              },
+              redeemIAssetAmt,
+            ),
+          ),
         );
     },
   )(redemptionLrps);
@@ -250,8 +238,6 @@ export async function adjustLrp(
   lrpRefScriptOutRef: OutRef,
   lrpParams: LRPParams,
 ): Promise<TxBuilder> {
-  const ownAddr = await lucid.wallet().address();
-
   const lrpScriptRefUtxo = matchSingle(
     await lucid.utxosByOutRef([lrpRefScriptOutRef]),
     (_) => new Error('Expected a single LRP Ref Script UTXO'),
@@ -306,7 +292,7 @@ export async function adjustLrp(
         mkLovelacesOf(lovelacesAdjustAmt),
       ),
     )
-    .addSigner(ownAddr);
+    .addSignerKey(lrpDatum.owner);
 }
 
 /**

package/src/{types/indigo/lrp.ts → contracts/lrp/types.ts}

@@ -1,6 +1,6 @@
 import { Data, Datum, Redeemer } from '@lucid-evolution/lucid';
-import { AssetClassSchema, OutputReferenceSchema } from '../generic';
-import { OnChainDecimalSchema } from '../on-chain-decimal';
+import { AssetClassSchema, OutputReferenceSchema } from '../../types/generic';
+import { OnChainDecimalSchema } from '../../types/on-chain-decimal';
 
 export const LRPParamsSchema = Data.Object({
   versionRecordToken: AssetClassSchema,
@@ -51,7 +51,7 @@ export function serialiseLrpDatum(datum: LRPDatum): Datum {
 }
 
 export function serialiseLrpRedeemer(redeemer: LRPRedeemer): Redeemer {
-  return Data.to<LRPRedeemer>(redeemer, LRPRedeemer, {canonical: true});
+  return Data.to<LRPRedeemer>(redeemer, LRPRedeemer);
 }
 
 export function castLrpParams(params: LRPParams): Data {

package/src/{scripts/one-shot-policy.ts → contracts/one-shot/scripts.ts}

@@ -3,7 +3,7 @@ import {
   MintingPolicy,
   ScriptType,
 } from '@lucid-evolution/lucid';
-import { castOneShotParams, OneShotParams } from '../types/one-shot';
+import { castOneShotParams, OneShotParams } from './types';
 
 /**
 Generated from this code in Aiken v1.1.13

package/src/contracts/{one-shot.ts → one-shot/transactions.ts}

@@ -9,9 +9,9 @@ import {
   toUnit,
   TxBuilder,
 } from '@lucid-evolution/lucid';
-import { OneShotParams } from '../types/one-shot';
-import { matchSingle } from '../helpers/helpers';
-import { mkOneShotPolicy } from '../scripts/one-shot-policy';
+import { OneShotParams } from './types';
+import { matchSingle } from '../../utils/utils';
+import { mkOneShotPolicy } from './scripts';
 import { reduce } from 'fp-ts/lib/Array';
 
 export async function oneShotMintTx(