createSimpleTransactionFromParams method

@override Future<Either<SimpleTransactionAlgebraError, IoTransaction>> createSimpleTransactionFromParams({ required String keyfile, required String password, required String fromFellowship, required String fromTemplate, int? someFromState, String? someChangeFellowship, String? someChangeTemplate, int? someChangeState, LockAddress? someToAddress, String? someToFellowship, String? someToTemplate, required int amount, required int fee, required ValueTypeIdentifier tokenType, })

Implementation

@override
Future<Either<SimpleTransactionAlgebraError, IoTransaction>>
    createSimpleTransactionFromParams({
  required String keyfile,
  required String password,
  required String fromFellowship,
  required String fromTemplate,
  int? someFromState,
  String? someChangeFellowship,
  String? someChangeTemplate,
  int? someChangeState,
  LockAddress? someToAddress,
  String? someToFellowship,
  String? someToTemplate,
  required int amount,
  required int fee,
  required ValueTypeIdentifier tokenType,
}) async {
  try {
    final keyPair = (await walletManagementUtils.loadKeys(keyfile, password))
        .getOrThrow();
    final someCurrentIndices = walletStateApi.getCurrentIndicesForFunds(
        fromFellowship, fromTemplate, someFromState);
    if (someCurrentIndices == null) {
      return Either.left(CreateTxError('Unable to get current indices'));
    }
    final predicateFundsToUnlock =
        walletStateApi.getLockByIndex(someCurrentIndices);
    if (predicateFundsToUnlock == null) {
      return Either.left(
          CreateTxError('Unable to get lock for current indices'));
    }

    final Indices? someNextIndices;
    if (someChangeFellowship != null &&
        someChangeTemplate != null &&
        someChangeState != null) {
      someNextIndices = walletStateApi.getCurrentIndicesForFunds(
          someChangeFellowship, someChangeTemplate, someChangeState);
    } else {
      someNextIndices =
          walletStateApi.getNextIndicesForFunds(fromFellowship, fromTemplate);
    }
    if (someNextIndices == null) {
      return Either.left(CreateTxError('Unable to get next indices'));
    }

    final changeLock = walletStateApi.getLock(
        fromFellowship, fromTemplate, someNextIndices.z);

    if (changeLock == null) {
      return Either.left(
          CreateTxError('Unable to get lock for next indices'));
    }

    final fromAddress = transactionBuilderApi
        .lockAddress(Lock(predicate: predicateFundsToUnlock));

    final List<Txo> txos;
    try {
      txos = (await utxoAlgebra.queryUtxo(fromAddress: fromAddress))
          .where((x) =>
              !x.transactionOutput.value.hasTopl() &&
              !x.transactionOutput.value.hasUpdateProposal())
          .toList();
    } catch (e) {
      return Either.left(NetworkProblem(e.toString()));
    }

    if (txos.isEmpty) {
      return Either.left(CreateTxError('No LVL txos found'));
    }

    final LockAddress toAddress;
    if (someToAddress != null) {
      toAddress = someToAddress;
    } else if (someToFellowship != null && someToTemplate != null) {
      final addrStr =
          walletStateApi.getAddress(someToFellowship, someToTemplate, null);

      if (addrStr == null) {
        return Either.left(CreateTxError('Unable to determine toAddress'));
      }
      final toAddressOpt = AddressCodecs.decode(addrStr);
      if (toAddressOpt.isRight) {
        toAddress = toAddressOpt.get();
      } else {
        return Either.left(CreateTxError("Invalid toAddress"));
      }
    } else {
      return Either.left(CreateTxError(
          "Either someToAddress or (someToFellowship and someToTemplate) must be provided"));
    }

    final tx = await buildTransaction(
      txos,
      someChangeFellowship,
      someChangeTemplate,
      someChangeState,
      predicateFundsToUnlock,
      changeLock,
      toAddress,
      amount,
      fee,
      someNextIndices,
      keyPair,
      tokenType,
    );

    return Either.right(tx);
  } catch (e) {
    if (e is SimpleTransactionAlgebraError) {
      return Either.left(e);
    } else {
      return Either.left(UnexpectedError(e.toString()));
    }
  }
}