@indigo-labs/indigo-sdk 0.5.4 → 0.5.6

package/tests/treasury/treasury.test.ts

@@ -1,320 +0,0 @@
-import {
-  addAssets,
-  Emulator,
-  EmulatorAccount,
-  fromHex,
-  fromText,
-  generateEmulatorAccount,
-  Lucid,
-} from '@lucid-evolution/lucid';
-import { beforeEach, describe, test } from 'vitest';
-import { LucidContext } from '../test-helpers';
-import { treasuryCollect } from '../../src';
-import {
-  EXAMPLE_TOKEN_1,
-  EXAMPLE_TOKEN_2,
-  EXAMPLE_TOKEN_3,
-  MAINNET_PROTOCOL_PARAMETERS,
-} from '../indigo-test-helpers';
-import { benchmarkAndAwaitTx } from '../utils/benchmark-utils';
-import { findRandomTreasuryUtxoWithOnlyAda } from '../../src/contracts/treasury/queries';
-import {
-  adaAssetClass,
-  AssetClass,
-  mkLovelacesOf,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import { mkAssetsOf } from '@3rd-eye-labs/cardano-offchain-common';
-import { expectScriptFailure } from '../utils/asserts';
-import { treasuryMergeTx, treasurySplitTx } from './actions';
-import { init } from '../endpoints/initialize';
-import { iusdInitialAssetCfg } from '../mock/assets-mock';
-
-type MyContext = LucidContext<{
-  admin: EmulatorAccount;
-  user: EmulatorAccount;
-  withdrawalAccount: EmulatorAccount;
-}>;
-
-const testAssetA: AssetClass = {
-  currencySymbol: fromHex(
-    // random generated
-    'cc072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8daa',
-  ),
-  tokenName: fromHex(fromText('A')),
-};
-const testAssetB: AssetClass = {
-  currencySymbol: fromHex(
-    // random generated
-    'cc072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8dab',
-  ),
-  tokenName: fromHex(fromText('B')),
-};
-
-const testAssetC: AssetClass = {
-  currencySymbol: fromHex(
-    // random generated
-    'aa072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8dac',
-  ),
-  tokenName: fromHex(fromText('C')),
-};
-
-const testAssetD: AssetClass = {
-  currencySymbol: fromHex(
-    // random generated
-    'cc072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8dad',
-  ),
-  tokenName: fromHex(fromText('D')),
-};
-
-const testAssetE: AssetClass = {
-  currencySymbol: fromHex(
-    // random generated
-    'cc072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8dae',
-  ),
-  tokenName: fromHex(fromText('E')),
-};
-
-const testAssetF: AssetClass = {
-  currencySymbol: fromHex(
-    // random generated
-    'cc072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8daf',
-  ),
-  tokenName: fromHex(fromText('F')),
-};
-
-const testAssetG: AssetClass = {
-  currencySymbol: fromHex(
-    // random generated
-    'cc072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8dba',
-  ),
-  tokenName: fromHex(fromText('G')),
-};
-
-const testAssetH: AssetClass = {
-  currencySymbol: fromHex(
-    // random generated
-    'cc072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8dbb',
-  ),
-  tokenName: fromHex(fromText('H')),
-};
-
-const testAssetI: AssetClass = {
-  currencySymbol: fromHex(
-    // random generated
-    'cc072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8dbc',
-  ),
-  tokenName: fromHex(fromText('I')),
-};
-
-const testAssetJ: AssetClass = {
-  currencySymbol: fromHex(
-    // random generated
-    'cc072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8dbd',
-  ),
-  tokenName: fromHex(fromText('J')),
-};
-
-const testAssetK: AssetClass = {
-  currencySymbol: fromHex(
-    // random generated
-    'cc072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8dbe',
-  ),
-  tokenName: fromHex(fromText('K')),
-};
-
-// NOTE: Withdrawing and PrepareWithdrawal from Treasury is tested in gov.test.ts
-describe('Treasury', () => {
-  beforeEach<MyContext>(async (context: MyContext) => {
-    context.users = {
-      admin: generateEmulatorAccount({
-        lovelace: BigInt(100_000_000_000_000),
-      }),
-      user: generateEmulatorAccount(
-        addAssets(
-          mkLovelacesOf(100_000_000_000_000n),
-          mkAssetsOf(EXAMPLE_TOKEN_1, 1_000_000_000_000_000n),
-          mkAssetsOf(EXAMPLE_TOKEN_2, 1_000_000_000_000_000n),
-          mkAssetsOf(EXAMPLE_TOKEN_3, 1_000_000_000_000_000n),
-          mkAssetsOf(testAssetA, 1_000_000_000_000_000n),
-          mkAssetsOf(testAssetB, 1_000_000_000_000_000n),
-          mkAssetsOf(testAssetC, 1_000_000_000_000_000n),
-          mkAssetsOf(testAssetD, 1_000_000_000_000_000n),
-          mkAssetsOf(testAssetE, 1_000_000_000_000_000n),
-          mkAssetsOf(testAssetF, 1_000_000_000_000_000n),
-          mkAssetsOf(testAssetG, 1_000_000_000_000_000n),
-          mkAssetsOf(testAssetH, 1_000_000_000_000_000n),
-          mkAssetsOf(testAssetI, 1_000_000_000_000_000n),
-          mkAssetsOf(testAssetJ, 1_000_000_000_000_000n),
-          mkAssetsOf(testAssetK, 1_000_000_000_000_000n),
-        ),
-      ),
-      withdrawalAccount: generateEmulatorAccount({}),
-    };
-
-    context.emulator = new Emulator(
-      [context.users.admin, context.users.user],
-      MAINNET_PROTOCOL_PARAMETERS,
-    );
-    context.lucid = await Lucid(context.emulator, 'Custom');
-
-    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
-  });
-
-  test<MyContext>('Merge (3 lovelace UTxOs)', async (context: MyContext) => {
-    const [sysParams, __] = await init(context.lucid, [iusdInitialAssetCfg()]);
-
-    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
-
-    await benchmarkAndAwaitTx(
-      'Treasury - Merge (3 lovelace UTxOs)',
-      await treasuryMergeTx(context, sysParams, [
-        mkLovelacesOf(50_000_000n),
-        mkLovelacesOf(50_000_000n),
-        mkLovelacesOf(50_000_000n),
-      ]),
-      context.lucid,
-      context.emulator,
-    );
-  });
-
-  test<MyContext>('Merge (3 INDY UTxOs)', async (context: MyContext) => {
-    const [sysParams, __] = await init(context.lucid, [iusdInitialAssetCfg()]);
-
-    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
-
-    await benchmarkAndAwaitTx(
-      'Treasury - Merge (3 INDY UTxOs)',
-      await treasuryMergeTx(context, sysParams, [
-        addAssets(
-          mkLovelacesOf(5_000_000n),
-          mkAssetsOf(EXAMPLE_TOKEN_1, 1_000_000_000n),
-        ),
-        addAssets(
-          mkLovelacesOf(5_000_000n),
-          mkAssetsOf(EXAMPLE_TOKEN_1, 1_000_000_000n),
-        ),
-        addAssets(
-          mkLovelacesOf(5_000_000n),
-          mkAssetsOf(EXAMPLE_TOKEN_1, 1_000_000_000n),
-        ),
-      ]),
-      context.lucid,
-      context.emulator,
-    );
-  });
-
-  test<MyContext>('Merge (fail, 1 lovelace, 2 INDY UTxOs)', async (context: MyContext) => {
-    const [sysParams, __] = await init(context.lucid, [iusdInitialAssetCfg()]);
-
-    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
-
-    await expectScriptFailure(
-      'All inputs have to contain the same merging assets',
-      treasuryMergeTx(context, sysParams, [
-        mkLovelacesOf(5_000_000n),
-        addAssets(
-          mkLovelacesOf(5_000_000n),
-          mkAssetsOf(EXAMPLE_TOKEN_1, 1_000_000_000n),
-        ),
-        addAssets(
-          mkLovelacesOf(5_000_000n),
-          mkAssetsOf(EXAMPLE_TOKEN_1, 1_000_000_000n),
-        ),
-      ]),
-    );
-  });
-
-  test<MyContext>('Split (12 assets)', async (context: MyContext) => {
-    const [sysParams, __] = await init(context.lucid, [iusdInitialAssetCfg()]);
-
-    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
-
-    await benchmarkAndAwaitTx(
-      'Treasury - Split (12 assets)',
-      await treasurySplitTx(
-        context,
-        sysParams,
-        addAssets(
-          mkLovelacesOf(5_000_000n),
-          mkAssetsOf(testAssetA, 1n),
-          mkAssetsOf(testAssetB, 1n),
-          mkAssetsOf(testAssetC, 1n),
-          mkAssetsOf(testAssetD, 1n),
-          mkAssetsOf(testAssetE, 1n),
-          mkAssetsOf(testAssetF, 1n),
-          mkAssetsOf(testAssetG, 1n),
-          mkAssetsOf(testAssetH, 1n),
-          mkAssetsOf(testAssetI, 1n),
-          mkAssetsOf(testAssetJ, 1n),
-          mkAssetsOf(testAssetK, 1n),
-        ),
-      ),
-      context.lucid,
-      context.emulator,
-    );
-  });
-
-  test<MyContext>('Split (fail, lovelace only)', async (context: MyContext) => {
-    const [sysParams, __] = await init(context.lucid, [iusdInitialAssetCfg()]);
-
-    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
-
-    await expectScriptFailure(
-      'All inputs must have more than 1 non-ADA asset or 1 non-ADA asset and more than 2x ADA buffer',
-      treasurySplitTx(context, sysParams, mkLovelacesOf(5_000_000n)),
-    );
-  });
-
-  test<MyContext>('Collect non-positive amount or negative extra lovelaces fails', async (context: MyContext) => {
-    const [sysParams, __] = await init(context.lucid, [iusdInitialAssetCfg()]);
-
-    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
-
-    const treasuryUTxO = await findRandomTreasuryUtxoWithOnlyAda(
-      context.lucid,
-      sysParams,
-    );
-
-    // This tests that the amount to collect cannot be negative.
-    await expectScriptFailure(
-      'Collected amount is positive',
-      treasuryCollect(
-        adaAssetClass,
-        -1_000_000n,
-        0n,
-        context.lucid,
-        sysParams,
-        treasuryUTxO,
-        treasuryUTxO,
-      ),
-    );
-
-    // This tests that the amount to collect cannot be zero.
-    await expectScriptFailure(
-      'Collected amount is positive',
-      treasuryCollect(
-        adaAssetClass,
-        0n,
-        0n,
-        context.lucid,
-        sysParams,
-        treasuryUTxO,
-        treasuryUTxO,
-      ),
-    );
-
-    // This tests that the extra lovelaces cannot be negative.
-    await expectScriptFailure(
-      'Collected amount is positive',
-      treasuryCollect(
-        adaAssetClass,
-        1n,
-        -1_000_000n,
-        context.lucid,
-        sysParams,
-        treasuryUTxO,
-        treasuryUTxO,
-      ),
-    );
-  });
-});

package/tests/utils/asserts.ts

@@ -1,87 +0,0 @@
-import {
-  isAssetsZero,
-  lovelacesAmt,
-  negateAssets,
-  noAdaValue,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import { addAssets, Assets, TxBuilder } from '@lucid-evolution/lucid';
-import { JSONStringify } from 'json-with-bigint';
-import { match, P } from 'ts-pattern';
-import { assert, expect } from 'vitest';
-
-export async function expectScriptFailure(
-  /**
-   * This doesn't have to be full message, can be just a part of it.
-   */
-  contains: string,
-  tx: Promise<TxBuilder>,
-): Promise<void> {
-  if (contains.length === 0) {
-    throw new Error('Expected error message has to be non empty.');
-  }
-
-  const result = await (await tx).completeSafe();
-
-  const errMsg = match(result)
-    .with({ _tag: 'Left', left: P.select() }, (smth) => smth.message)
-    .otherwise(() => null);
-
-  if (!errMsg) {
-    throw new Error(`Expected TX to fail, but it succeeded.`);
-  }
-
-  if (!errMsg.includes(contains)) {
-    throw new Error(
-      `Expected TX to fail with error containing: "${contains}". But got: "${errMsg}"`,
-    );
-  }
-}
-
-export function assertValueInRange<T extends number | bigint>(
-  val: T,
-  bounds: { min: T; max: T },
-): void {
-  assert(bounds.max > bounds.min, 'Bounds are incorrectly configured.');
-
-  expect(
-    bounds.min <= val && val <= bounds.max,
-    `${val} not in range [${bounds.min}, ${bounds.max}]`,
-  ).toBeTruthy();
-}
-
-export function expectValue(
-  actual: Assets,
-  msg: string,
-): {
-  toEqual: (expected: Assets) => void;
-  /**
-   * The non ADA part of value has to equal and the lovelace has to be less than or equal than
-   * the expected `maxLovelace`.
-   */
-  toEqualNonAdaAndMaxAda: (constraints: {
-    expectedNonAda: Assets;
-    maxLovelace: bigint;
-  }) => void;
-} {
-  return {
-    toEqual(expected) {
-      expect(
-        isAssetsZero(addAssets(actual, negateAssets(expected))),
-        `${msg}: Expected ${JSONStringify(actual)} to equal ${JSONStringify(expected)}`,
-      ).toBeTruthy();
-    },
-    toEqualNonAdaAndMaxAda({ expectedNonAda, maxLovelace }) {
-      expect(
-        isAssetsZero(
-          addAssets(noAdaValue(actual), negateAssets(expectedNonAda)),
-        ),
-        `${msg}: Expected no ADA part of ${JSONStringify(actual)} to equal ${JSONStringify(expectedNonAda)}`,
-      ).toBeTruthy();
-
-      expect(
-        lovelacesAmt(actual),
-        `${msg}: Lovelace part is more than expected`,
-      ).toBeLessThanOrEqual(maxLovelace);
-    },
-  };
-}

package/tests/utils/benchmark-utils.ts

@@ -1,130 +0,0 @@
-import {
-  EvalRedeemer,
-  LucidEvolution,
-  Provider,
-  TxBuilder,
-  TxSignBuilder,
-} from '@lucid-evolution/lucid';
-import { array as A } from 'fp-ts';
-import { BENCHMARK_RESULTS } from '../setup';
-import { MAINNET_PROTOCOL_PARAMETERS } from '../indigo-test-helpers';
-
-type ExUnits = { mem: number; steps: number; txSize: number };
-
-export async function calculateTxExUnits(
-  provider: Provider,
-  tx: TxSignBuilder,
-): Promise<ExUnits> {
-  const cbor = tx.toCBOR();
-  const redeemersEval = await provider.evaluateTx(tx.toCBOR());
-
-  const res = A.reduce<EvalRedeemer, ExUnits>(
-    { mem: 0, steps: 0, txSize: 0 },
-    (acc, e) => {
-      return {
-        mem: acc.mem + e.ex_units.mem,
-        steps: acc.steps + e.ex_units.steps,
-        txSize: 0,
-      };
-    },
-  )(redeemersEval);
-
-  return { ...res, txSize: cbor.length / 2 };
-}
-
-export type BenchmarkResult = ExUnits & {
-  memPercentage: number;
-  stepsPercentage: number;
-  sizePercentage: number;
-};
-
-// This function is used to benchmark a transaction and await it's successful execution.
-export async function benchmarkAndAwaitTx(
-  name: string,
-  tx: TxBuilder,
-  lucid: LucidEvolution,
-  provider: Provider,
-  extraSigners: string[] = [],
-): Promise<void> {
-  // Complete the transaction
-  const bTx = await tx.complete();
-  const signatures = [await bTx.partialSign.withWallet()];
-  for (const signer of extraSigners) {
-    lucid.selectWallet.fromSeed(signer);
-    signatures.push(await lucid.fromTx(bTx.toCBOR()).partialSign.withWallet());
-  }
-
-  const signedTx = bTx.assemble(signatures);
-
-  // Calculate execution units
-  const exUnits = await calculateTxExUnits(provider, signedTx);
-
-  // Get protocol parameters for percentages
-  const protocolParams = await provider.getProtocolParameters();
-
-  if (protocolParams.maxTxExMem !== MAINNET_PROTOCOL_PARAMETERS.maxTxExMem) {
-    throw new Error('Protocol parameters do not match Mainnet');
-  }
-
-  // Calculate percentages
-  const result = {
-    ...exUnits,
-    memPercentage: (exUnits.mem / Number(protocolParams.maxTxExMem)) * 100,
-    stepsPercentage:
-      (exUnits.steps / Number(protocolParams.maxTxExSteps)) * 100,
-    sizePercentage: (exUnits.txSize / Number(protocolParams.maxTxSize)) * 100,
-  };
-
-  BENCHMARK_RESULTS[name] = result;
-
-  await lucid.awaitTx(await (await signedTx.complete()).submit());
-}
-
-// This function is used to benchmark a transaction and await it's successful execution,
-// as well as to query the transaction fee.
-export async function benchmarkAndAwaitTxWithTxFee(
-  name: string,
-  tx: TxBuilder,
-  lucid: LucidEvolution,
-  provider: Provider,
-  extraSigners: string[] = [],
-): Promise<bigint> {
-  // Complete the transaction
-  const bTx = await tx.complete();
-  const signatures = [await bTx.partialSign.withWallet()];
-  for (const signer of extraSigners) {
-    lucid.selectWallet.fromSeed(signer);
-    signatures.push(await lucid.fromTx(bTx.toCBOR()).partialSign.withWallet());
-  }
-
-  const signedTx = bTx.assemble(signatures);
-
-  // Calculate execution units
-  const exUnits = await calculateTxExUnits(provider, signedTx);
-
-  // Get protocol parameters for percentages
-  const protocolParams = await provider.getProtocolParameters();
-
-  if (protocolParams.maxTxExMem !== MAINNET_PROTOCOL_PARAMETERS.maxTxExMem) {
-    throw new Error('Protocol parameters do not match Mainnet');
-  }
-
-  // Calculate percentages
-  const result = {
-    ...exUnits,
-    memPercentage: (exUnits.mem / Number(protocolParams.maxTxExMem)) * 100,
-    stepsPercentage:
-      (exUnits.steps / Number(protocolParams.maxTxExSteps)) * 100,
-    sizePercentage: (exUnits.txSize / Number(protocolParams.maxTxSize)) * 100,
-  };
-
-  BENCHMARK_RESULTS[name] = result;
-
-  const completedTx = await signedTx.complete();
-
-  const txFee = completedTx.toTransaction().body().fee();
-
-  await lucid.awaitTx(await completedTx.submit());
-
-  return txFee;
-}

package/tests/utils/index.ts

@@ -1,168 +0,0 @@
-import {
-  negateAssets,
-  noAdaValue,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import {
-  addAssets,
-  Assets,
-  credentialToAddress,
-  getAddressDetails,
-  LucidEvolution,
-  paymentCredentialOf,
-  UTxO,
-} from '@lucid-evolution/lucid';
-import { array as A, function as F } from 'fp-ts';
-import { zipWith } from 'fp-ts/lib/Array';
-import { runAndAwaitTxBuilder } from '../test-helpers';
-
-/**
- * In case passing in address with stake credential, the non stake credential address
- * is used as well for collecting inputs but cannot increase its value.
- */
-export async function getValueChangeAtAddressAfterAction<T>(
-  lucid: LucidEvolution,
-  address: string,
-  action: () => Promise<T>,
-): Promise<[T, Assets]> {
-  const hasStakeCred = getAddressDetails(address).stakeCredential != null;
-
-  const valBefore = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
-    addAssets(acc, utxo.assets),
-  )(await lucid.utxosAt(address));
-
-  const [res, nonStakeCredValChange] = hasStakeCred
-    ? await getValueChangeAtAddressAfterAction(
-        lucid,
-        credentialToAddress(
-          lucid.config().network!,
-          paymentCredentialOf(address),
-        ),
-        action,
-      )
-    : [await action(), {}];
-
-  if (
-    hasStakeCred &&
-    !Object.entries(nonStakeCredValChange).every(([_, amt]) => amt <= 0n)
-  ) {
-    throw new Error("Can't add value to the address without stake credential");
-  }
-
-  const valAfter = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
-    addAssets(acc, utxo.assets),
-  )(await lucid.utxosAt(address));
-
-  return [
-    res,
-    addAssets(valAfter, negateAssets(valBefore), nonStakeCredValChange),
-  ];
-}
-
-export async function getValueChangeAtAddressesAfterAction<T>(
-  lucid: LucidEvolution,
-  addresses: string[],
-  action: () => Promise<T>,
-): Promise<[T, Assets[]]> {
-  const valsBefore = [];
-
-  for (const address of addresses) {
-    const utxos = await lucid.utxosAt(address);
-    valsBefore.push(
-      F.pipe(
-        utxos,
-        A.reduce<UTxO, Assets>({}, (acc, utxo) => addAssets(acc, utxo.assets)),
-      ),
-    );
-  }
-
-  const res = await action();
-
-  const valsAfter = [];
-
-  for (const address of addresses) {
-    const utxos = await lucid.utxosAt(address);
-    valsAfter.push(
-      F.pipe(
-        utxos,
-        A.reduce<UTxO, Assets>({}, (acc, utxo) => addAssets(acc, utxo.assets)),
-      ),
-    );
-  }
-
-  return [
-    res,
-    zipWith(valsBefore, valsAfter, (valBefore, valAfter) =>
-      addAssets(valAfter, negateAssets(valBefore)),
-    ),
-  ];
-}
-
-export async function getNewUtxosAtAddressAfterAction<T>(
-  lucid: LucidEvolution,
-  address: string,
-  action: () => Promise<T>,
-): Promise<[T, UTxO[]]> {
-  const utxosBefore = await lucid.utxosAt(address);
-
-  const res = await action();
-
-  const utxosAfter = await lucid.utxosAt(address);
-
-  return [
-    res,
-    utxosAfter.filter(
-      (utxo) =>
-        utxosBefore.filter(
-          (oldUtxo) =>
-            utxo.txHash === oldUtxo.txHash &&
-            utxo.outputIndex === oldUtxo.outputIndex,
-        ).length === 0,
-    ),
-  ];
-}
-
-export async function totalValueAtAddress(
-  lucid: LucidEvolution,
-  addr: string,
-): Promise<Assets> {
-  const utxos = await lucid.utxosAt(addr);
-
-  return F.pipe(
-    utxos,
-    A.reduce<UTxO, Assets>({}, (acc, utxo) => addAssets(acc, utxo.assets)),
-  );
-}
-
-export async function sendValueTo(
-  destinationAddr: string,
-  value: Assets,
-  lucid: LucidEvolution,
-): Promise<void> {
-  await runAndAwaitTxBuilder(
-    lucid,
-    lucid.newTx().pay.ToAddress(destinationAddr, value),
-  );
-}
-
-/**
- * For all the non-ADA assets in current wallet, create a separate UTXo with each of them.
- */
-export async function fragmentWallet(lucid: LucidEvolution): Promise<void> {
-  const currentAddr = await lucid.wallet().address();
-
-  const totalVal = await totalValueAtAddress(lucid, currentAddr);
-
-  const otherAssets = Object.keys(noAdaValue(totalVal));
-
-  if (otherAssets.length === 0) return;
-
-  const tx = lucid.newTx();
-
-  for (const asset of otherAssets) {
-    tx.pay.ToAddress(currentAddr, {
-      [asset]: totalVal[asset],
-    });
-  }
-
-  await runAndAwaitTxBuilder(lucid, tx);
-}

package/tsconfig.build.json

@@ -1,4 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "exclude": ["spec/**/*.spec.ts", "vitest.config.ts"]
-}