# Scalus 1.0.0 public API cheatsheet # Generated - do not edit. Signatures are Scala 3. object scalus.cardano.ledger.BloxbeanToLedgerTranslation def toLedgerValue(self: com.bloxbean.cardano.client.transaction.spec.Value): Value case class scalus.cardano.ledger.CertState val vstate: VotingState val pstate: PoolsState val dstate: DelegationState object scalus.cardano.ledger.CertState def empty: CertState case class scalus.cardano.ledger.ConwayProtocolParams val minFeeA: Long val minFeeB: Long val maxBBSize: Long val maxTxSize: Long val maxBHSize: Long val keyDeposit: Long val poolDeposit: Long val eMax: Long val nOpt: Long val a0: NonNegativeInterval val rho: UnitInterval val tau: UnitInterval val protocolVersion: ProtocolVersion val minPoolCost: Long val coinsPerUTxOByte: Long val costModels: CostModels val prices: ExUnitPrices val maxTxExUnits: ExUnits val maxBlockExUnits: ExUnits val maxValSize: Long val collateralPercentage: Long val maxCollateralInputs: Long val poolVotingThresholds: PoolVotingThresholds val dRepVotingThresholds: DRepVotingThresholds val committeeMinSize: Long val committeeMaxTermLength: Long val govActionLifetime: Long val govActionDeposit: Long val dRepDeposit: Long val dRepActivity: Long val minFeeRefScriptCostPerByte: NonNegativeInterval def toProtocolParams: ProtocolParams object scalus.cardano.ledger.ConwayProtocolParams def fromCbor(cbor: Array[Byte]): ConwayProtocolParams given given_Decoder_ConwayProtocolParams: given_Decoder_ConwayProtocolParams object scalus.cardano.ledger.ConwayProtocolParams.given_Decoder_ConwayProtocolParams def read(r: Reader): ConwayProtocolParams case class scalus.cardano.ledger.DRepState val expiry: EpochNo val anchor: Option[Anchor] val deposit: Coin val delegates: Set[Credential] case class scalus.cardano.ledger.DelegationState val rewards: Map[Credential, Coin] val deposits: Map[Credential, Coin] val stakePools: Map[Credential, PoolKeyHash] val dreps: Map[Credential, DRep] enum scalus.cardano.ledger.EvaluatorMode case class scalus.cardano.ledger.FutureGenDeleg val slot: Slot val genesisKeyHash: AddrKeyHash class scalus.cardano.ledger.PlutusScriptEvaluationException val logs: Array[String] val failedScriptHash: ScriptHash val spentBudget: ExUnits val failedSourcePosition: Option[ScalusSourcePos] trait scalus.cardano.ledger.PlutusScriptEvaluator def evalPlutusScripts(tx: Transaction, utxos: Utxos, debugScripts: Map[ScriptHash, DebugScript]): Seq[Redeemer] def evalPlutusScriptsWithContexts(tx: Transaction, utxos: Utxos, debugScripts: Map[ScriptHash, DebugScript]): Seq[Tuple3[Redeemer, ScriptContext, ScriptHash]] object scalus.cardano.ledger.PlutusScriptEvaluator def buildScriptContexts(tx: Transaction, utxos: Utxos, slotConfig: SlotConfig, protocolVersion: MajorProtocolVersion): Map[Redeemer, ScriptContext] val noop: PlutusScriptEvaluator def const(budget: ExUnits): PlutusScriptEvaluator def constMaxBudget(cardanoInfo: CardanoInfo): PlutusScriptEvaluator def apply(evalBudget: Function5[Redeemer, String, PlutusVM, PlutusScript, Seq[Data], ExUnits]): PlutusScriptEvaluator def apply(slotConfig: SlotConfig, initialBudget: ExUnits, protocolMajorVersion: MajorProtocolVersion, costModels: CostModels, mode: EvaluatorMode, debugDumpFilesForTesting: Boolean, logBudgetDifferences: Boolean): PlutusScriptEvaluator def apply(slotConfig: SlotConfig, initialBudget: ExUnits, protocolMajorVersion: MajorProtocolVersion, costModels: CostModels, mode: EvaluatorMode, report: EvaluatorReportConfig, logBudgetDifferences: Boolean): PlutusScriptEvaluator def apply(cardanoInfo: CardanoInfo, mode: EvaluatorMode): PlutusScriptEvaluator case class scalus.cardano.ledger.PoolsState val stakePools: Map[PoolKeyHash, PoolRegistration] val futureStakePoolParams: Map[PoolKeyHash, PoolRegistration] val retiring: Map[PoolKeyHash, EpochNo] val deposits: Map[PoolKeyHash, Coin] object scalus.cardano.ledger.RewardsCalculation case class scalus.cardano.ledger.RewardsCalculation.RewardsConfig val monetaryExpansionRate: Double val treasuryExpansionRate: Double val minPoolCost: Coin val optimalPoolCount: Int val poolPledgeInfluence: Double case class scalus.cardano.ledger.RewardsCalculation.PoolRewardSummary val totalRewards: Coin val leaderReward: Coin val memberRewards: Map[Credential, Coin] case class scalus.cardano.ledger.RewardsCalculation.EpochRewardsSummary val epoch: Long val totalRewards: Coin val treasuryTax: Coin val availableRewards: Coin val poolRewards: Map[PoolKeyHash, PoolRewardSummary] val accountRewards: Map[Credential, Coin] def computeTotalRewards(reserves: Coin, fees: Coin, config: RewardsConfig): Tuple2[Coin, Coin] def distributePoolRewards(availableRewards: Coin, poolStakes: Map[PoolKeyHash, Coin], poolParams: Map[PoolKeyHash, PoolParameters], totalActiveStake: Coin, config: RewardsConfig): Map[PoolKeyHash, Coin] def splitPoolRewards(poolReward: Coin, poolParams: PoolParameters, poolStake: Coin, memberStakes: Map[Credential, Coin]): PoolRewardSummary def aggregateAccountRewards(poolRewards: Map[PoolKeyHash, PoolRewardSummary]): Map[Credential, Coin] case class scalus.cardano.ledger.RewardsCalculation.PoolParameters val cost: Coin val marginNumerator: Long val marginDenominator: Long val pledge: Coin object scalus.cardano.ledger.ScriptDataHashGenerator def computeScriptDataHash(redeemers: Option[KeepRaw[Redeemers]], datums: KeepRaw[TaggedSortedMap[DataHash, KeepRaw[Data]]], usedCostModels: CostModels): ScriptDataHash def computeScriptDataHash(witnessSet: TransactionWitnessSet, protocolParams: ProtocolParams, usedLanguages: TreeSet[Language], redeemers: Option[KeepRaw[Redeemers]], datums: KeepRaw[TaggedSortedMap[DataHash, KeepRaw[Data]]]): Option[ScriptDataHash] def computeScriptDataHash(transaction: Transaction, utxos: Utxos, protocolParams: ProtocolParams): Either[|[TransactionException.BadInputsUTxOException, TransactionException.BadReferenceInputsUTxOException], Option[ScriptDataHash]] object scalus.cardano.ledger.StakeDistribution case class scalus.cardano.ledger.StakeDistribution.StakeDistributionSnapshot val activeStake: Coin val poolStakes: Map[PoolKeyHash, Coin] val stakeCredentials: Map[Credential, Coin] def computeSnapshot(utxos: Utxos, delegations: Map[Credential, PoolKeyHash], drepDelegations: Map[Credential, DRep]): StakeDistributionSnapshot def computeDRepVotingStake(stakeByCredential: Map[Credential, Coin], drepDelegations: Map[Credential, DRep]): Map[DRep, Coin] def fromCertState(utxos: Utxos, certState: CertState): StakeDistributionSnapshot class scalus.cardano.ledger.TransactionException def explain: String object scalus.cardano.ledger.TransactionException case class scalus.cardano.ledger.TransactionException.EmptyInputsException val transactionId: TransactionHash case class scalus.cardano.ledger.TransactionException.NonDisjointInputsAndReferenceInputsException val transactionId: TransactionHash val intersection: Set[TransactionInput] case class scalus.cardano.ledger.TransactionException.BadAllInputsUTxOException val transactionId: TransactionHash val missingInputs: Set[TransactionInput] val missingCollateralInputs: Set[TransactionInput] val missingReferenceInputs: Set[TransactionInput] case class scalus.cardano.ledger.TransactionException.BadInputsUTxOException val transactionId: TransactionHash case class scalus.cardano.ledger.TransactionException.BadCollateralInputsUTxOException val transactionId: TransactionHash case class scalus.cardano.ledger.TransactionException.BadReferenceInputsUTxOException val transactionId: TransactionHash case class scalus.cardano.ledger.TransactionException.InvalidSignaturesInWitnessesException val transactionId: TransactionHash val invalidVkeyWitnesses: Set[VKeyWitness] val invalidBootstrapWitnesses: Set[BootstrapWitness] case class scalus.cardano.ledger.TransactionException.MissingKeyHashesException val transactionId: TransactionHash val missingInputsKeyHashes: Set[AddrKeyHash | StakeKeyHash] val missingCollateralInputsKeyHashes: Set[AddrKeyHash | StakeKeyHash] val missingVotingProceduresKeyHashes: Set[AddrKeyHash] val missingWithdrawalsKeyHashes: Set[AddrKeyHash | StakeKeyHash] val missingCertificatesKeyHashes: Set[AddrKeyHash | PoolKeyHash] val missingRequiredSignersKeyHashes: Set[AddrKeyHash] case class scalus.cardano.ledger.TransactionException.MissingOrExtraScriptHashesException val transactionId: TransactionHash val missingInputsScriptHashes: Set[ScriptHash] val missingMintScriptHashes: Set[ScriptHash] val missingVotingProceduresScriptHashes: Set[ScriptHash] val missingWithdrawalsScriptHashes: Set[ScriptHash] val missingProposalProceduresScriptHashes: Set[ScriptHash] val missingCertificatesScriptHashes: Set[ScriptHash] val extraScriptHashes: Set[ScriptHash] case class scalus.cardano.ledger.TransactionException.NativeScriptsException val transactionId: TransactionHash val invalidWitnessesNativeScripts: Set[ScriptHash] val invalidProvidedReferenceNativeScripts: Set[ScriptHash] case class scalus.cardano.ledger.TransactionException.InvalidTransactionSizeException val transactionId: TransactionHash val transactionSize: Int val maxTransactionSize: Long case class scalus.cardano.ledger.TransactionException.OutputsHaveNotEnoughCoinsException val transactionId: TransactionHash val invalidOutputs: Seq[Tuple3[TransactionOutput, Coin, MultiAsset]] val invalidCollateralOutput: Option[Tuple3[TransactionOutput, Coin, MultiAsset]] case class scalus.cardano.ledger.TransactionException.OutputsHaveTooBigValueStorageSizeException val transactionId: TransactionHash val maxValueSize: Long val invalidOutputs: Seq[Tuple2[TransactionOutput, Int]] val invalidCollateralOutput: Option[Tuple2[TransactionOutput, Int]] case class scalus.cardano.ledger.TransactionException.OutsideValidityIntervalException val transactionId: TransactionHash val validityInterval: ValidityInterval val slot: SlotNo case class scalus.cardano.ledger.TransactionException.ValueNotConservedUTxOException val transactionId: TransactionHash val consumed: Value val produced: Value case class scalus.cardano.ledger.TransactionException.FeesOkException val transactionId: TransactionHash val transactionFee: Coin val minRequiredFee: Coin val collateralPercentage: Long val areTotalExUnitsZero: Boolean val collateralReturnOutput: Option[TransactionOutput] val actualTotalSumOfCollateralCoins: Coin val expectedTotalSumOfCollateralCoins: Option[Coin] val collateralsConsistNotVKeyAddress: Utxos val collateralsContainNotOnlyADA: Utxos val remainingAssets: MultiAsset val hasCollateralInputs: Boolean def isTransactionFeeLessThanMinRequiredFee: Boolean def hasCollateralsConsistNotVKeyAddress: Boolean def hasCollateralsContainNotOnlyADA: Boolean def isCollateralInsufficient: Boolean def isCollateralNotEqualToExpected: Boolean def areCollateralInputsMissing: Boolean case class scalus.cardano.ledger.TransactionException.StakeCertificatesException val transactionId: TransactionHash val alreadyRegistered: Set[Credential] val missingRegistrations: Set[Credential] val nonZeroRewardAccounts: Map[Credential, Coin] val invalidDeposits: Map[Credential, Tuple2[Coin, Coin]] val invalidRefunds: Map[Credential, Tuple2[Coin, Coin]] case class scalus.cardano.ledger.TransactionException.StakePoolException val transactionId: TransactionHash val notRegistered: Set[PoolKeyHash] val rewardAccountNetworkMismatch: Set[Tuple3[PoolKeyHash, Network, Network]] val costBelowMinimum: Map[PoolKeyHash, Tuple2[Coin, Coin]] val invalidRetirementEpochs: Map[PoolKeyHash, Tuple3[Long, Long, Long]] case class scalus.cardano.ledger.TransactionException.DRepException val transactionId: TransactionHash val alreadyRegistered: Set[Credential] val notRegistered: Set[Credential] val invalidDeposits: Map[Credential, Tuple2[Coin, Coin]] val invalidRefunds: Map[Credential, Tuple2[Coin, Coin]] case class scalus.cardano.ledger.TransactionException.WithdrawalsNotInRewardsException val transactionId: TransactionHash val missingRewardAccounts: Map[RewardAccount, Coin] val nonDrainingWithdrawals: Map[RewardAccount, Tuple2[Coin, Coin]] case class scalus.cardano.ledger.TransactionException.ExUnitsExceedMaxException val transactionId: TransactionHash val actualTxExecutionUnits: ExUnits val maxTxExecutionUnits: ExUnits case class scalus.cardano.ledger.TransactionException.TooManyCollateralInputsException val transactionId: TransactionHash val actualCollateralInputsSize: Int val maxCollateralInputsSize: Long case class scalus.cardano.ledger.TransactionException.InvalidScriptDataHashException val transactionId: TransactionHash val actual: Option[ScriptDataHash] val expected: Option[ScriptDataHash] case class scalus.cardano.ledger.TransactionException.IllFormedScriptsException val transactionId: TransactionHash val invalidWitnessesScripts: Set[ScriptHash] val InvalidScriptsFromAllOutputs: Set[ScriptHash] case class scalus.cardano.ledger.TransactionException.WrongNetworkAddress val transactionId: TransactionHash val invalidOutputAddresses: Seq[Address] val invalidCollateralReturnAddresses: Option[Address] case class scalus.cardano.ledger.TransactionException.WrongNetworkWithdrawal val transactionId: TransactionHash val invalidWithdrawals: Seq[Tuple2[RewardAccount, Coin]] case class scalus.cardano.ledger.TransactionException.WrongNetworkInTxBody val transactionId: TransactionHash val actualNetworkId: Int val expectedNetworkId: Int class scalus.cardano.ledger.TransactionException.MetadataException val MetadataException: MetadataException object scalus.cardano.ledger.TransactionException.MetadataException case class scalus.cardano.ledger.TransactionException.MetadataException.MissingAuxiliaryDataException val transactionId: TransactionHash val auxiliaryDataHash: AuxiliaryDataHash case class scalus.cardano.ledger.TransactionException.MetadataException.MissingAuxiliaryDataHashException val transactionId: TransactionHash val auxiliaryData: AuxiliaryData case class scalus.cardano.ledger.TransactionException.MetadataException.InvalidAuxiliaryDataHashException val transactionId: TransactionHash val actual: AuxiliaryDataHash val expected: AuxiliaryDataHash case class scalus.cardano.ledger.TransactionException.MetadataException.InvalidAuxiliaryDataException val transactionId: TransactionHash val auxiliaryData: AuxiliaryData case class scalus.cardano.ledger.TransactionException.ExactSetOfRedeemersException val transactionId: TransactionHash val extraRedeemers: Set[Tuple2[RedeemerTag, Int]] val missingRedeemers: Set[Tuple2[RedeemerTag, Int]] case class scalus.cardano.ledger.TransactionException.DatumsException val transactionId: TransactionHash val inputsWithMissingDatumHashes: Set[TransactionInput] val unmatchedDatumHashes: Set[DataHash] val notAllowedSupplementalDatumHashes: Set[DataHash] case class scalus.cardano.ledger.TransactionException.OutputBootAddrAttrsTooBigException val transactionId: TransactionHash val outputsWithOversizedAttrs: Seq[Address] val maxAllowedSize: Int case class scalus.cardano.ledger.TransactionException.PlutusScriptValidationException val transactionId: TransactionHash val message: String val logs: Seq[String] val spentBudget: ExUnits val scriptHash: Option[ScriptHash] case class scalus.cardano.ledger.TransactionException.IllegalArgumentException val message: String case class scalus.cardano.ledger.UTxOState val utxo: Utxos val deposited: Coin val fees: Coin val govState: GovState val stakeDistribution: StakeMap val donation: Coin case class scalus.cardano.ledger.VotingState val dreps: Map[Credential, DRepState] case class scalus.cardano.node.AppliedTx val tx: Transaction val slot: SlotNo val spent: Utxos def txHash: TransactionHash trait scalus.cardano.node.BlockchainProvider def submit(transaction: Transaction): Future[Either[SubmitError, TransactionHash]] def pollForConfirmation(txHash: TransactionHash, maxAttempts: Int, delayMs: Long): Future[TransactionStatus] def submitAndPoll(transaction: Transaction, maxAttempts: Int, delayMs: Long): Future[Either[SubmitError, TransactionHash]] trait scalus.cardano.node.BlockchainProviderTF def submit(transaction: Transaction): F[Either[SubmitError, TransactionHash]] def pollForConfirmation(txHash: TransactionHash, maxAttempts: Int, delayMs: Long): F[TransactionStatus] def submitAndPoll(transaction: Transaction, maxAttempts: Int, delayMs: Long): F[Either[SubmitError, TransactionHash]] trait scalus.cardano.node.BlockchainReader def executionContext: scala.concurrent.ExecutionContext def cardanoInfo: CardanoInfo def fetchLatestParams: Future[ProtocolParams] def currentSlot: Future[SlotNo] def getDatum(datumHash: DataHash): Future[Option[Data]] def findUtxos(query: UtxoQuery): Future[Either[UtxoQueryError, Utxos]] def checkTransaction(txHash: TransactionHash): Future[TransactionStatus] trait scalus.cardano.node.BlockchainReaderTF def cardanoInfo: CardanoInfo def fetchLatestParams: F[ProtocolParams] def findUtxos(query: UtxoQuery): F[Either[UtxoQueryError, Utxos]] def findUtxo(input: TransactionInput): F[Either[UtxoQueryError, Utxo]] def findUtxos(inputs: Set[TransactionInput]): F[Either[UtxoQueryError, Utxos]] def findUtxos(address: Address): F[Either[UtxoQueryError, Utxos]] def currentSlot: F[SlotNo] def getDatum(datumHash: DataHash): F[Option[Data]] def checkTransaction(txHash: TransactionHash): F[TransactionStatus] def queryUtxos(f: Function1[Utxo, Boolean]): UtxoQueryWithReaderTF[F] class scalus.cardano.node.BlockfrostProvider def executionContext: ExecutionContext def cardanoInfo: CardanoInfo def network: Network def slotConfig: SlotConfig def refreshCardanoInfo: Future[CardanoInfo] def fetchScriptInfo(scriptHash: String): Future[ScriptInfo] def fetchScriptJson(scriptHash: String): Future[ujson.Value] def fetchScriptCbor(scriptHash: String): Future[ByteString] def fetchDatumJson(datumHash: String): Future[ujson.Value] def fetchDatumCbor(datumHash: String): Future[ByteString] def fetchDatum(datumHash: String): Future[Data] def fetchAddressInfo(address: String): Future[AddressInfo] def fetchAddressTransactions(address: String, page: Option[Int], count: Int, order: String): Future[Seq[AddressTransaction]] def fetchAddressTxHashes(address: String, page: Option[Int], count: Int, order: String): Future[Seq[String]] def fetchLatestBlock: Future[BlockInfo] def fetchLatestBlockTxs(page: Option[Int], count: Int): Future[Seq[String]] def fetchBlock(hashOrNumber: String): Future[BlockInfo] def fetchBlockTxs(hashOrNumber: String, page: Option[Int], count: Int, order: String): Future[Seq[String]] def fetchBlockNext(hashOrNumber: String, page: Option[Int], count: Int): Future[Seq[BlockInfo]] def fetchBlockPrevious(hashOrNumber: String, page: Option[Int], count: Int): Future[Seq[BlockInfo]] def fetchBlockAddresses(hashOrNumber: String, page: Option[Int], count: Int): Future[Seq[BlockAddress]] def fetchBlockBySlot(slot: Long): Future[BlockInfo] def fetchTransactionInfo(txHash: String): Future[TransactionInfo] def fetchTransactionCbor(txHash: String): Future[ByteString] def fetchTransactionMetadata(txHash: String): Future[Seq[TransactionMetadataEntry]] def fetchTransactionMetadataCbor(txHash: String): Future[Seq[TransactionMetadataCborEntry]] def fetchTransactionRedeemers(txHash: String): Future[Seq[TransactionRedeemer]] def fetchTransactionWithdrawals(txHash: String): Future[Seq[TransactionWithdrawal]] def fetchTransactionDelegations(txHash: String): Future[Seq[TransactionDelegation]] def fetchTransactionMirs(txHash: String): Future[Seq[TransactionMir]] def fetchTransactionPoolUpdates(txHash: String): Future[Seq[TransactionPoolUpdate]] def fetchTransactionPoolRetires(txHash: String): Future[Seq[TransactionPoolRetire]] def fetchTransactionStakes(txHash: String): Future[Seq[TransactionStake]] def fetchAccount(stakeAddress: String): Future[AccountInfo] def fetchAccountRegistrations(stakeAddress: String, page: Option[Int], count: Int, order: String): Future[Seq[AccountRegistration]] def fetchAccountDelegations(stakeAddress: String, page: Option[Int], count: Int, order: String): Future[Seq[AccountDelegation]] def fetchAccountAddresses(stakeAddress: String, page: Option[Int], count: Int, order: String): Future[Seq[AccountAddress]] def fetchAccountUtxos(stakeAddress: String, page: Option[Int], count: Int, order: String): Future[Either[UtxoQueryError, Utxos]] def fetchAccountRewards(stakeAddress: String, page: Option[Int], count: Int, order: String): Future[Seq[AccountReward]] def fetchAsset(asset: String): Future[AssetInfo] def fetchAssetAddresses(asset: String, page: Option[Int], count: Int, order: String): Future[Seq[AssetAddress]] def fetchAssetTransactions(asset: String, page: Option[Int], count: Int, order: String): Future[Seq[AssetTransaction]] def fetchMetadataByLabel(label: Long, page: Option[Int], count: Int, order: String): Future[Seq[TxMetadataJson]] def fetchMetadataByLabelCbor(label: Long, page: Option[Int], count: Int, order: String): Future[Seq[TxMetadataCbor]] def fetchGenesis: Future[GenesisInfo] def fetchNetwork: Future[NetworkInfo] def fetchNetworkEras: Future[Seq[EraInfo]] def fetchEpochBlocks(epoch: Long, page: Option[Int], count: Int, order: String): Future[Seq[String]] def fetchPoolsExtended(page: Option[Int], count: Int, order: String): Future[Seq[PoolExtended]] def fetchPoolDelegators(poolId: String, page: Option[Int], count: Int, order: String): Future[Seq[PoolDelegator]] def fetchPoolHistory(poolId: String, page: Option[Int], count: Int, order: String): Future[Seq[PoolHistoryEntry]] def fetchDrep(drepId: String): Future[DrepInfo] def fetchApiRoot: Future[ApiRootInfo] def fetchHealth: Future[HealthStatus] def fetchHealthClock: Future[HealthClock] def currentSlot: Future[SlotNo] def getDatum(datumHash: DataHash): Future[Option[Data]] def fetchLatestParams: Future[ProtocolParams] def fetchParamsOfEpoch(epoch: Long): Future[ProtocolParams] def submit(tx: Transaction): Future[Either[SubmitError, TransactionHash]] def checkTransaction(txHash: TransactionHash): Future[TransactionStatus] def pollForConfirmation(txHash: TransactionHash, maxAttempts: Int, delayMs: Long): Future[TransactionStatus] def findUtxos(query: UtxoQuery): Future[Either[UtxoQueryError, Utxos]] def resolveScriptRef(scriptHash: ScriptHash): Future[ScriptRef] object scalus.cardano.node.BlockfrostProvider val mainnetUrl: String def parseProtocolParamsResponse(response: Response[Either[String, String]]): ProtocolParams val previewUrl: String val preprodUrl: String val localUrl: String val localAdminUrl: String def parseUtxos(json: String): Utxos def parseUtxoItems(items: Seq[ujson.Value]): Utxos def parseUtxoItemsWithRefHashes(items: Seq[ujson.Value]): Tuple2[Utxos, Map[TransactionInput, ScriptHash]] def referenceScriptHash(json: ujson.Value): Option[ScriptHash] def buildPlutusScript(scriptType: String, expectedHash: ScriptHash, cbor: ByteString): Script def buildNativeScript(expectedHash: ScriptHash, timelockJson: ujson.Value): Script def mainnet(apiKey: String, maxConcurrentRequests: Int)(using ec: ExecutionContext): Future[BlockfrostProvider] def preview(apiKey: String, maxConcurrentRequests: Int)(using ec: ExecutionContext): Future[BlockfrostProvider] def preprod(apiKey: String, maxConcurrentRequests: Int)(using ec: ExecutionContext): Future[BlockfrostProvider] def localYaci(baseUrl: String, adminUrl: String, maxConcurrentRequests: Int)(using ec: ExecutionContext): Future[BlockfrostProvider] def fetchYaciSlotConfig(adminUrl: String)(using backend: Backend[[T >: Nothing <: Any] => Future[T]], ec: ExecutionContext): Future[SlotConfig] def create(apiKey: String, baseUrl: String, network: Network, slotConfig: SlotConfig, maxConcurrentRequests: Int)(using ec: ExecutionContext): Future[BlockfrostProvider] object scalus.cardano.node.BlockfrostProviderPlatform def defaultBackend: Backend[[T >: Nothing <: Any] => Future[T]] def delayFuture(ms: Long): Future[Unit] class scalus.cardano.node.ConcurrencyLimiter def apply[T](f: => Future[T]): Future[T] case class scalus.cardano.node.DelegationInfo val poolId: Option[PoolKeyHash] val rewards: Coin class scalus.cardano.node.Emulator val validators: Iterable[Validator] val mutators: Iterable[Mutator] def utxos: Utxos def certState: CertState def datums: Map[DataHash, Data] def appliedTxLog: Vector[AppliedTx] def appliedTxIndex: Map[TransactionHash, AppliedTx] def appliedTxs: Set[TransactionHash] def submitSync(transaction: Transaction): Either[SubmitError, TransactionHash] def submitSync(transaction: Transaction, debugScripts: Map[ScriptHash, DebugScript]): Either[SubmitError, TransactionHash] def setSlot(slot: SlotNo): Unit def clearAppliedTxs(): Unit def snapshot(): Emulator object scalus.cardano.node.Emulator val defaultValidators: Set[STS.Validator] val defaultMutators: Set[STS.Mutator] def withAddresses(addresses: Seq[Address]): Emulator def withAddresses(addresses: Seq[Address], initialValue: Value): Emulator def withAddresses(addresses: java.util.List[Address]): Emulator def withAddresses(addresses: java.util.List[Address], initialValue: Value): Emulator def withState(initState: EmulatorInitialState): Emulator def withState(initState: EmulatorInitialState, context: Context): Emulator def withRegisteredStakeCredentials(initialUtxos: Utxos, initialStakeRewards: Map[Credential, Coin]): Emulator def withRegisteredStakeCredentials(initialUtxos: Utxos, initialStakeRewards: Map[Credential, Coin], initialContext: Context): Emulator trait scalus.cardano.node.EmulatorBase def executionContext: ExecutionContext def validators: Iterable[STS.Validator] def mutators: Iterable[STS.Mutator] def utxos: Utxos def certState: CertState def datums: Map[DataHash, Data] def appliedTxIndex: Map[TransactionHash, AppliedTx] def appliedTxLog: Seq[AppliedTx] def appliedTxs: Set[TransactionHash] def submitSync(transaction: Transaction): Either[SubmitError, TransactionHash] def setSlot(slot: SlotNo): Unit def snapshot(): Emulator def clearAppliedTxs(): Unit def evaluatorMode: EvaluatorMode def tick(n: Long): Unit def hasTx(txHash: TransactionHash): Boolean def getTransaction(txHash: TransactionHash): Option[Transaction] def getAppliedTx(txHash: TransactionHash): Option[AppliedTx] def getDelegation(credential: Credential): DelegationInfo def getDatum(datumHash: DataHash): Future[Option[Data]] def cardanoInfo: CardanoInfo def currentSlot: Future[SlotNo] def fetchLatestParams: Future[ProtocolParams] def submit(transaction: Transaction): Future[Either[SubmitError, TransactionHash]] def submit(transaction: Transaction, debugScripts: Map[ScriptHash, DebugScript]): Future[Either[SubmitError, TransactionHash]] def submitSync(transaction: Transaction, debugScripts: Map[ScriptHash, DebugScript]): Either[SubmitError, TransactionHash] def findUtxos(query: UtxoQuery): Future[Either[UtxoQueryError, Utxos]] object scalus.cardano.node.EmulatorBase def evalQuery(utxos: Utxos, query: UtxoQuery): Utxos def createInitialUtxos(addresses: Seq[Address]): Utxos def createInitialUtxos(addresses: Seq[Address], initialValue: Value): Utxos def resolveSpent(utxos: Utxos, transaction: Transaction): Utxos def indexAppliedTxs(log: Iterable[AppliedTx]): Map[TransactionHash, AppliedTx] def extractDatums(transaction: Transaction): Map[DataHash, Data] def buildInitialState(initState: EmulatorInitialState, context: Context): Tuple2[CertState, Map[DataHash, Data]] def certStateWithRegisteredCredentials(initialStakeRewards: Map[Credential, Coin], context: Context): CertState case class scalus.cardano.node.EmulatorDRepRegistration val credential: Credential val deposit: Coin val anchor: Option[Anchor] object scalus.cardano.node.EmulatorDRepRegistration def of(credential: Credential, deposit: Coin): EmulatorDRepRegistration def of(credential: Credential, deposit: Coin, anchor: Anchor): EmulatorDRepRegistration case class scalus.cardano.node.EmulatorInitialState val utxos: Utxos val stakeRegistrations: Seq[EmulatorStakeRegistration] val poolRegistrations: Seq[EmulatorPoolRegistration] val drepRegistrations: Seq[EmulatorDRepRegistration] val datums: Map[DataHash, Data] object scalus.cardano.node.EmulatorInitialState def builder(): Builder class scalus.cardano.node.EmulatorInitialState.Builder def utxos(utxos: java.util.Map[TransactionInput, TransactionOutput]): Builder def putUtxo(input: TransactionInput, output: TransactionOutput): Builder def datums(datums: java.util.Map[DataHash, Data]): Builder def addStakeRegistration(registration: EmulatorStakeRegistration): Builder def addPoolRegistration(registration: EmulatorPoolRegistration): Builder def addDRepRegistration(registration: EmulatorDRepRegistration): Builder def build(): EmulatorInitialState trait scalus.cardano.node.EmulatorJavaApi def getUtxos: java.util.Map[TransactionInput, TransactionOutput] def getDatums: java.util.Map[DataHash, Data] def getAppliedTxLog: java.util.List[AppliedTx] def getAppliedTxHashes: java.util.Set[TransactionHash] def getTransactionOrNull(txHash: TransactionHash): Transaction def getAppliedTxOrNull(txHash: TransactionHash): AppliedTx def getDatumOrNull(datumHash: DataHash): Data def getCurrentSlot: Long def getProtocolParams: ProtocolParams def trySubmit(transaction: Transaction): SubmitResult def trySubmit(transaction: Transaction, debugScripts: java.util.Map[ScriptHash, DebugScript]): SubmitResult def submitAsync(transaction: Transaction): CompletableFuture[SubmitResult] def findUtxosForAddress(address: Address): java.util.List[Utxo] def findUtxosForInputs(inputs: java.util.Set[TransactionInput]): java.util.List[Utxo] def findUtxosForAddressAsync(address: Address): CompletableFuture[java.util.List[Utxo]] case class scalus.cardano.node.EmulatorPoolRegistration val params: PoolRegistration case class scalus.cardano.node.EmulatorStakeRegistration val credential: Credential val rewards: Coin val delegatedTo: Option[PoolKeyHash] object scalus.cardano.node.EmulatorStakeRegistration def of(credential: Credential): EmulatorStakeRegistration def of(credential: Credential, rewards: Coin): EmulatorStakeRegistration def of(credential: Credential, rewards: Coin, delegatedTo: PoolKeyHash): EmulatorStakeRegistration trait scalus.cardano.node.NetworkSubmitError object scalus.cardano.node.NetworkSubmitError case class scalus.cardano.node.NetworkSubmitError.ConnectionError val message: String val cause: Option[Throwable] case class scalus.cardano.node.NetworkSubmitError.AuthenticationError val message: String case class scalus.cardano.node.NetworkSubmitError.RateLimited val message: String case class scalus.cardano.node.NetworkSubmitError.Banned val message: String case class scalus.cardano.node.NetworkSubmitError.MempoolFull val message: String case class scalus.cardano.node.NetworkSubmitError.InternalError val message: String val cause: Option[Throwable] trait scalus.cardano.node.NodeSubmitError object scalus.cardano.node.NodeSubmitError case class scalus.cardano.node.NodeSubmitError.UtxoNotAvailable val message: String val unavailableInputs: Set[TransactionInput] case class scalus.cardano.node.NodeSubmitError.TransactionExpired val message: String case class scalus.cardano.node.NodeSubmitError.ValueNotConserved val message: String case class scalus.cardano.node.NodeSubmitError.ScriptFailure val message: String val logs: Seq[String] val scriptHash: Option[ScriptHash] val spentBudget: ExUnits case class scalus.cardano.node.NodeSubmitError.ValidationError val message: String val errorCode: Option[String] trait scalus.cardano.node.SubmitError def message: String object scalus.cardano.node.SubmitError val ConnectionError: ConnectionError.type val AuthenticationError: AuthenticationError.type val RateLimited: RateLimited.type val Banned: Banned.type val MempoolFull: MempoolFull.type val InternalError: InternalError.type val UtxoNotAvailable: UtxoNotAvailable.type val TransactionExpired: TransactionExpired.type val ValueNotConserved: ValueNotConserved.type val ScriptFailure: ScriptFailure.type val ValidationError: ValidationError.type def fromHttpResponse(statusCode: Int, message: String): SubmitError def parseValidationError(message: String): SubmitError def fromException(ex: TransactionException): SubmitError class scalus.cardano.node.SubmitResult def isSuccess: Boolean def getTxHashOrNull: TransactionHash def getErrorOrNull: SubmitError def getErrorMessageOrNull: String def toEither: Either[SubmitError, TransactionHash] def toString: String object scalus.cardano.node.SubmitResult def fromEither(result: Either[SubmitError, TransactionHash]): SubmitResult enum scalus.cardano.node.TransactionStatus trait scalus.cardano.node.UtxoFilter def &&(other: UtxoFilter): UtxoFilter def ||(other: UtxoFilter): UtxoFilter def unary_!: UtxoFilter object scalus.cardano.node.UtxoFilter case class scalus.cardano.node.UtxoFilter.HasAsset val policyId: PolicyId val assetName: AssetName case class scalus.cardano.node.UtxoFilter.HasDatum val datum: DatumOption case class scalus.cardano.node.UtxoFilter.HasDatumHash val hash: DataHash case class scalus.cardano.node.UtxoFilter.MinLovelace val amount: Coin case class scalus.cardano.node.UtxoFilter.AtInputs val inputs: Set[TransactionInput] case class scalus.cardano.node.UtxoFilter.And val left: UtxoFilter val right: UtxoFilter case class scalus.cardano.node.UtxoFilter.Or val left: UtxoFilter val right: UtxoFilter case class scalus.cardano.node.UtxoFilter.Not val filter: UtxoFilter trait scalus.cardano.node.UtxoQuery def ||(other: UtxoQuery): UtxoQuery def &&(f: UtxoFilter): UtxoQuery def limit(n: Int): UtxoQuery def skip(n: Int): UtxoQuery def minTotal(amount: Coin): UtxoQuery object scalus.cardano.node.UtxoQuery case class scalus.cardano.node.UtxoQuery.Simple val source: UtxoSource val filter: Option[UtxoFilter] val limit: Option[Int] val offset: Option[Int] val minRequiredTotalAmount: Option[Coin] def &&(f: UtxoFilter): UtxoQuery def limit(n: Int): UtxoQuery def skip(n: Int): UtxoQuery def minTotal(amount: Coin): UtxoQuery case class scalus.cardano.node.UtxoQuery.Or val left: UtxoQuery val right: UtxoQuery val limit: Option[Int] val offset: Option[Int] val minRequiredTotalAmount: Option[Coin] def &&(f: UtxoFilter): UtxoQuery def limit(n: Int): UtxoQuery def skip(n: Int): UtxoQuery def minTotal(amount: Coin): UtxoQuery def apply(source: UtxoSource): Simple given given_Conversion_UtxoSource_UtxoQuery: Conversion[UtxoSource, UtxoQuery] def evalFilter(filter: UtxoFilter, utxo: Tuple2[TransactionInput, TransactionOutput]): Boolean def applyPagination(candidates: Utxos, limit: Option[Int], offset: Option[Int], minRequiredTotalAmount: Option[Coin]): Utxos def propagate(q: UtxoQuery, limit: Option[Int], minTotal: Option[Coin]): UtxoQuery enum scalus.cardano.node.UtxoQueryError object scalus.cardano.node.UtxoQueryMacros def buildQuery(f: Function1[Utxo, Boolean]): UtxoQuery case class scalus.cardano.node.UtxoQueryWithReaderTF val reader: BlockchainReaderTF[F] val query: UtxoQuery def limit(n: Int): UtxoQueryWithReaderTF[F] def skip(n: Int): UtxoQueryWithReaderTF[F] def minTotal(amount: Coin): UtxoQueryWithReaderTF[F] def execute(): F[Either[UtxoQueryError, Utxos]] trait scalus.cardano.node.UtxoSource def ||(other: UtxoSource): UtxoSource def &&(other: UtxoSource): UtxoSource object scalus.cardano.node.UtxoSource case class scalus.cardano.node.UtxoSource.FromAddress val address: Address case class scalus.cardano.node.UtxoSource.FromAsset val policyId: PolicyId val assetName: AssetName case class scalus.cardano.node.UtxoSource.FromInputs val inputs: Set[TransactionInput] case class scalus.cardano.node.UtxoSource.FromTransaction val transactionId: TransactionHash case class scalus.cardano.node.UtxoSource.Or val left: UtxoSource val right: UtxoSource case class scalus.cardano.node.UtxoSource.And val left: UtxoSource val right: UtxoSource object scalus.cardano.txbuilder.Change def changeOutputDiffHandler(diff: Value, tx: Transaction, protocolParams: ProtocolParams, changeOutputIdx: Int): Either[TxBalancingError, Transaction] trait scalus.cardano.txbuilder.Datum object scalus.cardano.txbuilder.Datum val DatumInlined: DatumInlined object scalus.cardano.txbuilder.Datum.DatumInlined case class scalus.cardano.txbuilder.Datum.DatumValue val datum: Data case class scalus.cardano.txbuilder.DelayedDatumSpec val outputIndex: Int val datumBuilder: Function1[Transaction, Data] val step: TransactionBuilderStep case class scalus.cardano.txbuilder.DelayedRedeemerSpec val purpose: RedeemerPurpose val redeemerBuilder: Function1[Transaction, Data] val step: TransactionBuilderStep case class scalus.cardano.txbuilder.DetachedRedeemer val datum: Data val purpose: RedeemerPurpose case class scalus.cardano.txbuilder.EditableTransaction val transaction: Transaction val redeemers: Vector[DetachedRedeemer] case class scalus.cardano.txbuilder.NativeScriptWitness val scriptSource: ScriptSource[Native] def witnessKind: WitnessKind object scalus.cardano.txbuilder.NativeScriptWitness def attached(script: Script.Native): NativeScriptWitness def reference(): NativeScriptWitness object scalus.cardano.txbuilder.PubKeyWitness def witnessKind: WitnessKind case class scalus.cardano.txbuilder.RedeemerIndexingInternalError val detachedRedeemer: DetachedRedeemer val steps: Seq[TransactionBuilderStep] object scalus.cardano.txbuilder.RedeemerManagement def detachRedeemer(tx: Transaction, redeemer: Redeemer): Option[DetachedRedeemer] def indexFor(tx: Transaction, purpose: RedeemerPurpose): Int def attachRedeemer(tx: Transaction, detached: DetachedRedeemer): Option[Redeemer] def attachRedeemers(tx: Transaction, detached: Vector[DetachedRedeemer]): Either[DetachedRedeemer, Vector[Redeemer]] trait scalus.cardano.txbuilder.RedeemerPurpose def redeemerTag: RedeemerTag object scalus.cardano.txbuilder.RedeemerPurpose case class scalus.cardano.txbuilder.RedeemerPurpose.ForSpend val input: TransactionInput def redeemerTag: RedeemerTag case class scalus.cardano.txbuilder.RedeemerPurpose.ForMint val scriptHash: ScriptHash def redeemerTag: RedeemerTag case class scalus.cardano.txbuilder.RedeemerPurpose.ForReward val rewardAddress: RewardAccount def redeemerTag: RedeemerTag case class scalus.cardano.txbuilder.RedeemerPurpose.ForCert val certificate: Certificate def redeemerTag: RedeemerTag case class scalus.cardano.txbuilder.RedeemerPurpose.ForVote val voter: Voter def redeemerTag: RedeemerTag case class scalus.cardano.txbuilder.RedeemerPurpose.ForPropose val proposal: ProposalProcedure def redeemerTag: RedeemerTag enum scalus.cardano.txbuilder.ResolvedTxInput trait scalus.cardano.txbuilder.ScriptSource object scalus.cardano.txbuilder.ScriptSource case class scalus.cardano.txbuilder.ScriptSource.NativeScriptValue val script: Native val NativeScriptAttached: NativeScriptAttached object scalus.cardano.txbuilder.ScriptSource.NativeScriptAttached case class scalus.cardano.txbuilder.ScriptSource.PlutusScriptValue val script: PlutusScript val PlutusScriptAttached: PlutusScriptAttached object scalus.cardano.txbuilder.ScriptSource.PlutusScriptAttached enum scalus.cardano.txbuilder.SomeBuildError def reason: Throwable def toString: String trait scalus.cardano.txbuilder.SpendWitness trait scalus.cardano.txbuilder.StepError def step: TransactionBuilderStep def explain: String object scalus.cardano.txbuilder.StepError case class scalus.cardano.txbuilder.StepError.InputAlreadyExists val input: TransactionInput val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.ResolvedUtxosIncoherence val input: TransactionInput val existingOutput: TransactionOutput val incoherentOutput: TransactionOutput val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.CollateralNotPubKey val utxo: Utxo val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.DatumIsMissing val utxo: Utxo val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.IncorrectDatumHash val utxo: Utxo val datum: Data val datumHash: DataHash val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.IncorrectScriptHash val script: Script val hash: ScriptHash val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.RedeemerComputationFailed val message: String val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.DatumComputationFailed val message: String val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.WrongOutputType val expectedType: WitnessKind val utxo: Utxo val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.WrongCredentialType val action: Operation val expectedType: WitnessKind val cred: Credential val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.DatumWitnessNotProvided val utxo: Utxo val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.DatumValueForUtxoWithInlineDatum val utxo: Utxo val datum: Datum val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.UnneededDeregisterWitness val stakeCredential: Credential val witness: PubKeyWitness | TwoArgumentPlutusScriptWitness | NativeScriptWitness val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.UnneededSpoVoteWitness val cred: Credential val witness: TwoArgumentPlutusScriptWitness | NativeScriptWitness val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.UnneededProposalPolicyWitness val proposal: ProposalProcedure val witness: PubKeyWitness | TwoArgumentPlutusScriptWitness | NativeScriptWitness val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.RedeemerIndexingError val redeemer: Redeemer val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.WrongNetworkId val address: Address val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.AttachedScriptNotFound val scriptHash: ScriptHash val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.ByronAddressesNotSupported val address: Address val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.ScriptResolutionError val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.FeeAlreadySet val currentFee: Long val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.ValidityStartSlotAlreadySet val slot: Long val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.ValidityEndSlotAlreadySet val slot: Long val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.DonationAlreadySet val current: Coin val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.CurrentTreasuryValueAlreadySet val current: Coin val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.UnexpectedDeferredStep val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.DeferredResolutionFailed val cause: Exception val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.StepError.UnsupportedPlutusVersion val language: Language val step: TransactionBuilderStep def explain: String case class scalus.cardano.txbuilder.ThreeArgumentPlutusScriptWitness val scriptSource: ScriptSource[PlutusScript] val redeemerBuilder: Function1[Transaction, Data] val datum: Datum def witnessKind: WitnessKind object scalus.cardano.txbuilder.ThreeArgumentPlutusScriptWitness def apply(scriptSource: ScriptSource[PlutusScript], redeemer: Data, datum: Datum): ThreeArgumentPlutusScriptWitness def attached[T](script: PlutusScript, redeemer: T, datum: Datum)(evidence$1: ToData[T]): ThreeArgumentPlutusScriptWitness def attached(script: PlutusScript, redeemerBuilder: Function1[Transaction, Data], datum: Datum): ThreeArgumentPlutusScriptWitness def reference[T](redeemer: T, datum: Datum)(evidence$1: ToData[T]): ThreeArgumentPlutusScriptWitness def reference(redeemerBuilder: Function1[Transaction, Data], datum: Datum): ThreeArgumentPlutusScriptWitness object scalus.cardano.txbuilder.TransactionBuilder val MaxBalancingIterations: Int trait scalus.cardano.txbuilder.TransactionBuilder.Operation def explain: String val Operation: Operation object scalus.cardano.txbuilder.TransactionBuilder.Operation case class scalus.cardano.txbuilder.TransactionBuilder.Operation.Minting val scriptHash: PolicyId def explain: String case class scalus.cardano.txbuilder.TransactionBuilder.Operation.CertificateOperation val cert: Certificate def explain: String case class scalus.cardano.txbuilder.TransactionBuilder.Operation.Withdraw val address: StakeAddress def explain: String case class scalus.cardano.txbuilder.TransactionBuilder.Operation.Proposing val proposal: ProposalProcedure def explain: String case class scalus.cardano.txbuilder.TransactionBuilder.Operation.Voting val voter: Voter def explain: String def totalCollateralValue(tx: Transaction, utxos: Utxos): Value case class scalus.cardano.txbuilder.TransactionBuilder.ResolvedUtxos val utxos: Utxos def addUtxo(utxo: Utxo): Option[ResolvedUtxos] def addUtxos(utxos: Seq[Utxo]): Either[Seq[Utxo], ResolvedUtxos] val ResolvedUtxos: ResolvedUtxos object scalus.cardano.txbuilder.TransactionBuilder.ResolvedUtxos val empty: ResolvedUtxos def apply(utxos: Utxos): ResolvedUtxos case class scalus.cardano.txbuilder.TransactionBuilder.Context val transaction: Transaction val redeemers: Seq[DetachedRedeemer] val network: Network val expectedSigners: Set[AddrKeyHash] val resolvedUtxos: ResolvedUtxos val delayedRedeemerSpecs: Seq[DelayedRedeemerSpec] val delayedDatumSpecs: Seq[DelayedDatumSpec] val collateralReturnAddress: Option[Address] val toTuple: Tuple5[Transaction, Seq[DetachedRedeemer], Network, Set[AddrKeyHash], ResolvedUtxos] def replaceRedeemers(newRedeemers: Seq[DetachedRedeemer]): Context def addDelayedRedeemer(spec: DelayedRedeemerSpec): Context def addDelayedDatum(spec: DelayedDatumSpec): Context def ensureMinAdaAll(protocolParams: ProtocolParams): Context def balance(diffHandler: DiffHandler, protocolParams: ProtocolParams, evaluator: PlutusScriptEvaluator, debugScripts: Map[ScriptHash, DebugScript]): Either[TxBalancingError, Context] def getUtxos: Utxos def validate(validators: Seq[Validator], protocolParams: ProtocolParams, slot: Long, certState: CertState): Either[TransactionException, Context] def balanceContext(protocolParams: ProtocolParams, diffHandler: DiffHandler, evaluator: PlutusScriptEvaluator, debugScripts: Map[ScriptHash, DebugScript]): Either[SomeBuildError, Context] def validateContext(validators: Seq[Validator], protocolParams: ProtocolParams, slot: Long, certState: CertState): Either[SomeBuildError, Context] def finalizeContext(protocolParams: ProtocolParams, diffHandler: DiffHandler, evaluator: PlutusScriptEvaluator, validators: Seq[Validator], slot: Long, certState: CertState, debugScripts: Map[ScriptHash, DebugScript]): Either[SomeBuildError, Context] val Context: Context object scalus.cardano.txbuilder.TransactionBuilder.Context def empty(networkId: Network): Context val unsafeCtxBodyL: Lens[Context, TransactionBody] val unsafeCtxWitnessL: Lens[Context, TransactionWitnessSet] val unsafeCtxTxOutputsL: Lens[Context, IndexedSeq[Sized[TransactionOutput]]] val unsafeCtxTxReferenceInputsL: Lens[Context, TaggedSortedSet[TransactionInput]] def ensureMinAda(candidateOutput: TransactionOutput, params: ProtocolParams): TransactionOutput def build(network: Network, steps: Seq[TransactionBuilderStep]): Either[SomeBuildError, Context] def modify(ctx: Context, steps: Seq[TransactionBuilderStep]): Either[SomeBuildError, Context] def replaceDelayedRedeemers(redeemers: Seq[DetachedRedeemer], specs: Seq[DelayedRedeemerSpec], sortedTx: Transaction): Either[StepError, Seq[DetachedRedeemer]] def replaceDelayedDatums(tx: Transaction, specs: Seq[DelayedDatumSpec]): Either[StepError, Transaction] def ensureCollateralReturn(tx: Transaction, resolvedUtxos: Utxos, collateralReturnAddress: Option[Address], protocolParams: ProtocolParams): Either[TxBalancingError, Transaction] def calculateChangeValue(tx: Transaction, utxo: Utxos, params: ProtocolParams): Value def balanceFeeAndChange(initial: Transaction, changeOutputIdx: Int, protocolParams: ProtocolParams, resolvedUtxo: Utxos, evaluator: PlutusScriptEvaluator, debugScripts: Map[ScriptHash, DebugScript]): Either[TxBalancingError, Transaction] def balanceFeeAndChangeWithTokens(initial: Transaction, diffHandler: Function2[Value, Transaction, Either[TxBalancingError, Transaction]], protocolParams: ProtocolParams, resolvedUtxo: Utxos, evaluator: PlutusScriptEvaluator, debugScripts: Map[ScriptHash, DebugScript]): Either[TxBalancingError, Transaction] def computeScriptsWitness(utxos: Utxos, evaluator: PlutusScriptEvaluator, protocolParams: ProtocolParams, debugScripts: Map[ScriptHash, DebugScript])(tx: Transaction): Either[TxBalancingError, Transaction] trait scalus.cardano.txbuilder.TransactionBuilderStep object scalus.cardano.txbuilder.TransactionBuilderStep case class scalus.cardano.txbuilder.TransactionBuilderStep.Spend val utxo: Utxo val witness: SpendWitness case class scalus.cardano.txbuilder.TransactionBuilderStep.Send val output: TransactionOutput case class scalus.cardano.txbuilder.TransactionBuilderStep.SendWithDatumBuilder val output: TransactionOutput val datumBuilder: Function1[Transaction, Data] case class scalus.cardano.txbuilder.TransactionBuilderStep.Mint val scriptHash: ScriptHash val assetName: AssetName val amount: Long val witness: NativeScriptWitness | TwoArgumentPlutusScriptWitness case class scalus.cardano.txbuilder.TransactionBuilderStep.ReferenceOutput val utxo: Utxo case class scalus.cardano.txbuilder.TransactionBuilderStep.Fee val fee: Coin case class scalus.cardano.txbuilder.TransactionBuilderStep.ValidityStartSlot val slot: Long case class scalus.cardano.txbuilder.TransactionBuilderStep.ValidityEndSlot val slot: Long case class scalus.cardano.txbuilder.TransactionBuilderStep.AddCollateral val utxo: Utxo case class scalus.cardano.txbuilder.TransactionBuilderStep.SetCollateralReturn val returnAddress: Address case class scalus.cardano.txbuilder.TransactionBuilderStep.ModifyAuxiliaryData val f: Function1[Option[AuxiliaryData], Option[AuxiliaryData]] case class scalus.cardano.txbuilder.TransactionBuilderStep.IssueCertificate val cert: Certificate val witness: PubKeyWitness | NativeScriptWitness | TwoArgumentPlutusScriptWitness case class scalus.cardano.txbuilder.TransactionBuilderStep.WithdrawRewards val stakeCredential: Credential val amount: Coin val witness: PubKeyWitness | NativeScriptWitness | TwoArgumentPlutusScriptWitness case class scalus.cardano.txbuilder.TransactionBuilderStep.SubmitProposal val proposal: ProposalProcedure val witness: PubKeyWitness | NativeScriptWitness | TwoArgumentPlutusScriptWitness case class scalus.cardano.txbuilder.TransactionBuilderStep.SubmitVotingProcedure val voter: Voter val votes: Map[GovActionId, VotingProcedure] val witness: PubKeyWitness | NativeScriptWitness | TwoArgumentPlutusScriptWitness case class scalus.cardano.txbuilder.TransactionBuilderStep.RequireSignature val signer: AddrKeyHash case class scalus.cardano.txbuilder.TransactionBuilderStep.Deferred val query: UtxoQuery val resolve: Function1[Utxos, Seq[TransactionBuilderStep]] case class scalus.cardano.txbuilder.TransactionBuilderStep.Donate val amount: Coin case class scalus.cardano.txbuilder.TransactionBuilderStep.SetCurrentTreasuryValue val value: Coin object scalus.cardano.txbuilder.TransactionConversion def toEditableTransaction(tx: Transaction): EditableTransaction def toEditableTransactionSafe(tx: Transaction): Either[Redeemer, EditableTransaction] def fromEditableTransactionSafe(editable: EditableTransaction): Either[DetachedRedeemer, Transaction] def fromEditableTransaction(editable: EditableTransaction): Transaction object scalus.cardano.txbuilder.TransactionEditor def editTransaction(f: Function1[Transaction, Transaction])(tx: Transaction): Transaction def editTransactionSafe(f: Function1[Transaction, Transaction])(tx: Transaction): Either[Redeemer, Transaction] class scalus.cardano.txbuilder.TransactionSigner def sign(unsignedTransaction: Transaction): Transaction object scalus.cardano.txbuilder.TransactionSigner def apply(keyPairs: Set[Tuple2[ByteString, ByteString]]): TransactionSigner class scalus.cardano.txbuilder.TransactionStepsProcessor def applySteps(steps: Seq[TransactionBuilderStep]): Tuple2[Context, Result[Unit]] def useCertificateWitness(cert: Certificate, witness: |[|[PubKeyWitness.type, TwoArgumentPlutusScriptWitness], NativeScriptWitness], step: TransactionBuilderStep): Result[Unit] def useNonSpendingWitness(credAction: Operation, cred: Credential, witness: |[|[PubKeyWitness.type, TwoArgumentPlutusScriptWitness], NativeScriptWitness], step: TransactionBuilderStep): Result[Unit] def assertCredentialMatchesWitness(action: Operation, witness: |[|[PubKeyWitness.type, NativeScriptWitness], TwoArgumentPlutusScriptWitness], cred: Credential, step: TransactionBuilderStep): Result[Unit] case class scalus.cardano.txbuilder.TwoArgumentPlutusScriptWitness val scriptSource: ScriptSource[PlutusScript] val redeemerBuilder: Function1[Transaction, Data] def witnessKind: WitnessKind object scalus.cardano.txbuilder.TwoArgumentPlutusScriptWitness def apply(scriptSource: ScriptSource[PlutusScript], redeemer: Data): TwoArgumentPlutusScriptWitness def attached[T](script: PlutusScript, redeemer: T)(evidence$1: ToData[T]): TwoArgumentPlutusScriptWitness def attached(script: PlutusScript, redeemerBuilder: Function1[Transaction, Data]): TwoArgumentPlutusScriptWitness def reference[T](redeemer: T)(evidence$1: ToData[T]): TwoArgumentPlutusScriptWitness def reference(redeemerBuilder: Function1[Transaction, Data]): TwoArgumentPlutusScriptWitness enum scalus.cardano.txbuilder.TxBalancingError case class scalus.cardano.txbuilder.TxBuilder val env: CardanoInfo val context: Context val evaluator: PlutusScriptEvaluator val steps: Seq[TransactionBuilderStep] val attachedData: Map[DataHash, Data] val changeOutputIndex: Option[Int] val debugScripts: Map[ScriptHash, DebugScript] def spend(utxo: Utxo, witness: SpendWitness): TxBuilder def spend(utxo: Utxo): TxBuilder def spend(utxos: Utxos): TxBuilder def spend[T](utxo: Utxo, redeemer: T)(evidence$1: ToData[T]): TxBuilder def spend(utxo: Utxo, redeemerBuilder: Function1[Transaction, Data]): TxBuilder def spend(utxo: Utxo, redeemerBuilder: Function1[Transaction, Data], script: PlutusScript): TxBuilder def spend[T](utxo: Utxo, redeemer: T, script: PlutusScript)(evidence$1: ToData[T]): TxBuilder def spend[T](utxo: Utxo, redeemer: T, compiled: CompiledPlutus[_ >: Nothing <: Any])(evidence$1: ToData[T]): TxBuilder def spend(utxo: Utxo, redeemerBuilder: Function1[Transaction, Data], compiled: CompiledPlutus[_ >: Nothing <: Any]): TxBuilder def references(utxo: Utxo, rest: Utxo*): TxBuilder def references(utxo: Utxo, compiled: CompiledPlutus[_ >: Nothing <: Any]): TxBuilder def collaterals(utxo: Utxo, rest: Utxo*): TxBuilder def collaterals(utxos: Utxos): TxBuilder def output(output: TransactionOutput): TxBuilder def payTo(address: Address, value: Value): TxBuilder def payTo[T](address: Address, value: Value, datum: T)(evidence$1: ToData[T]): TxBuilder def payTo(address: Address, value: Value, datumHash: DataHash): TxBuilder def payTo(compiled: CompiledPlutus[_ >: Nothing <: Any], value: Value): TxBuilder def payTo[T](compiled: CompiledPlutus[_ >: Nothing <: Any], value: Value, datum: T)(evidence$1: ToData[T]): TxBuilder def payTo(compiled: CompiledPlutus[_ >: Nothing <: Any], value: Value, datumHash: DataHash): TxBuilder def payTo(address: Address, value: Value, datumBuilder: Function1[Transaction, Data]): TxBuilder def payTo(compiled: CompiledPlutus[_ >: Nothing <: Any], value: Value, datumBuilder: Function1[Transaction, Data]): TxBuilder def changeTo(output: TransactionOutput): TxBuilder def attach(datum: Data): TxBuilder def metadata(auxiliaryData: AuxiliaryData): TxBuilder def mint[T](policyId: PolicyId, assets: collection.Map[AssetName, Long], redeemer: T)(evidence$1: ToData[T]): TxBuilder def mint[T](script: PlutusScript, assets: collection.Map[AssetName, Long], redeemer: T)(evidence$1: ToData[T]): TxBuilder def mint[T](compiled: CompiledPlutus[_ >: Nothing <: Any], assets: collection.Map[AssetName, Long], redeemer: T)(evidence$1: ToData[T]): TxBuilder def mint(compiled: CompiledPlutus[_ >: Nothing <: Any], assets: collection.Map[AssetName, Long], redeemerBuilder: Function1[Transaction, Data]): TxBuilder def mint(script: PlutusScript, assets: collection.Map[AssetName, Long], redeemerBuilder: Function1[Transaction, Data]): TxBuilder def mint(policyId: PolicyId, assets: collection.Map[AssetName, Long], redeemerBuilder: Function1[Transaction, Data]): TxBuilder def mint(policyId: PolicyId, assets: collection.Map[AssetName, Long], witness: ScriptWitness): TxBuilder def registerStake(stakeAddress: StakeAddress): TxBuilder def registerStake(stakeAddress: StakeAddress, witness: ScriptWitness): TxBuilder def deregisterStake(stakeAddress: StakeAddress): TxBuilder def deregisterStake(stakeAddress: StakeAddress, refund: Coin): TxBuilder def deregisterStake(stakeAddress: StakeAddress, witness: ScriptWitness): TxBuilder def deregisterStake(stakeAddress: StakeAddress, refund: Option[Coin], witness: ScriptWitness): TxBuilder def delegateTo(stakeAddress: StakeAddress, poolId: PoolKeyHash): TxBuilder def delegateTo(stakeAddress: StakeAddress, poolId: PoolKeyHash, witness: ScriptWitness): TxBuilder def stakeAndDelegate(stakeAddress: StakeAddress, poolId: PoolKeyHash): TxBuilder def stakeAndDelegate(stakeAddress: StakeAddress, poolId: PoolKeyHash, witness: ScriptWitness): TxBuilder def withdrawRewards(stakeAddress: StakeAddress, amount: Coin): TxBuilder def withdrawRewards(stakeAddress: StakeAddress, amount: Coin, witness: ScriptWitness): TxBuilder def donateToTreasury(amount: Coin): TxBuilder def setCurrentTreasuryValue(value: Coin): TxBuilder def delegateVoteToDRep(stakeAddress: StakeAddress, drep: DRep): TxBuilder def delegateVoteToDRep(stakeAddress: StakeAddress, drep: DRep, witness: ScriptWitness): TxBuilder def registerAndDelegateVoteToDRep(stakeAddress: StakeAddress, drep: DRep): TxBuilder def registerAndDelegateVoteToDRep(stakeAddress: StakeAddress, drep: DRep, witness: ScriptWitness): TxBuilder def delegateToPoolAndDRep(stakeAddress: StakeAddress, poolId: PoolKeyHash, drep: DRep): TxBuilder def delegateToPoolAndDRep(stakeAddress: StakeAddress, poolId: PoolKeyHash, drep: DRep, witness: ScriptWitness): TxBuilder def registerAndDelegateToPoolAndDRep(stakeAddress: StakeAddress, poolId: PoolKeyHash, drep: DRep): TxBuilder def registerAndDelegateToPoolAndDRep(stakeAddress: StakeAddress, poolId: PoolKeyHash, drep: DRep, witness: ScriptWitness): TxBuilder def registerDRep(drepCredential: Credential, anchor: Option[Anchor]): TxBuilder def registerDRep(drepCredential: Credential, anchor: Option[Anchor], witness: ScriptWitness): TxBuilder def unregisterDRep(drepCredential: Credential, refund: Coin): TxBuilder def unregisterDRep(drepCredential: Credential, refund: Coin, witness: ScriptWitness): TxBuilder def updateDRep(drepCredential: Credential, anchor: Option[Anchor]): TxBuilder def updateDRep(drepCredential: Credential, anchor: Option[Anchor], witness: ScriptWitness): TxBuilder def minFee(minFee: Coin): TxBuilder def validDuring(interval: ValidityInterval): TxBuilder def validFrom(from: Instant): TxBuilder def validTo(to: Instant): TxBuilder def build(diffHandler: DiffHandler): TxBuilder def build(changeTo: Address): TxBuilder def draft: Transaction def sign(signer: TransactionSigner): TxBuilder def transaction: Transaction def complete(reader: BlockchainReader, sponsor: Address): Future[TxBuilder] def complete(availableUtxos: Utxos, sponsor: Address): TxBuilder def withDebugScript(scriptHash: ScriptHash, debugScript: DebugScript): TxBuilder def withDebugScript(compiled: CompiledPlutus[_ >: Nothing <: Any]): TxBuilder def requireSignature(signer: AddrKeyHash): TxBuilder def requireSignatures(signers: Set[AddrKeyHash]): TxBuilder def addSteps(s: TransactionBuilderStep*): TxBuilder object scalus.cardano.txbuilder.TxBuilder def apply(env: CardanoInfo, evaluator: PlutusScriptEvaluator): TxBuilder def apply(env: CardanoInfo): TxBuilder def withConstMaxBudgetEvaluator(env: CardanoInfo): TxBuilder class scalus.cardano.txbuilder.TxBuilderException object scalus.cardano.txbuilder.TxBuilderException case class scalus.cardano.txbuilder.TxBuilderException.BuildStepException val stepError: StepError val context: Context def step: TransactionBuilderStep case class scalus.cardano.txbuilder.TxBuilderException.RedeemerIndexingException val error: RedeemerIndexingInternalError val context: Context case class scalus.cardano.txbuilder.TxBuilderException.BalancingException val error: TxBalancingError val context: Context def isScriptFailure: Boolean def scriptLogs: Option[Seq[String]] case class scalus.cardano.txbuilder.TxBuilderException.LedgerValidationException val error: TransactionException val context: Context case class scalus.cardano.txbuilder.TxBuilderException.InsufficientAdaException val required: Coin val available: Coin val sponsorAddress: Address case class scalus.cardano.txbuilder.TxBuilderException.InsufficientTokensException val policyId: PolicyId val assetName: AssetName val required: Long val available: Long val sponsorAddress: Address case class scalus.cardano.txbuilder.TxBuilderException.CollateralUnavailableException val required: Coin val bestAvailable: Coin val maxCollateralInputs: Long val sponsorAddress: Address case class scalus.cardano.txbuilder.TxBuilderException.DeferredResolutionException val stepError: DeferredResolutionFailed def step: TransactionBuilderStep case class scalus.cardano.txbuilder.TxBuilderException.UtxoQueryException val error: UtxoQueryError val message: String def fromBuildError(error: SomeBuildError): TxBuilderException class scalus.cardano.txbuilder.UtxoPool def remainingForInputs: Utxos def inputs: Utxos def collateral: Utxos def withInputs(additional: Utxos): UtxoPool def withCollateral(additional: Utxos): UtxoPool def replaceCollateral(newCollateral: Utxos): UtxoPool def totalAvailableAda: Coin def totalAvailableTokens(policyId: PolicyId, assetName: AssetName): Long def selectForValue(required: Value): Utxos def selectForCollateral(requiredAmount: Coin, protocolParams: ProtocolParams): Utxos object scalus.cardano.txbuilder.UtxoPool def apply(available: Utxos): UtxoPool trait scalus.cardano.txbuilder.Witness def witnessKind: WitnessKind enum scalus.cardano.txbuilder.WitnessKind case class scalus.cardano.ledger.Anchor val url: String val dataHash: DataHash def toString: String object scalus.cardano.ledger.Anchor given given_Ordering_Anchor: Ordering[Anchor] given given_Pretty_Anchor: given_Pretty_Anchor object scalus.cardano.ledger.Anchor.given_Pretty_Anchor def pretty(a: Anchor, style: Style): Doc case class scalus.cardano.ledger.AssetName val bytes: ByteString def toString: String object scalus.cardano.ledger.AssetName given given_Ordering_AssetName: Ordering[AssetName] val empty: AssetName def fromHex(hex: String): AssetName def fromString(str: String): AssetName given given_Pretty_AssetName: given_Pretty_AssetName object scalus.cardano.ledger.AssetName.given_Pretty_AssetName def pretty(a: AssetName, style: Style): Doc enum scalus.cardano.ledger.AuxiliaryData def getMetadata: Map[Word64, Metadatum] def getNativeScripts: IndexedSeq[Timelock] def getPlutusV1Scripts: IndexedSeq[ByteString] def getPlutusV2Scripts: IndexedSeq[ByteString] def getPlutusV3Scripts: IndexedSeq[ByteString] def getPlutusScripts: IndexedSeq[ByteString] def getAllScripts: IndexedSeq[|[Timelock, ByteString]] object scalus.cardano.ledger.AuxiliaryData enum scalus.cardano.ledger.AuxiliaryData.Metadata val metadata: Map[Word64, Metadatum] enum scalus.cardano.ledger.AuxiliaryData.MetadataWithScripts val metadata: Map[Word64, Metadatum] val nativeScripts: IndexedSeq[Timelock] enum scalus.cardano.ledger.AuxiliaryData.AlonzoFormat val metadata: Option[Map[Word64, Metadatum]] val nativeScripts: IndexedSeq[Timelock] val plutusV1Scripts: IndexedSeq[ByteString] val plutusV2Scripts: IndexedSeq[ByteString] val plutusV3Scripts: IndexedSeq[ByteString] given given_Encoder_AuxiliaryData: given_Encoder_AuxiliaryData object scalus.cardano.ledger.AuxiliaryData.given_Encoder_AuxiliaryData def write(w: Writer, value: AuxiliaryData): Writer given given_Decoder_AuxiliaryData: given_Decoder_AuxiliaryData object scalus.cardano.ledger.AuxiliaryData.given_Decoder_AuxiliaryData def read(r: Reader): AuxiliaryData object scalus.cardano.ledger.Base58 def encode(input: Array[Byte]): String def decode(input: String): Array[Byte] object scalus.cardano.ledger.Bech32 case class scalus.cardano.ledger.Bech32.Bech32Decoded val hrp: String val data: Array[Byte] val SEP: '1' def polymod(values: Array[Int5]): Int def hrpExpand(s: String): Array[Int5] def verifyCheckSum(hrp: String, data: Array[Int5]): Boolean def createChecksum(hrp: String, data: Array[Int5]): Array[Int5] def decode(bech32: String): Bech32Decoded def decodeTo5Bit(bech32: String): Tuple2[String, Array[Int5]] def encode(hrp: String, data: Array[Byte]): String def encodeFrom5Bit(hrp: String, data: Array[Int5]): String def to5Bit(input: Array[Byte]): Array[Int5] def from5Bit(input: Array[Int5]): Array[Byte] trait scalus.cardano.ledger.Blake2b_224 trait scalus.cardano.ledger.Blake2b_256 case class scalus.cardano.ledger.Block val header: BlockHeader val transactionBodies: IndexedSeq[KeepRaw[TransactionBody]] val transactionWitnessSets: IndexedSeq[KeepRaw[TransactionWitnessSet]] val auxiliaryDataSet: Map[Int, KeepRaw[AuxiliaryData]] val invalidTransactions: IndexedSeq[Int] def blockNumber: Long def slot: Long def hash: BlockHash def txCount: Int def invalidTxCount: Int def validTxCount: Int def isEmpty: Boolean def transactions(using x$1: OriginalCborByteArray): Seq[Transaction] object scalus.cardano.ledger.Block given given_Encoder_Block: Encoder[Block] given decoder(using x$1: OriginalCborByteArray): Decoder[Block] case class scalus.cardano.ledger.BlockFile val era: Int val block: Block object scalus.cardano.ledger.BlockFile given given_Encoder_BlockFile: Encoder[BlockFile] given decoder(using x$1: OriginalCborByteArray): Decoder[BlockFile] def fromCborArray(bytes: Array[Byte]): BlockFile case class scalus.cardano.ledger.BlockHeader val headerBody: BlockHeaderBody val bodySignature: ByteString def blockNumber: Long def slot: Long def prevHash: Option[BlockHash] case class scalus.cardano.ledger.BlockHeaderBody val blockNumber: Long val slot: Long val prevHash: Option[BlockHash] val issuerVkey: ByteString val vrfVkey: ByteString val vrfResult: VrfCert val blockBodySize: Long val blockBodyHash: BlockHash val operationalCert: OperationalCert val protocolVersion: ProtocolVersion case class scalus.cardano.ledger.BootstrapWitness val publicKey: ByteString val signature: ByteString val chainCode: ByteString val attributes: ByteString val addrKeyHash: AddrKeyHash object scalus.cardano.ledger.BootstrapWitness given given_Ordering_BootstrapWitness: Ordering[BootstrapWitness] given given_Pretty_BootstrapWitness: given_Pretty_BootstrapWitness object scalus.cardano.ledger.BootstrapWitness.given_Pretty_BootstrapWitness def pretty(a: BootstrapWitness, style: Style): Doc object scalus.cardano.ledger.Builtins val Batches: Batches object scalus.cardano.ledger.Builtins.Batches val batch1: Set[DefaultFun] val batch2: Set[DefaultFun] val batch3: Set[DefaultFun] val batch4a: Set[DefaultFun] val batch4b: Set[DefaultFun] val batch4: Set[DefaultFun] val batch5: Set[DefaultFun] val batch6: Set[DefaultFun] def findBuiltinsIntroducedIn(language: Language, majorProtocolVersion: MajorProtocolVersion): Set[DefaultFun] case class scalus.cardano.ledger.CardanoInfo val protocolParams: ProtocolParams val network: Network val slotConfig: SlotConfig def majorProtocolVersion: MajorProtocolVersion def era: Era object scalus.cardano.ledger.CardanoInfo val mainnet: CardanoInfo val preprod: CardanoInfo val preview: CardanoInfo def verify(expected: CardanoInfo, actual: CardanoInfo): Either[Seq[ProtocolParams.ParamDiff], CardanoInfo] enum scalus.cardano.ledger.Certificate def lookupRegStakeTxCert: Option[Credential] def lookupUnRegStakeTxCert: Option[Credential] def keyHashes: Set[|[AddrKeyHash, PoolKeyHash]] def scriptHashOption: Option[ScriptHash] object scalus.cardano.ledger.Certificate enum scalus.cardano.ledger.Certificate.StakeDelegation val credential: Credential val poolKeyHash: PoolKeyHash enum scalus.cardano.ledger.Certificate.PoolRegistration val operator: AddrKeyHash val vrfKeyHash: VrfKeyHash val pledge: Coin val cost: Coin val margin: UnitInterval val rewardAccount: RewardAccount val poolOwners: Set[AddrKeyHash] val relays: IndexedSeq[Relay] val poolMetadata: Option[PoolMetadata] enum scalus.cardano.ledger.Certificate.PoolRetirement val poolKeyHash: PoolKeyHash val epochNo: Long enum scalus.cardano.ledger.Certificate.RegCert val credential: Credential val coin: Option[Coin] enum scalus.cardano.ledger.Certificate.UnregCert val credential: Credential val coin: Option[Coin] enum scalus.cardano.ledger.Certificate.VoteDelegCert val credential: Credential val drep: DRep enum scalus.cardano.ledger.Certificate.StakeVoteDelegCert val credential: Credential val poolKeyHash: PoolKeyHash val drep: DRep enum scalus.cardano.ledger.Certificate.StakeRegDelegCert val credential: Credential val poolKeyHash: PoolKeyHash val coin: Coin enum scalus.cardano.ledger.Certificate.VoteRegDelegCert val credential: Credential val drep: DRep val coin: Coin enum scalus.cardano.ledger.Certificate.StakeVoteRegDelegCert val credential: Credential val poolKeyHash: PoolKeyHash val drep: DRep val coin: Coin enum scalus.cardano.ledger.Certificate.AuthCommitteeHotCert val committeeColdCredential: Credential val committeeHotCredential: Credential enum scalus.cardano.ledger.Certificate.ResignCommitteeColdCert val committeeColdCredential: Credential val anchor: Option[Anchor] enum scalus.cardano.ledger.Certificate.RegDRepCert val drepCredential: Credential val coin: Coin val anchor: Option[Anchor] enum scalus.cardano.ledger.Certificate.UnregDRepCert val drepCredential: Credential val coin: Coin enum scalus.cardano.ledger.Certificate.UpdateDRepCert val drepCredential: Credential val anchor: Option[Anchor] def shelleyTotalRefundsTxCerts(lookupStakingDeposit: Function1[Credential, Option[Coin]], params: ProtocolParams, certificates: Iterable[Certificate]): Coin def conwayDRepRefundsTxCerts(lookupDRepDeposit: Function1[Credential, Option[Coin]], certificates: Iterable[Certificate]): Coin def shelleyTotalDeposits(params: ProtocolParams, certificates: Iterable[Certificate]): Coin def conwayDRepDeposits(params: ProtocolParams, certificates: Iterable[Certificate]): Coin given given_Encoder_Certificate: given_Encoder_Certificate object scalus.cardano.ledger.Certificate.given_Encoder_Certificate def write(w: Writer, value: Certificate): Writer given given_Decoder_Certificate: given_Decoder_Certificate object scalus.cardano.ledger.Certificate.given_Decoder_Certificate def read(r: Reader): Certificate given given_Pretty_Certificate: given_Pretty_Certificate object scalus.cardano.ledger.Certificate.given_Pretty_Certificate def pretty(a: Certificate, style: Style): Doc case class scalus.cardano.ledger.Coin val value: Long def +(other: Coin): Coin def -(other: Coin): Coin def unary_-: Coin def isZero: Boolean def nonZero: Boolean def >(other: Coin): Boolean def >=(other: Coin): Boolean def <(other: Coin): Boolean def <=(other: Coin): Boolean object scalus.cardano.ledger.Coin val zero: Coin def ada(amount: Long): Coin given given_Codec_Coin: Codec[Coin] given given_CommutativeGroup_Coin: given_CommutativeGroup_Coin object scalus.cardano.ledger.Coin.given_CommutativeGroup_Coin def combine(x: Coin, y: Coin): Coin def empty: Coin def inverse(x: Coin): Coin given given_ToData_Coin: ToData[Coin] given given_FromData_Coin: FromData[Coin] given given_UpickleReadWriter_Coin: ReadWriter[Coin] given given_Pretty_Coin: given_Pretty_Coin object scalus.cardano.ledger.Coin.given_Pretty_Coin def pretty(a: Coin, style: Style): Doc case class scalus.cardano.ledger.Constitution val anchor: Anchor val scriptHash: Option[ScriptHash] case class scalus.cardano.ledger.CostModels val models: Map[Int, IndexedSeq[Long]] def getLanguageViewEncoding: Array[Byte] object scalus.cardano.ledger.CostModels val cardanoCliReadWriter: ReadWriter[CostModels] given given_ToData_CostModels: ToData[CostModels] given given_FromData_CostModels: FromData[CostModels] enum scalus.cardano.ledger.Credential def isKeyHash: Boolean def isScriptHash: Boolean def scriptHashOption: Option[scalus.cardano.ledger.ScriptHash] def keyHashOption: Option[AddrKeyHash] object scalus.cardano.ledger.Credential enum scalus.cardano.ledger.Credential.KeyHash val keyHash: AddrKeyHash enum scalus.cardano.ledger.Credential.ScriptHash val scriptHash: ScriptHash given given_Pretty_Credential: given_Pretty_Credential object scalus.cardano.ledger.Credential.given_Pretty_Credential def pretty(a: Credential, style: Style): Doc enum scalus.cardano.ledger.DRep object scalus.cardano.ledger.DRep enum scalus.cardano.ledger.DRep.KeyHash val keyHash: AddrKeyHash enum scalus.cardano.ledger.DRep.ScriptHash val scriptHash: ScriptHash val AlwaysAbstain: DRep val AlwaysNoConfidence: DRep given given_Encoder_DRep: given_Encoder_DRep object scalus.cardano.ledger.DRep.given_Encoder_DRep def write(w: Writer, value: DRep): Writer given given_Decoder_DRep: given_Decoder_DRep object scalus.cardano.ledger.DRep.given_Decoder_DRep def read(r: Reader): DRep given given_Pretty_DRep: given_Pretty_DRep object scalus.cardano.ledger.DRep.given_Pretty_DRep def pretty(a: DRep, style: Style): Doc case class scalus.cardano.ledger.DRepVotingThresholds val motionNoConfidence: UnitInterval val committeeNormal: UnitInterval val committeeNoConfidence: UnitInterval val updateToConstitution: UnitInterval val hardForkInitiation: UnitInterval val ppNetworkGroup: UnitInterval val ppEconomicGroup: UnitInterval val ppTechnicalGroup: UnitInterval val ppGovGroup: UnitInterval val treasuryWithdrawal: UnitInterval object scalus.cardano.ledger.DRepVotingThresholds given given_Encoder_DRepVotingThresholds: Encoder[DRepVotingThresholds] given given_Decoder_DRepVotingThresholds: Decoder[DRepVotingThresholds] given given_ToData_DRepVotingThresholds: ToData[DRepVotingThresholds] given given_FromData_DRepVotingThresholds: FromData[DRepVotingThresholds] enum scalus.cardano.ledger.DatumOption def contentEquals(other: DatumOption): Boolean def dataHash: DataHash def dataHashOption: Option[DataHash] def dataOption: Option[Data] object scalus.cardano.ledger.DatumOption enum scalus.cardano.ledger.DatumOption.Hash val hash: DataHash enum scalus.cardano.ledger.DatumOption.Inline val data: Data given given_Pretty_DatumOption: given_Pretty_DatumOption object scalus.cardano.ledger.DatumOption.given_Pretty_DatumOption def pretty(a: DatumOption, style: Style): Doc given given_Encoder_DatumOption: given_Encoder_DatumOption object scalus.cardano.ledger.DatumOption.given_Encoder_DatumOption def write(w: Writer, value: DatumOption): Writer given given_Decoder_DatumOption: given_Decoder_DatumOption object scalus.cardano.ledger.DatumOption.given_Decoder_DatumOption def read(r: Reader): DatumOption enum scalus.cardano.ledger.DumpArtifact enum scalus.cardano.ledger.Era val value: Int case class scalus.cardano.ledger.EvaluatorReportConfig val enabled: Boolean val outputDir: String val artifacts: Set[DumpArtifact] val profile: ProfileLevel val profileOutputs: Seq[ProfileOutput] val profileThreshold: Double val maxRows: Int def dumps(artifact: DumpArtifact): Boolean def effectiveProfileOutputs: Seq[ProfileOutput] object scalus.cardano.ledger.EvaluatorReportConfig val disabled: EvaluatorReportConfig def fromLegacyBoolean(debugDumpFilesForTesting: Boolean): EvaluatorReportConfig def fromEnv(base: EvaluatorReportConfig, env: Map[String, String]): EvaluatorReportConfig case class scalus.cardano.ledger.ExUnitPrices val priceMemory: NonNegativeInterval val priceSteps: NonNegativeInterval object scalus.cardano.ledger.ExUnitPrices given given_ToData_ExUnitPrices: ToData[ExUnitPrices] given given_FromData_ExUnitPrices: FromData[ExUnitPrices] case class scalus.cardano.ledger.ExUnits val memory: Long val steps: Long def showJson: String def +(other: ExUnits): ExUnits def fee(prices: ExUnitPrices): Coin def fee(using info: CardanoInfo): Coin object scalus.cardano.ledger.ExUnits val zero: ExUnits val enormous: ExUnits given given_Encoder_ExUnits: Encoder[ExUnits] given given_Decoder_ExUnits: Decoder[ExUnits] given given_Ordering_ExUnits: Ordering[ExUnits] given given_Group_ExUnits: given_Group_ExUnits object scalus.cardano.ledger.ExUnits.given_Group_ExUnits def combine(x: ExUnits, y: ExUnits): ExUnits def empty: ExUnits def inverse(x: ExUnits): ExUnits given given_ToData_ExUnits: ToData[ExUnits] given given_FromData_ExUnits: FromData[ExUnits] given given_Pretty_ExUnits: given_Pretty_ExUnits object scalus.cardano.ledger.ExUnits.given_Pretty_ExUnits def pretty(a: ExUnits, style: Style): Doc enum scalus.cardano.ledger.GovAction def scriptHashOption: Option[ScriptHash] object scalus.cardano.ledger.GovAction enum scalus.cardano.ledger.GovAction.ParameterChange val prevActionId: Option[GovActionId] val protocolParamUpdate: ProtocolParamUpdate val policyHash: Option[PolicyHash] enum scalus.cardano.ledger.GovAction.HardForkInitiation val prevActionId: Option[GovActionId] val protocolVersion: ProtocolVersion enum scalus.cardano.ledger.GovAction.TreasuryWithdrawals val withdrawals: Map[RewardAccount, Coin] val policyHash: Option[PolicyHash] enum scalus.cardano.ledger.GovAction.NoConfidence val prevActionId: Option[GovActionId] enum scalus.cardano.ledger.GovAction.UpdateCommittee val prevActionId: Option[GovActionId] val removedMembers: Set[Credential] val addedMembers: Map[Credential, Long] val threshold: UnitInterval enum scalus.cardano.ledger.GovAction.NewConstitution val prevActionId: Option[GovActionId] val constitution: Constitution val InfoAction: GovAction given given_Ordering_GovAction: Ordering[GovAction] given given_Encoder_GovAction: Encoder[GovAction] given given_Decoder_GovAction: Decoder[GovAction] case class scalus.cardano.ledger.GovActionId val transactionId: TransactionHash val govActionIndex: Int object scalus.cardano.ledger.GovActionId given given_Ordering_GovActionId: given_Ordering_GovActionId object scalus.cardano.ledger.GovActionId.given_Ordering_GovActionId def compare(x: GovActionId, y: GovActionId): Int trait scalus.cardano.ledger.HashConstructors def fromByteString(bytes: ByteString): HashType def fromHex(hex: String): HashType def fromArray(bytes: Array[Byte]): HashType object scalus.cardano.ledger.HashPurpose trait scalus.cardano.ledger.HashPurpose.KeyHash trait scalus.cardano.ledger.HashPurpose.ScriptHash trait scalus.cardano.ledger.HashPurpose.DataHash trait scalus.cardano.ledger.HashPurpose.ScriptDataHash trait scalus.cardano.ledger.HashPurpose.MetadataHash trait scalus.cardano.ledger.HashPurpose.AuxiliaryDataHash trait scalus.cardano.ledger.HashPurpose.VrfKeyHash trait scalus.cardano.ledger.HashPurpose.PoolKeyHash trait scalus.cardano.ledger.HashPurpose.StakeKeyHash trait scalus.cardano.ledger.HashPurpose.TransactionHash trait scalus.cardano.ledger.HashPurpose.BlockHash case class scalus.cardano.ledger.HashSize val size: Int object scalus.cardano.ledger.HashSize given given_HashSize_Blake2b_224: HashSize[Blake2b_224] given given_HashSize_Blake2b_256: HashSize[Blake2b_256] class scalus.cardano.ledger.KeepRaw val value: A val raw: Array[Byte] def hashCode: Int def equals(obj: Any): Boolean def toString: String object scalus.cardano.ledger.KeepRaw def unapply[A](keepRaw: KeepRaw[A]): Some[Tuple2[A, Array[Byte]]] def lens[A]()(evidence$1: Encoder[A]): Lens[KeepRaw[A], A] def unsafe[A](value: A, raw: => Array[Byte]): KeepRaw[A] def apply[A](value: A)(evidence$1: Encoder[A]): KeepRaw[A] given given_Decoder_KeepRaw[A](evidence$1: Decoder[A], x$1: OriginalCborByteArray): Decoder[KeepRaw[A]] given given_Encoder_KeepRaw[A](evidence$1: Encoder[A]): Encoder[KeepRaw[A]] given given_Pretty_KeepRaw[A](using p: Pretty[A]): Pretty[KeepRaw[A]] object scalus.cardano.ledger.KeepRawBytes def unapply[A](keepRaw: KeepRaw[A]): Some[Array[Byte]] object scalus.cardano.ledger.KeepRawValue def unapply[A](keepRaw: KeepRaw[A]): Some[A] enum scalus.cardano.ledger.Language def languageId: Int object scalus.cardano.ledger.Language val PlutusV1: Language val PlutusV2: Language val PlutusV3: Language val PlutusV4: Language def fromId(id: Int): Language def show(lang: Language): String def introducedInVersion(lang: Language): MajorProtocolVersion given given_Encoder_Language: Encoder[Language] given given_Decoder_Language: Decoder[Language] given given_Ordering_Language: Ordering[Language] given given_Pretty_Language: given_Pretty_Language object scalus.cardano.ledger.Language.given_Pretty_Language def pretty(a: Language, style: Style): Doc object scalus.cardano.ledger.LedgerToPlutusTranslation def getCredential(cred: Credential): v1.Credential def getStakingCredential(cred: Credential): v1.StakingCredential def getRewardAccount(rewardAccount: RewardAccount): v1.Credential def getAddress(address: Address): v1.Address def getTxOutRefV1(input: TransactionInput): v1.TxOutRef def getTxOutRefV2(input: TransactionInput): v2.TxOutRef def getTxOutRefV3(input: TransactionInput): v3.TxOutRef def getTxInInfoV1(input: TransactionInput, utxos: Map[TransactionInput, TransactionOutput]): v1.TxInInfo def getTxInInfoV2(input: TransactionInput, utxos: Map[TransactionInput, TransactionOutput]): v2.TxInInfo def getValue(value: Value): v1.Value def getMintValueV1V2(mint: Option[Mint]): v1.Value def getMintValueV3(mint: Option[Mint]): v1.Value def getTxOutV1(output: Sized[TransactionOutput]): v1.TxOut def getTxOutV2(output: Sized[TransactionOutput]): v2.TxOut def getInterval(validityStartSlot: Option[Long], ttl: Option[Long], slotConfig: SlotConfig, protocolVersion: MajorProtocolVersion): v1.Interval def getWithdrawals(withdrawals: Option[Withdrawals]): scalus.cardano.onchain.plutus.prelude.List[Tuple2[v1.StakingCredential, BigInt]] def getDCert(cert: Certificate): v1.DCert def getTxCertV3(cert: Certificate): v3.TxCert def getTxInfoV1(tx: Transaction, utxos: Map[TransactionInput, TransactionOutput], slotConfig: SlotConfig, protocolVersion: MajorProtocolVersion): v1.TxInfo def getTxInfoV2(tx: Transaction, utxos: Map[TransactionInput, TransactionOutput], slotConfig: SlotConfig, protocolVersion: MajorProtocolVersion): v2.TxInfo def getTxInInfoV3(input: TransactionInput, utxos: Map[TransactionInput, TransactionOutput]): v3.TxInInfo def getTxInfoV3(tx: Transaction, utxos: Map[TransactionInput, TransactionOutput], slotConfig: SlotConfig, protocolVersion: MajorProtocolVersion): v3.TxInfo def getScriptPurposeV1(tx: Transaction, redeemer: Redeemer): v1.ScriptPurpose def getScriptPurposeV2(tx: Transaction, redeemer: Redeemer): v1.ScriptPurpose def getScriptPurposeV3(tx: Transaction, redeemer: Redeemer): v3.ScriptPurpose def getScriptInfoV3(tx: Transaction, redeemer: Redeemer, datum: Option[Data]): v3.ScriptInfo def getProposalProcedureV3(proposal: ProposalProcedure): v3.ProposalProcedure def getGovernanceActionV3(action: GovAction): v3.GovernanceAction def getProtocolVersion(version: ProtocolVersion): v3.ProtocolVersion def getGovActionId(id: GovActionId): v3.GovernanceActionId def getVoterV3(voter: Voter): v3.Voter def getVotingProcedures(votingProcs: Option[VotingProcedures]): SortedMap[v3.Voter, SortedMap[GovernanceActionId, v3.Vote]] def getVoteV3(procedure: VotingProcedure): v3.Vote def getScriptContextV1(redeemer: Redeemer, tx: Transaction, utxos: Map[TransactionInput, TransactionOutput], slotConfig: SlotConfig, protocolVersion: MajorProtocolVersion): v1.ScriptContext def getScriptContextV2(redeemer: Redeemer, tx: Transaction, utxos: Map[TransactionInput, TransactionOutput], slotConfig: SlotConfig, protocolVersion: MajorProtocolVersion): v2.ScriptContext def getScriptContextV3(redeemer: Redeemer, datum: Option[Data], tx: Transaction, utxos: Map[TransactionInput, TransactionOutput], slotConfig: SlotConfig, protocolVersion: MajorProtocolVersion): v3.ScriptContext case class scalus.cardano.ledger.MajorProtocolVersion val version: Int def compare(that: MajorProtocolVersion): Int object scalus.cardano.ledger.MajorProtocolVersion val shelleyPV: MajorProtocolVersion val allegraPV: MajorProtocolVersion val maryPV: MajorProtocolVersion val alonzoPV: MajorProtocolVersion val vasilPV: MajorProtocolVersion val valentinePV: MajorProtocolVersion val changPV: MajorProtocolVersion val plominPV: MajorProtocolVersion val vanRossemPV: MajorProtocolVersion val futurePV: MajorProtocolVersion val knownPVs: SortedSet[MajorProtocolVersion] trait scalus.cardano.ledger.Metadatum object scalus.cardano.ledger.Metadatum case class scalus.cardano.ledger.Metadatum.Map val entries: Map[Metadatum, Metadatum] case class scalus.cardano.ledger.Metadatum.List val items: IndexedSeq[Metadatum] case class scalus.cardano.ledger.Metadatum.Int val value: Long case class scalus.cardano.ledger.Metadatum.Bytes val value: ByteString case class scalus.cardano.ledger.Metadatum.Text val value: String given given_Encoder_Metadatum: given_Encoder_Metadatum object scalus.cardano.ledger.Metadatum.given_Encoder_Metadatum def write(w: Writer, value: Metadatum): Writer given given_Decoder_Metadatum: given_Decoder_Metadatum object scalus.cardano.ledger.Metadatum.given_Decoder_Metadatum def read(r: Reader): Metadatum case class scalus.cardano.ledger.MultiAsset val assets: SortedMap[PolicyId, SortedMap[AssetName, Long]] def isEmpty: Boolean def nonEmpty: Boolean def isPositive: Boolean def isNegative: Boolean def negativeAssets: MultiAsset def onlyPositive: MultiAsset def +(other: MultiAsset): MultiAsset def -(other: MultiAsset): MultiAsset def unary_-: MultiAsset def toString: String object scalus.cardano.ledger.MultiAsset val zero: MultiAsset val empty: MultiAsset def asset(policyId: PolicyId, assetName: AssetName, amount: Long): MultiAsset def fromPolicy(policyId: PolicyId, assets: Iterable[Tuple2[AssetName, Long]]): MultiAsset def fromAssets(assets: collection.Map[PolicyId, collection.Map[AssetName, Long]]): MultiAsset def from(assets: Iterable[Tuple3[PolicyId, AssetName, Long]]): MultiAsset def from(assets: Tuple3[PolicyId, AssetName, Long]*): MultiAsset def apply(assets: SortedMap[PolicyId, SortedMap[AssetName, Long]]): MultiAsset def binOp(op: Function2[Long, Long, Long])(self: MultiAsset, other: MultiAsset): MultiAsset given given_Encoder_MultiAsset: Encoder[MultiAsset] given given_Decoder_MultiAsset: Decoder[MultiAsset] given given_CommutativeGroup_MultiAsset: given_CommutativeGroup_MultiAsset object scalus.cardano.ledger.MultiAsset.given_CommutativeGroup_MultiAsset def combine(x: MultiAsset, y: MultiAsset): MultiAsset def empty: MultiAsset def inverse(x: MultiAsset): MultiAsset def formatAssetEntries(ma: MultiAsset, style: Style): List[Doc] given given_Pretty_MultiAsset: given_Pretty_MultiAsset object scalus.cardano.ledger.MultiAsset.given_Pretty_MultiAsset def pretty(a: MultiAsset, style: Style): Doc class scalus.cardano.ledger.NonNegativeInterval val numerator: Long val denominator: Long def equals(obj: Any): Boolean def hashCode(): Int def toString: String def copy(numerator: Long, denominator: Long): NonNegativeInterval def *(factor: Int): NonNegativeInterval def *(factor: Long): NonNegativeInterval def +(other: NonNegativeInterval): NonNegativeInterval def *(other: NonNegativeInterval): NonNegativeInterval def /(other: NonNegativeInterval): NonNegativeInterval def <(other: NonNegativeInterval): Boolean def <=(other: NonNegativeInterval): Boolean def >(other: NonNegativeInterval): Boolean def >=(other: NonNegativeInterval): Boolean def ceil: Long def floor: Long def toBigDecimal: BigDecimal def toDouble: Double def reduce: NonNegativeInterval object scalus.cardano.ledger.NonNegativeInterval def apply(numerator: Long, denominator: Long): NonNegativeInterval def unapply(x: NonNegativeInterval): Option[Tuple2[Long, Long]] val zero: NonNegativeInterval def reduce(numerator: Long, denominator: Long): NonNegativeInterval def reduceBigInt(numerator: BigInt, denominator: BigInt): NonNegativeInterval def apply(numerator: Long): NonNegativeInterval def apply(value: Double, precision: Int): NonNegativeInterval given given_UpickleReadWriter_NonNegativeInterval: ReadWriter[NonNegativeInterval] given given_Encoder_NonNegativeInterval: Encoder[NonNegativeInterval] given given_Decoder_NonNegativeInterval: Decoder[NonNegativeInterval] given given_ToData_NonNegativeInterval: ToData[NonNegativeInterval] given given_FromData_NonNegativeInterval: FromData[NonNegativeInterval] case class scalus.cardano.ledger.OperationalCert val hotVKey: ByteString val sequenceNumber: Long val kesPeriod: Long val sigma: ByteString trait scalus.cardano.ledger.PlutusScript def script: ByteString def language: Language var _cachedProgram: |[Program, Null] def program: Program def deBruijnedProgram: DeBruijnedProgram def toHex: String def isWellFormed(majorProtocolVersion: MajorProtocolVersion): Boolean object scalus.cardano.ledger.PlutusScript def isWellFormed(script: ByteString, language: Language, majorProtocolVersion: MajorProtocolVersion): Boolean case class scalus.cardano.ledger.PoolMetadata val url: String val metadataHash: MetadataHash case class scalus.cardano.ledger.PoolVotingThresholds val motionNoConfidence: UnitInterval val committeeNormal: UnitInterval val committeeNoConfidence: UnitInterval val hardForkInitiation: UnitInterval val ppSecurityGroup: UnitInterval object scalus.cardano.ledger.PoolVotingThresholds given given_Encoder_PoolVotingThresholds: Encoder[PoolVotingThresholds] given given_Decoder_PoolVotingThresholds: Decoder[PoolVotingThresholds] given given_ToData_PoolVotingThresholds: ToData[PoolVotingThresholds] given given_FromData_PoolVotingThresholds: FromData[PoolVotingThresholds] enum scalus.cardano.ledger.ProfileDestination enum scalus.cardano.ledger.ProfileFormat enum scalus.cardano.ledger.ProfileLevel case class scalus.cardano.ledger.ProfileOutput val format: ProfileFormat val destination: ProfileDestination case class scalus.cardano.ledger.ProposalProcedure val deposit: Coin val rewardAccount: RewardAccount val govAction: GovAction val anchor: Anchor object scalus.cardano.ledger.ProposalProcedure given given_Ordering_ProposalProcedure: Ordering[ProposalProcedure] case class scalus.cardano.ledger.ProtocolParamUpdate val minFeeA: Option[Coin] val minFeeB: Option[Coin] val maxBlockBodySize: Option[Int] val maxTxSize: Option[Int] val maxBlockHeaderSize: Option[Int] val keyDeposit: Option[Coin] val poolDeposit: Option[Coin] val maxEpoch: Option[Int] val nOpt: Option[Int] val poolPledgeInfluence: Option[NonNegativeInterval] val expansionRate: Option[UnitInterval] val treasuryGrowthRate: Option[UnitInterval] val minPoolCost: Option[Coin] val adaPerUtxoByte: Option[Coin] val costModels: Option[CostModels] val executionCosts: Option[ExUnitPrices] val maxTxExUnits: Option[ExUnits] val maxBlockExUnits: Option[ExUnits] val maxValueSize: Option[Int] val collateralPercentage: Option[Int] val maxCollateralInputs: Option[Int] val poolVotingThresholds: Option[PoolVotingThresholds] val drepVotingThresholds: Option[DRepVotingThresholds] val minCommitteeSize: Option[Int] val committeeTermLimit: Option[Int] val governanceActionValidityPeriod: Option[Int] val governanceActionDeposit: Option[Coin] val drepDeposit: Option[Coin] val drepInactivityPeriod: Option[Int] val minFeeRefScriptCoinsPerByte: Option[NonNegativeInterval] object scalus.cardano.ledger.ProtocolParamUpdate given given_Encoder_ProtocolParamUpdate: Encoder[ProtocolParamUpdate] given given_Decoder_ProtocolParamUpdate: Decoder[ProtocolParamUpdate] given given_ToData_ProtocolParamUpdate: ToData[ProtocolParamUpdate] given given_FromData_ProtocolParamUpdate: FromData[ProtocolParamUpdate] case class scalus.cardano.ledger.ProtocolParams val collateralPercentage: Long val committeeMaxTermLength: Long val committeeMinSize: Long val costModels: CostModels val dRepActivity: Long val dRepDeposit: Long val dRepVotingThresholds: DRepVotingThresholds val executionUnitPrices: ExUnitPrices val govActionDeposit: Long val govActionLifetime: Long val maxBlockBodySize: Long val maxBlockExecutionUnits: ExUnits val maxBlockHeaderSize: Long val maxCollateralInputs: Long val maxTxExecutionUnits: ExUnits val maxTxSize: Long val maxValueSize: Long val minFeeRefScriptCostPerByte: Long val minPoolCost: Long val monetaryExpansion: Double val poolPledgeInfluence: Double val poolRetireMaxEpoch: Long val poolVotingThresholds: PoolVotingThresholds val protocolVersion: ProtocolVersion val stakeAddressDeposit: Long val stakePoolDeposit: Long val stakePoolTargetNum: Long val treasuryCut: Double val txFeeFixed: Long val txFeePerByte: Long val utxoCostPerByte: Long object scalus.cardano.ledger.ProtocolParams case class scalus.cardano.ledger.ProtocolParams.ParamDiff val field: String val expected: String val actual: String def diff(expected: ProtocolParams, actual: ProtocolParams): Seq[ParamDiff] def fromBlockfrostJson(json: String): ProtocolParams def fromBlockfrostJson(json: InputStream): ProtocolParams def fromCardanoCliJson(json: String): ProtocolParams def fromCardanoCliJson(json: InputStream): ProtocolParams val blockfrostParamsReadWriter: ReadWriter[ProtocolParams] val cardanoCliParamsReadWriter: ReadWriter[ProtocolParams] object scalus.cardano.ledger.ProtocolParamsToExpr given given_ToExpr_ProtocolVersion: given_ToExpr_ProtocolVersion object scalus.cardano.ledger.ProtocolParamsToExpr.given_ToExpr_ProtocolVersion def apply(pv: ProtocolVersion)(using x$2: Quotes): Expr[ProtocolVersion] given given_ToExpr_ExUnits: given_ToExpr_ExUnits object scalus.cardano.ledger.ProtocolParamsToExpr.given_ToExpr_ExUnits def apply(eu: ExUnits)(using x$2: Quotes): Expr[ExUnits] given given_ToExpr_UnitInterval: given_ToExpr_UnitInterval object scalus.cardano.ledger.ProtocolParamsToExpr.given_ToExpr_UnitInterval def apply(ui: UnitInterval)(using x$2: Quotes): Expr[UnitInterval] given given_ToExpr_NonNegativeInterval: given_ToExpr_NonNegativeInterval object scalus.cardano.ledger.ProtocolParamsToExpr.given_ToExpr_NonNegativeInterval def apply(nni: NonNegativeInterval)(using x$2: Quotes): Expr[NonNegativeInterval] given given_ToExpr_ExUnitPrices: given_ToExpr_ExUnitPrices object scalus.cardano.ledger.ProtocolParamsToExpr.given_ToExpr_ExUnitPrices def apply(eup: ExUnitPrices)(using x$2: Quotes): Expr[ExUnitPrices] given given_ToExpr_PoolVotingThresholds: given_ToExpr_PoolVotingThresholds object scalus.cardano.ledger.ProtocolParamsToExpr.given_ToExpr_PoolVotingThresholds def apply(pvt: PoolVotingThresholds)(using x$2: Quotes): Expr[PoolVotingThresholds] given given_ToExpr_DRepVotingThresholds: given_ToExpr_DRepVotingThresholds object scalus.cardano.ledger.ProtocolParamsToExpr.given_ToExpr_DRepVotingThresholds def apply(dvt: DRepVotingThresholds)(using x$2: Quotes): Expr[DRepVotingThresholds] given given_ToExpr_CostModels: given_ToExpr_CostModels object scalus.cardano.ledger.ProtocolParamsToExpr.given_ToExpr_CostModels def apply(cm: CostModels)(using x$2: Quotes): Expr[CostModels] given given_ToExpr_ProtocolParams: given_ToExpr_ProtocolParams object scalus.cardano.ledger.ProtocolParamsToExpr.given_ToExpr_ProtocolParams def apply(pp: ProtocolParams)(using x$2: Quotes): Expr[ProtocolParams] case class scalus.cardano.ledger.ProtocolVersion val major: Int val minor: Int def compare(that: ProtocolVersion): Int def toMajor: MajorProtocolVersion object scalus.cardano.ledger.ProtocolVersion val shelleyPV: ProtocolVersion val allegraPV: ProtocolVersion val maryPV: ProtocolVersion val alonzoPV: ProtocolVersion val vasilPV: ProtocolVersion val valentinePV: ProtocolVersion val conwayPV: ProtocolVersion val plominPV: ProtocolVersion val vanRossemPV: ProtocolVersion val futurePV: ProtocolVersion val knownPVs: SortedSet[ProtocolVersion] case class scalus.cardano.ledger.Redeemer val tag: RedeemerTag val index: Int val data: Data val exUnits: ExUnits object scalus.cardano.ledger.Redeemer given given_Ordering_Redeemer: given_Ordering_Redeemer object scalus.cardano.ledger.Redeemer.given_Ordering_Redeemer def compare(x: Redeemer, y: Redeemer): Int given given_Pretty_Redeemer: given_Pretty_Redeemer object scalus.cardano.ledger.Redeemer.given_Pretty_Redeemer def pretty(a: Redeemer, style: Style): Doc enum scalus.cardano.ledger.RedeemerTag object scalus.cardano.ledger.RedeemerTag val Spend: RedeemerTag val Mint: RedeemerTag val Cert: RedeemerTag val Reward: RedeemerTag val Voting: RedeemerTag val Proposing: RedeemerTag given given_Ordering_RedeemerTag: given_Ordering_RedeemerTag object scalus.cardano.ledger.RedeemerTag.given_Ordering_RedeemerTag def compare(x: RedeemerTag, y: RedeemerTag): Int given given_Encoder_RedeemerTag: given_Encoder_RedeemerTag object scalus.cardano.ledger.RedeemerTag.given_Encoder_RedeemerTag def write(w: Writer, value: RedeemerTag): Writer given given_Decoder_RedeemerTag: given_Decoder_RedeemerTag object scalus.cardano.ledger.RedeemerTag.given_Decoder_RedeemerTag def read(r: Reader): RedeemerTag trait scalus.cardano.ledger.Redeemers def toSeq: Seq[Redeemer] def toIndexedSeq: IndexedSeq[Redeemer] def toMap: immutable.Map[Tuple2[RedeemerTag, Int], Tuple2[Data, ExUnits]] def isEmpty: Boolean val totalExUnits: ExUnits object scalus.cardano.ledger.Redeemers case class scalus.cardano.ledger.Redeemers.Array val redeemers: IndexedSeq[Redeemer] case class scalus.cardano.ledger.Redeemers.Map val redeemers: Map[Tuple2[RedeemerTag, Int], Tuple2[Data, ExUnits]] def apply(redeemers: Redeemer*): Redeemers def from(redeemers: IterableOnce[Redeemer]): Redeemers given given_Encoder_Redeemers: given_Encoder_Redeemers object scalus.cardano.ledger.Redeemers.given_Encoder_Redeemers def write(w: Writer, value: Redeemers): Writer given given_Decoder_Redeemers: given_Decoder_Redeemers object scalus.cardano.ledger.Redeemers.given_Decoder_Redeemers def read(r: Reader): Redeemers given given_Pretty_Redeemers: given_Pretty_Redeemers object scalus.cardano.ledger.Redeemers.given_Pretty_Redeemers def pretty(a: Redeemers, style: Style): Doc enum scalus.cardano.ledger.Relay object scalus.cardano.ledger.Relay enum scalus.cardano.ledger.Relay.SingleHostAddr val port: Option[Int] val ipv4: Option[ByteString] val ipv6: Option[ByteString] enum scalus.cardano.ledger.Relay.SingleHostName val port: Option[Int] val dnsName: String enum scalus.cardano.ledger.Relay.MultiHostName val dnsName: String given given_Encoder_Relay: Encoder[Relay] given given_Decoder_Relay: Decoder[Relay] case class scalus.cardano.ledger.RewardAccount val address: StakeAddress def keyHashOption: Option[|[AddrKeyHash, StakeKeyHash]] def scriptHashOption: Option[ScriptHash] object scalus.cardano.ledger.RewardAccount given given_Ordering_RewardAccount: given_Ordering_RewardAccount object scalus.cardano.ledger.RewardAccount.given_Ordering_RewardAccount def compare(x: RewardAccount, y: RewardAccount): Int given given_Encoder_RewardAccount: given_Encoder_RewardAccount object scalus.cardano.ledger.RewardAccount.given_Encoder_RewardAccount def write(w: Writer, value: RewardAccount): Writer given given_Decoder_RewardAccount: given_Decoder_RewardAccount object scalus.cardano.ledger.RewardAccount.given_Decoder_RewardAccount def read(r: Reader): RewardAccount trait scalus.cardano.ledger.Script def scriptHash: ScriptHash object scalus.cardano.ledger.Script case class scalus.cardano.ledger.Script.Native val script: Timelock val scriptHash: ScriptHash case class scalus.cardano.ledger.Script.PlutusV1 val script: ByteString val scriptHash: ScriptHash def language: Language val PlutusV1: PlutusV1 object scalus.cardano.ledger.Script.PlutusV1 def apply(program: Program): PlutusV1 case class scalus.cardano.ledger.Script.PlutusV2 val script: ByteString val scriptHash: ScriptHash def language: Language val PlutusV2: PlutusV2 object scalus.cardano.ledger.Script.PlutusV2 def apply(program: Program): PlutusV2 case class scalus.cardano.ledger.Script.PlutusV3 val script: ByteString val scriptHash: ScriptHash def language: Language val PlutusV3: PlutusV3 object scalus.cardano.ledger.Script.PlutusV3 def apply(program: Program): PlutusV3 case class scalus.cardano.ledger.Script.PlutusV4 val script: ByteString val scriptHash: ScriptHash def language: Language val PlutusV4: PlutusV4 object scalus.cardano.ledger.Script.PlutusV4 def apply(program: Program): PlutusV4 given given_Codec_Script: Codec[Script] given prettyScript: prettyScript object scalus.cardano.ledger.Script.prettyScript def pretty(a: Script, style: Style): Doc given given_Pretty_Native: Pretty[Script.Native] given given_Pretty_PlutusV1: Pretty[Script.PlutusV1] given given_Pretty_PlutusV2: Pretty[Script.PlutusV2] given given_Pretty_PlutusV3: Pretty[Script.PlutusV3] given given_Pretty_PlutusV4: Pretty[Script.PlutusV4] case class scalus.cardano.ledger.ScriptRef val script: Script object scalus.cardano.ledger.ScriptRef given given_Encoder_ScriptRef: given_Encoder_ScriptRef object scalus.cardano.ledger.ScriptRef.given_Encoder_ScriptRef def write(w: Writer, value: ScriptRef): Writer given given_Decoder_ScriptRef: given_Decoder_ScriptRef object scalus.cardano.ledger.ScriptRef.given_Decoder_ScriptRef def read(r: Reader): ScriptRef given given_Pretty_ScriptRef: Pretty[ScriptRef] case class scalus.cardano.ledger.Sized val value: A val size: Int def toString: String object scalus.cardano.ledger.Sized def lens[A]()(evidence$1: Encoder[A]): Lens[Sized[A], A] def apply[A](value: A)(evidence$1: Encoder[A]): Sized[A] given given_Decoder_Sized[A](evidence$1: Decoder[A], x$1: OriginalCborByteArray): Decoder[Sized[A]] given given_Encoder_Sized[A](evidence$1: Encoder[A]): Encoder[Sized[A]] object scalus.cardano.ledger.SizedSize def unapply[A](sized: Sized[A]): Some[Int] object scalus.cardano.ledger.SizedValue def unapply[A](sized: Sized[A]): Some[A] case class scalus.cardano.ledger.Slot val slot: Long def <=(other: Slot): Boolean def >=(other: Slot): Boolean def <(other: Slot): Boolean def >(other: Slot): Boolean case class scalus.cardano.ledger.SlotConfig val zeroTime: Long val zeroSlot: Long val slotLength: Long val epochLength: Long val zeroEpoch: Long def slotToTime(slot: Long): Long def timeToSlot(time: Long): Long def slotToInstant(slot: Long): Instant def instantToSlot(instant: Instant): Long def epochOf(slot: Long): Long def firstSlotOfEpoch(epoch: Long): Long object scalus.cardano.ledger.SlotConfig val DefaultEpochLength: Long def apply(zeroTime: Long, zeroSlot: Long, slotLength: Long): SlotConfig val mainnet: SlotConfig val preview: SlotConfig val preprod: SlotConfig trait scalus.cardano.ledger.TaggedSeq def checkNonEmpty[A](src: IterableOnce[A]): IndexedSeq[A] def checkDuplicates[A](src: IterableOnce[A]): IndexedSeq[A] def readTagged[A](r: Reader)(evidence$1: Decoder[A]): IndexedSeq[A] def writeTagged[A](w: Writer, v: IterableOnce[A])(evidence$1: Encoder[A]): Writer enum scalus.cardano.ledger.Timelock val scriptHash: ScriptHash val show: String def evaluate(validatorKeys: Set[AddrKeyHash], interval: ValidityInterval): Boolean def toCbor: Array[Byte] object scalus.cardano.ledger.Timelock enum scalus.cardano.ledger.Timelock.Signature val keyHash: AddrKeyHash enum scalus.cardano.ledger.Timelock.AllOf val scripts: IndexedSeq[Timelock] enum scalus.cardano.ledger.Timelock.AnyOf val scripts: IndexedSeq[Timelock] enum scalus.cardano.ledger.Timelock.MOf val m: Int val scripts: IndexedSeq[Timelock] enum scalus.cardano.ledger.Timelock.TimeStart val lockStart: SlotNo enum scalus.cardano.ledger.Timelock.TimeExpire val lockExpire: SlotNo given given_Encoder_Timelock: Encoder[Timelock] given given_Decoder_Timelock: Decoder[Timelock] def fromCbor(cbor: Array[Byte]): Timelock def inInterval(slot: SlotNo, interval: ValidityInterval): Boolean def lteNegInfty(i: SlotNo, j: Option[SlotNo]): Boolean def ltePosInfty(i: Option[SlotNo], j: SlotNo): Boolean given blockfrostReadWriter: upickle.default.ReadWriter[Timelock] def fromBlockfrostJson(json: String): Timelock given given_Pretty_Timelock: given_Pretty_Timelock object scalus.cardano.ledger.Timelock.given_Pretty_Timelock def pretty(a: Timelock, style: Style): Doc case class scalus.cardano.ledger.Transaction val body: KeepRaw[TransactionBody] val witnessSetRaw: KeepRaw[TransactionWitnessSet] val isValid: Boolean val auxiliaryData: Option[KeepRaw[AuxiliaryData]] val id: TransactionHash def witnessSet: TransactionWitnessSet def validityInterval: ValidityInterval def utxos: Utxos def toCbor: Array[Byte] def toCborForFeeCalculation: Array[Byte] def withBody(b: TransactionBody): Transaction def withBody(f: Function1[TransactionBody, TransactionBody]): Transaction def withWitness(ws: TransactionWitnessSet): Transaction def withWitness(f: Function1[TransactionWitnessSet, TransactionWitnessSet]): Transaction object scalus.cardano.ledger.Transaction def apply(body: TransactionBody): Transaction def apply(body: TransactionBody, witnessSet: TransactionWitnessSet): Transaction def apply(body: TransactionBody, witnessSet: TransactionWitnessSet, auxiliaryData: AuxiliaryData): Transaction def empty: Transaction def fromCbor(bytes: Array[Byte])(using pv: ProtocolVersion): Transaction given given_Encoder_Transaction: Encoder[Transaction] given decoder(using x$1: OriginalCborByteArray, x$2: ProtocolVersion): Decoder[Transaction] given given_Pretty_Transaction: given_Pretty_Transaction object scalus.cardano.ledger.Transaction.given_Pretty_Transaction def pretty(a: Transaction, style: Style): Doc case class scalus.cardano.ledger.TransactionBody val inputs: TaggedSortedSet[TransactionInput] val outputs: IndexedSeq[Sized[TransactionOutput]] val fee: Coin val ttl: Option[Long] val certificates: TaggedOrderedStrictSet[Certificate] val withdrawals: Option[Withdrawals] val auxiliaryDataHash: Option[AuxiliaryDataHash] val validityStartSlot: Option[Long] val mint: Option[Mint] val scriptDataHash: Option[ScriptDataHash] val collateralInputs: TaggedSortedSet[TransactionInput] val requiredSigners: TaggedSortedSet[AddrKeyHash] val networkId: Option[Int] val collateralReturnOutput: Option[Sized[TransactionOutput]] val totalCollateral: Option[Coin] val referenceInputs: TaggedSortedSet[TransactionInput] val votingProcedures: Option[VotingProcedures] val proposalProcedures: TaggedOrderedSet[ProposalProcedure] val currentTreasuryValue: Option[Coin] val donation: Option[Coin] object scalus.cardano.ledger.TransactionBody given given_Encoder_TransactionBody: given_Encoder_TransactionBody object scalus.cardano.ledger.TransactionBody.given_Encoder_TransactionBody def write(w: Writer, value: TransactionBody): Writer given given_Decoder_TransactionBody(using x$1: OriginalCborByteArray, x$2: ProtocolVersion): given_Decoder_TransactionBody given given_Pretty_TransactionBody: given_Pretty_TransactionBody object scalus.cardano.ledger.TransactionBody.given_Pretty_TransactionBody def pretty(a: TransactionBody, style: Style): Doc case class scalus.cardano.ledger.TransactionInput val transactionId: TransactionHash val index: Int object scalus.cardano.ledger.TransactionInput given given_Ordering_TransactionInput: given_Ordering_TransactionInput object scalus.cardano.ledger.TransactionInput.given_Ordering_TransactionInput def compare(x: TransactionInput, y: TransactionInput): Int given given_Pretty_TransactionInput: given_Pretty_TransactionInput object scalus.cardano.ledger.TransactionInput.given_Pretty_TransactionInput def pretty(a: TransactionInput, style: Style): Doc trait scalus.cardano.ledger.TransactionOutput def address: Address def value: Value def datumOption: Option[DatumOption] def scriptRef: Option[ScriptRef] def withValue(amount: Value): TransactionOutput def resolveDatum(tx: Transaction): Option[scalus.uplc.builtin.Data] def inlineDatum: Option[scalus.uplc.builtin.Data] def requireInlineDatum: scalus.uplc.builtin.Data object scalus.cardano.ledger.TransactionOutput val valueLens: Lens[TransactionOutput, Value] def unapply(transactionOutput: TransactionOutput): Tuple4[Address, Value, Option[DatumOption], Option[ScriptRef]] case class scalus.cardano.ledger.TransactionOutput.Shelley val address: Address val value: Value val datumHash: Option[DataHash] def datumOption: Option[DatumOption] def scriptRef: Option[ScriptRef] def withValue(amount: Value): TransactionOutput case class scalus.cardano.ledger.TransactionOutput.Babbage val address: Address val value: Value val datumOption: Option[DatumOption] val scriptRef: Option[ScriptRef] def withValue(amount: Value): TransactionOutput def apply(address: Address, value: Value): TransactionOutput def apply(address: Address, value: Value, datumHash: DataHash): TransactionOutput def apply(address: Address, value: Value, datumOption: DatumOption): TransactionOutput def apply(address: Address, value: Value, inlineDatum: scalus.uplc.builtin.Data): TransactionOutput def apply(address: Address, value: Value, datumOption: Option[DatumOption], scriptRef: Option[ScriptRef]): TransactionOutput given given_Encoder_TransactionOutput: given_Encoder_TransactionOutput object scalus.cardano.ledger.TransactionOutput.given_Encoder_TransactionOutput def write(w: Writer, value: TransactionOutput): Writer given given_Decoder_TransactionOutput: given_Decoder_TransactionOutput object scalus.cardano.ledger.TransactionOutput.given_Decoder_TransactionOutput def read(r: Reader): TransactionOutput given given_Pretty_TransactionOutput: given_Pretty_TransactionOutput object scalus.cardano.ledger.TransactionOutput.given_Pretty_TransactionOutput def pretty(a: TransactionOutput, style: Style): Doc def hasDatumHash(o: TransactionOutput)(hash: DataHash): Boolean object scalus.cardano.ledger.TransactionOutputAddress def unapply(transactionOutput: TransactionOutput): Some[Address] object scalus.cardano.ledger.TransactionOutputDatumOption def unapply(transactionOutput: TransactionOutput): Option[DatumOption] object scalus.cardano.ledger.TransactionOutputScriptRef def unapply(transactionOutput: TransactionOutput): Option[ScriptRef] object scalus.cardano.ledger.TransactionOutputValue def unapply(transactionOutput: TransactionOutput): Some[Value] case class scalus.cardano.ledger.TransactionWitnessSet val vkeyWitnesses: TaggedSortedSet[VKeyWitness] val nativeScripts: TaggedSortedMap[ScriptHash, Native] val bootstrapWitnesses: TaggedSortedSet[BootstrapWitness] val plutusV1Scripts: TaggedSortedStrictMap[ScriptHash, PlutusV1] val plutusData: KeepRaw[TaggedSortedMap[DataHash, KeepRaw[Data]]] val redeemers: Option[KeepRaw[Redeemers]] val plutusV2Scripts: TaggedSortedStrictMap[ScriptHash, PlutusV2] val plutusV3Scripts: TaggedSortedStrictMap[ScriptHash, PlutusV3] def isEmpty: Boolean object scalus.cardano.ledger.TransactionWitnessSet val empty: TransactionWitnessSet def apply(scripts: Seq[Script], redeemers: Option[Redeemers], vkeyWitnesses: Set[VKeyWitness], plutusData: Seq[Data]): TransactionWitnessSet given given_Encoder_TransactionWitnessSet: given_Encoder_TransactionWitnessSet object scalus.cardano.ledger.TransactionWitnessSet.given_Encoder_TransactionWitnessSet def write(w: Writer, value: TransactionWitnessSet): Writer given decoder(using x$1: OriginalCborByteArray, x$2: ProtocolVersion): decoder given given_KeyOf_DataHash_KeepRaw: TaggedSortedMap.KeyOf[DataHash, KeepRaw[Data]] given given_KeyOf_ScriptHash_Native: TaggedSortedMap.KeyOf[ScriptHash, Script.Native] given given_KeyOf_ScriptHash_PlutusV1: TaggedSortedStrictMap.KeyOf[ScriptHash, Script.PlutusV1] given given_KeyOf_ScriptHash_PlutusV2: TaggedSortedStrictMap.KeyOf[ScriptHash, Script.PlutusV2] given given_KeyOf_ScriptHash_PlutusV3: TaggedSortedStrictMap.KeyOf[ScriptHash, Script.PlutusV3] given given_Pretty_TransactionWitnessSet: given_Pretty_TransactionWitnessSet object scalus.cardano.ledger.TransactionWitnessSet.given_Pretty_TransactionWitnessSet def pretty(a: TransactionWitnessSet, style: Style): Doc case class scalus.cardano.ledger.UnitInterval val numerator: Long val denominator: Long def toDouble: Double object scalus.cardano.ledger.UnitInterval def fromDouble(value: Double): UnitInterval val half: UnitInterval val zero: UnitInterval val one: UnitInterval given given_Encoder_UnitInterval: Encoder[UnitInterval] given given_Decoder_UnitInterval: Decoder[UnitInterval] given given_ReadWriter_UnitInterval: ReadWriter[UnitInterval] given given_ToData_UnitInterval: ToData[UnitInterval] given given_FromData_UnitInterval: FromData[UnitInterval] case class scalus.cardano.ledger.Utxo val input: TransactionInput val output: TransactionOutput def toTuple: Tuple2[TransactionInput, TransactionOutput] object scalus.cardano.ledger.Utxo def apply(utxo: Tuple2[TransactionInput, TransactionOutput]): Utxo case class scalus.cardano.ledger.VKeyWitness val vkey: ByteString val signature: ByteString val vkeyHash: AddrKeyHash object scalus.cardano.ledger.VKeyWitness given given_Ordering_VKeyWitness: Ordering[VKeyWitness] given given_Pretty_VKeyWitness: given_Pretty_VKeyWitness object scalus.cardano.ledger.VKeyWitness.given_Pretty_VKeyWitness def pretty(a: VKeyWitness, style: Style): Doc case class scalus.cardano.ledger.ValidityInterval val invalidBefore: Option[SlotNo] val invalidHereafter: Option[SlotNo] case class scalus.cardano.ledger.Value val coin: Coin val assets: MultiAsset def +(rhs: Value): Value def -(rhs: Value): Value def unary_-: Value def isPositive: Boolean def isNegative: Boolean def isZeroAda: Boolean def nonZeroAda: Boolean def isEmptyAssets: Boolean def nonEmptyAssets: Boolean def isOnlyAda: Boolean def isOnlyAssets: Boolean def isZero: Boolean def nonZero: Boolean def toString: String object scalus.cardano.ledger.Value val zero: Value def lovelace(amount: Long): Value def ada(amount: Long): Value def asset(policyId: PolicyId, assetName: AssetName, amount: Long, lovelace: Coin): Value def assets(assets: Map[PolicyId, Map[AssetName, Long]], lovelace: Coin): Value def fromPolicy(policyId: PolicyId, assets: Map[AssetName, Long], lovelace: Coin): Value def combine(values: IterableOnce[Value]): Value def combine(values: Value*): Value given given_Encoder_Value: given_Encoder_Value object scalus.cardano.ledger.Value.given_Encoder_Value def write(w: Writer, value: Value): Writer given given_Decoder_Value: given_Decoder_Value object scalus.cardano.ledger.Value.given_Decoder_Value def read(r: Reader): Value given given_CommutativeGroup_Value: given_CommutativeGroup_Value object scalus.cardano.ledger.Value.given_CommutativeGroup_Value def combine(x: Value, y: Value): Value def empty: Value def inverse(x: Value): Value given given_Pretty_Value: given_Pretty_Value object scalus.cardano.ledger.Value.given_Pretty_Value def pretty(a: Value, style: Style): Doc def hasAsset(v: Value)(policyId: PolicyId, assetName: AssetName): Boolean def asset(v: Value)(policyId: PolicyId, assetName: AssetName): Long enum scalus.cardano.ledger.Vote object scalus.cardano.ledger.Vote val No: Vote val Yes: Vote val Abstain: Vote given given_Encoder_Vote: Encoder[Vote] given given_Decoder_Vote: Decoder[Vote] enum scalus.cardano.ledger.Voter def keyHashOption: Option[AddrKeyHash] def scriptHashOption: Option[ScriptHash] object scalus.cardano.ledger.Voter enum scalus.cardano.ledger.Voter.ConstitutionalCommitteeHotKey val keyHash: AddrKeyHash enum scalus.cardano.ledger.Voter.ConstitutionalCommitteeHotScript val scriptHash: ScriptHash enum scalus.cardano.ledger.Voter.DRepKey val keyHash: AddrKeyHash enum scalus.cardano.ledger.Voter.DRepScript val scriptHash: ScriptHash enum scalus.cardano.ledger.Voter.StakingPoolKey val keyHash: AddrKeyHash given given_Ordering_Voter: Ordering[Voter] case class scalus.cardano.ledger.VotingProcedure val vote: Vote val anchor: Option[Anchor] case class scalus.cardano.ledger.VotingProcedures val procedures: SortedMap[Voter, SortedMap[GovActionId, VotingProcedure]] def isEmpty: Boolean object scalus.cardano.ledger.VotingProcedures given given_Encoder_VotingProcedures: Encoder[VotingProcedures] given given_Decoder_VotingProcedures: Decoder[VotingProcedures] case class scalus.cardano.ledger.VrfCert val output: ByteString val proof: ByteString case class scalus.cardano.ledger.Withdrawals val withdrawals: SortedMap[RewardAccount, Coin] def isEmpty: Boolean object scalus.cardano.ledger.Withdrawals val empty: Withdrawals given given_Encoder_Withdrawals: Encoder[Withdrawals] given given_Decoder_Withdrawals: Decoder[Withdrawals] case class scalus.cardano.ledger.Word64 val value: Long def toLong: Long def toBigInteger: BigInteger def toUnsignedString: String def toHexString: String def compareUnsigned(other: Word64): Int def isLargeUnsigned: Boolean def +(other: Word64): Word64 def -(other: Word64): Word64 def *(other: Word64): Word64 def divideUnsigned(other: Word64): Word64 def remainderUnsigned(other: Word64): Word64 def &(other: Word64): Word64 def |(other: Word64): Word64 def ^(other: Word64): Word64 def unary_~: Word64 def <<(bits: Int): Word64 def >>>(bits: Int): Word64 def >>(bits: Int): Word64 object scalus.cardano.ledger.Word64 def fromUnsignedString(s: String): Word64 def fromBigInteger(bi: BigInteger): Word64 def fromUnsignedInt(value: Int): Word64 val Zero: Word64 val MaxValue: Word64 val One: Word64 given given_Encoder_Word64: given_Encoder_Word64 object scalus.cardano.ledger.Word64.given_Encoder_Word64 def write(writer: Writer, w64: Word64): Writer given given_Decoder_Word64: given_Decoder_Word64 object scalus.cardano.ledger.Word64.given_Decoder_Word64 def read(reader: Reader): Word64 def flatBytesCount(a: Word64): Int given given_Flat_Word64: given_Flat_Word64 object scalus.cardano.ledger.Word64.given_Flat_Word64 def bitSize(a: Word64): Int def encode(a: Word64, encode: EncoderState): Unit def decode(decode: DecoderState): Word64 case class scalus.cardano.onchain.plutus.prelude.AssocMap val toList: List[Tuple2[A, B]] object scalus.cardano.onchain.plutus.prelude.AssocMap def empty[A, B]: AssocMap[A, B] def singleton[A, B](key: A, value: B): AssocMap[A, B] def unsafeFromList[A, B](lst: List[Tuple2[A, B]]): AssocMap[A, B] def fromList[A, B](lst: List[Tuple2[A, B]])(evidence$1: Eq[A]): AssocMap[A, B] given AssocMapFromData[A, B](evidence$1: FromData[A], evidence$2: Eq[A], evidence$3: FromData[B]): FromData[AssocMap[A, B]] given assocMapToData[A, B](evidence$1: ToData[A], evidence$2: ToData[B]): ToData[AssocMap[A, B]] def toPairList[A, B](self: AssocMap[A, B]): PairList[A, B] def isEmpty[A, B](self: AssocMap[A, B]): Boolean def nonEmpty[A, B](self: AssocMap[A, B]): Boolean def length[A, B](self: AssocMap[A, B]): BigInt def size[A, B](self: AssocMap[A, B]): BigInt def keys[A, B](self: AssocMap[A, B]): List[A] def values[A, B](self: AssocMap[A, B]): List[B] def mapValues[A, B](self: AssocMap[A, B])[C](f: Function1[B, C]): AssocMap[A, C] def forall[A, B](self: AssocMap[A, B])(f: Function1[Tuple2[A, B], Boolean]): Boolean def exists[A, B](self: AssocMap[A, B])(f: Function1[Tuple2[A, B], Boolean]): Boolean def filterKeys[A, B](self: AssocMap[A, B])(predicate: Function1[A, Boolean]): AssocMap[A, B] def filter[A, B](self: AssocMap[A, B])(predicate: Function1[Tuple2[A, B], Boolean]): AssocMap[A, B] def filterNot[A, B](self: AssocMap[A, B])(predicate: Function1[Tuple2[A, B], Boolean]): AssocMap[A, B] def find[A, B](self: AssocMap[A, B])(predicate: Function1[Tuple2[A, B], Boolean]): Option[Tuple2[A, B]] def foldLeft[A, B](self: AssocMap[A, B])[C](init: C)(combiner: Function2[C, Tuple2[A, B], C]): C def foldRight[A, B](self: AssocMap[A, B])[C](init: C)(combiner: Function2[Tuple2[A, B], C, C]): C def get[A, B](self: AssocMap[A, B])(key: A)(evidence$1: Eq[A]): Option[B] def contains[A, B](self: AssocMap[A, B])(key: A)(evidence$1: Eq[A]): Boolean def insert[A, B](self: AssocMap[A, B])(key: A, value: B)(evidence$1: Eq[A]): AssocMap[A, B] def delete[A, B](self: AssocMap[A, B])(key: A)(evidence$1: Eq[A]): AssocMap[A, B] def union[A, B, C](lhs: AssocMap[A, B], rhs: AssocMap[A, C])(evidence$1: Eq[A]): AssocMap[A, These[B, C]] given assocMapNoEq[A, B]: Eq[AssocMap[A, B]] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] object scalus.cardano.onchain.plutus.prelude.AssocMapEq def equals[A, B](lhs: AssocMap[A, B], rhs: AssocMap[A, B])(evidence$1: Eq[A], evidence$2: Eq[B]): Boolean val sirModule: Module val sirDeps: List[SIRModuleWithDeps] trait scalus.cardano.onchain.plutus.prelude.Eq def apply(lhs: A, rhs: A): Boolean object scalus.cardano.onchain.plutus.prelude.Eq def apply[A](evidence$1: Eq[A]): Eq[A] def derived[A]: Eq[A] def structural[A](f: Function2[A, A, Boolean]): Eq[A] given given_Eq_Unit: Eq[Unit] given given_Eq_BigInt: Eq[BigInt] given given_Eq_String: Eq[String] given given_Eq_Boolean: Eq[Boolean] given given_Eq_Data: Eq[Data] given given_Eq_A_B[A, B](evidence$1: Eq[A], evidence$2: Eq[B]): Eq[Tuple2[A, B]] given given_Eq_A_B_C[A, B, C](evidence$1: Eq[A], evidence$2: Eq[B], evidence$3: Eq[C]): Eq[Tuple3[A, B, C]] def by[A, B](mapper: Function1[A, B])(evidence$1: Eq[B]): Eq[A] def eqv[A](self: Eq[A])(lhs: A, rhs: A): Boolean def notEqv[A](self: Eq[A])(lhs: A, rhs: A): Boolean def orElse[A](self: Eq[A])(other: Eq[A]): Eq[A] def orElseBy[A](self: Eq[A])[B](mapper: Function1[A, B])(evidence$1: Eq[B]): Eq[A] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] object scalus.cardano.onchain.plutus.prelude.EqMacros def eqImpl[A](evidence$1: Type[A], x$1: Quotes): Expr[Eq[A]] enum scalus.cardano.onchain.plutus.prelude.List object scalus.cardano.onchain.plutus.prelude.List val Nil: List[Nothing] enum scalus.cardano.onchain.plutus.prelude.List.Cons val head: A val tail: List[A] def empty[A]: List[A] def unboxedNil[A]: List[A] def single[A](a: A): List[A] def apply[A](args: A*): List[A] def from[A](i: IterableOnce[A]): List[A] def from[A](i: java.lang.Iterable[A]): List[A] def range(from: BigInt, to: BigInt): List[BigInt] def rangeUntil(from: BigInt, to: BigInt): List[BigInt] def fill[A](value: A, times: BigInt): List[A] def map2[A, B, C](a: List[A], b: List[B])(f: Function2[A, B, C]): List[C] given listToData[A](evidence$1: ToData[A]): ToData[scalus.cardano.onchain.plutus.prelude.List[A]] given listPairToData[A, B](evidence$1: ToData[A], evidence$2: ToData[B]): ToData[scalus.cardano.onchain.plutus.prelude.List[scalus.uplc.builtin.BuiltinPair[A, B]]] given listFromData[A](evidence$1: FromData[A]): FromData[scalus.cardano.onchain.plutus.prelude.List[A]] given listPairsFromData[A, B](evidence$1: FromData[A], evidence$2: FromData[B]): FromData[scalus.cardano.onchain.plutus.prelude.List[scalus.uplc.builtin.BuiltinPair[A, B]]] given listEq[A](evidence$1: Eq[A]): Eq[List[A]] given listOrd[A](evidence$1: Ord[A]): Ord[List[A]] given showList[T](evidence$1: Show[T]): Show[List[T]] def +:[A][B](list: List[B])(elem: A): List[B] def sort[A](self: List[A])(evidence$1: Ord[A]): List[A] def quicksort[A](self: List[A])(evidence$1: Ord[A]): List[A] def flatten[A](self: List[List[A]]): List[A] def !![A](self: List[A])(idx: BigInt): A def isEmpty[A](self: List[A]): Boolean def nonEmpty[A](self: List[A]): Boolean def isDefinedAt[A](self: List[A])(index: BigInt): Boolean def at[A](self: List[A])(index: BigInt): A def get[A](self: List[A])(index: BigInt): Option[A] def contains[A](self: List[A])[B](elem: B)(using eq: Eq[B]): Boolean def groupBy[A](self: List[A])[K](keyExtractor: Function1[A, K])(evidence$1: Ord[K]): SortedMap[K, List[A]] def groupMap[A](self: List[A])[K, B](keyExtractor: Function1[A, K])(valueExtractor: Function1[A, B])(evidence$1: Ord[K]): SortedMap[K, List[B]] def groupMapReduce[A](self: List[A])[K, B](keyExtractor: Function1[A, K])(valueExtractor: Function1[A, B])(reducer: Function2[B, B, B])(evidence$1: Ord[K]): SortedMap[K, B] def zip[A](self: List[A])[B](other: List[B]): List[Tuple2[A, B]] def prepended[A](self: List[A])[B](elem: B): List[B] def prependedAll[A](self: List[A])[B](other: List[B]): List[B] def ++:[A][B](other: List[B])(self: List[A]): List[B] def appended[A](self: List[A])[B](elem: B): List[B] def :+[A](self: List[A])[B](elem: B): List[B] def appendedAll[A](self: List[A])[B](other: List[B]): List[B] def :++[A](self: List[A])[B](other: List[B]): List[B] def concat[A](self: List[A])[B](other: List[B]): List[B] def ++[A](self: List[A])[B](other: List[B]): List[B] def map[A](self: List[A])[B](mapper: Function1[A, B]): List[B] def flatMap[A](self: List[A])[B](mapper: Function1[A, List[B]]): List[B] def filter[A](self: List[A])(predicate: Function1[A, Boolean]): List[A] def filterNot[A](self: List[A])(predicate: Function1[A, Boolean]): List[A] def filterMap[A](self: List[A])[B](predicate: Function1[A, Option[B]]): List[B] def find[A](self: List[A])(predicate: Function1[A, Boolean]): Option[A] def findMap[A](self: List[A])[B](mapper: Function1[A, Option[B]]): Option[B] def foldLeft[A](self: List[A])[B](init: B)(combiner: Function2[B, A, B]): B def foldRight[A](self: List[A])[B](init: B)(combiner: Function2[A, B, B]): B def exists[A](self: List[A])(predicate: Function1[A, Boolean]): Boolean def forall[A](self: List[A])(predicate: Function1[A, Boolean]): Boolean def count[A](self: List[A])(p: Function1[A, Boolean]): BigInt def indexOf[A](self: List[A])[B](elem: B)(using eq: Eq[B]): BigInt def indexOfOption[A](self: List[A])[B](elem: B)(using eq: Eq[B]): Option[BigInt] def last[A](self: List[A]): A def lastOption[A](self: List[A]): Option[A] def length[A](self: List[A]): BigInt def size[A](self: List[A]): BigInt def head[A](self: List[A]): A def headOption[A](self: List[A]): Option[A] def tail[A](self: List[A]): List[A] def drop[A](self: List[A])(skip: BigInt): List[A] def dropRight[A](self: List[A])(skip: BigInt): List[A] def dropWhile[A](self: List[A])(predicate: Function1[A, Boolean]): List[A] def deleteFirst[A](self: List[A])[B](elem: B)(using eq: Eq[B]): List[A] def take[A](self: List[A])(count: BigInt): List[A] def takeRight[A](self: List[A])(count: BigInt): List[A] def takeWhile[A](self: List[A])(predicate: Function1[A, Boolean]): List[A] def distinct[A](self: List[A])[B](using eq: Eq[B]): List[A] def diff[A](self: List[A])[B](other: List[B])(using eq: Eq[B]): List[A] def init[A](self: List[A]): List[A] def reverse[A](self: List[A]): List[A] def foreach[A](self: List[A])(f: Function1[A, Unit]): Unit def asScala[A](self: List[A]): scala.Seq[A] def toScalaList[A](self: List[A]): scala.collection.immutable.List[A] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] object scalus.cardano.onchain.plutus.prelude.LogMacros def logMacro(using x$1: Quotes)(args: Expr[Seq[Any]]): Expr[Unit] object scalus.cardano.onchain.plutus.prelude.Math def abs(x: BigInt): BigInt def min(x: BigInt, y: BigInt): BigInt def max(x: BigInt, y: BigInt): BigInt def clamp(self: BigInt, min: BigInt, max: BigInt): BigInt def gcd(x: BigInt, y: BigInt): BigInt def sqrt(radicand: BigInt): BigInt def isSqrt(self: BigInt, x: BigInt): Boolean def pow(base: BigInt, exp: BigInt): BigInt def exp2(exp: BigInt): BigInt def log2(self: BigInt): BigInt def log(self: BigInt, base: BigInt): BigInt val sirModule: Module val sirDeps: List[SIRModuleWithDeps] enum scalus.cardano.onchain.plutus.prelude.Option object scalus.cardano.onchain.plutus.prelude.Option enum scalus.cardano.onchain.plutus.prelude.Option.Some val value: A val None: Option[Nothing] def apply[A](x: A): Option[A] def empty[A]: Option[A] given optionEq[A](using eq: Eq[A]): Eq[Option[A]] given emptyOptionEq: Eq[Option[Nothing]] given optionOrd[A](using ord: Ord[A]): Ord[Option[A]] given optionFromData[A](evidence$1: FromData[A]): FromData[Option[A]] given optionToData[A](evidence$1: ToData[A]): ToData[Option[A]] def flatten[A](self: Option[Option[A]]): Option[A] def isEmpty[A](self: Option[A]): Boolean def nonEmpty[A](self: Option[A]): Boolean def isDefined[A](self: Option[A]): Boolean def getOrFail[A](self: Option[A])(message: String): A def orFail[A](self: Option[A])(message: String): Unit def get[A](self: Option[A]): A def getOrElse[A](self: Option[A])[B](default: B): B def orElse[A](self: Option[A])[B](alternative: Option[B]): Option[B] def map[A](self: Option[A])[B](mapper: Function1[A, B]): Option[B] def flatMap[A](self: Option[A])[B](mapper: Function1[A, Option[B]]): Option[B] def filter[A](self: Option[A])(predicate: Function1[A, Boolean]): Option[A] def filterNot[A](self: Option[A])(predicate: Function1[A, Boolean]): Option[A] def contains[A](self: Option[A])[B](elem: B)(using eq: Eq[B]): Boolean def exists[A](self: Option[A])(p: Function1[A, Boolean]): Boolean def forall[A](self: Option[A])(p: Function1[A, Boolean]): Boolean def find[A](self: Option[A])(p: Function1[A, Boolean]): Option[A] def asScala[A](self: Option[A]): scala.Option[A] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] trait scalus.cardano.onchain.plutus.prelude.Ord def apply(lhs: A, rhs: A): Order object scalus.cardano.onchain.plutus.prelude.Ord def apply[A](evidence$1: Ord[A]): Ord[A] given given_Ord_Unit: Ord[Unit] given given_Ord_BigInt: Ord[BigInt] def <(self: BigInt)(other: BigInt): Boolean def <=(self: BigInt)(other: BigInt): Boolean def >(self: BigInt)(other: BigInt): Boolean def >=(self: BigInt)(other: BigInt): Boolean def equiv(self: BigInt)(other: BigInt): Boolean def nonEquiv(self: BigInt)(other: BigInt): Boolean given given_Ord_Boolean: Ord[Boolean] def <(self: Boolean)(other: Boolean): Boolean def <=(self: Boolean)(other: Boolean): Boolean def >(self: Boolean)(other: Boolean): Boolean def >=(self: Boolean)(other: Boolean): Boolean def equiv(self: Boolean)(other: Boolean): Boolean def nonEquiv(self: Boolean)(other: Boolean): Boolean given given_Ord_Data: Ord[Data] given given_Ord_A_B[A, B](evidence$1: Ord[A], evidence$2: Ord[B]): Ord[Tuple2[A, B]] given given_Ord_A_B_C[A, B, C](evidence$1: Ord[A], evidence$2: Ord[B], evidence$3: Ord[C]): Ord[Tuple3[A, B, C]] def <[A](self: A)(other: A)(evidence$1: Ord[A]): Boolean def <=[A](self: A)(other: A)(evidence$1: Ord[A]): Boolean def >[A](self: A)(other: A)(evidence$1: Ord[A]): Boolean def >=[A](self: A)(other: A)(evidence$1: Ord[A]): Boolean def equiv[A](self: A)(other: A)(evidence$1: Ord[A]): Boolean def nonEquiv[A](self: A)(other: A)(evidence$1: Ord[A]): Boolean def by[A, B](mapper: Function1[A, B])(evidence$1: Ord[B]): Ord[A] def compare[A](self: Ord[A])(lhs: A, rhs: A): Order def lt[A](self: Ord[A])(lhs: A, rhs: A): Boolean def lteq[A](self: Ord[A])(lhs: A, rhs: A): Boolean def gt[A](self: Ord[A])(lhs: A, rhs: A): Boolean def gteq[A](self: Ord[A])(lhs: A, rhs: A): Boolean def equiv[A](self: Ord[A])(lhs: A, rhs: A): Boolean def nonEquiv[A](self: Ord[A])(lhs: A, rhs: A): Boolean def orElse[A](self: Ord[A])(other: Ord[A]): Ord[A] def orElseBy[A](self: Ord[A])[B](mapper: Function1[A, B])(evidence$1: Ord[B]): Ord[A] def keyPairOrd[A, B](evidence$1: Ord[A]): Ord[Tuple2[A, B]] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] enum scalus.cardano.onchain.plutus.prelude.Order object scalus.cardano.onchain.plutus.prelude.Order val Less: Order val Equal: Order val Greater: Order given given_Eq_Order: Eq[Order] given given_Ord_Order: Ord[Order] def isLess(self: Order): Boolean def isLessEqual(self: Order): Boolean def isGreater(self: Order): Boolean def isGreaterEqual(self: Order): Boolean def isEqual(self: Order): Boolean def nonEqual(self: Order): Boolean def ifEqualThen(self: Order)(other: => Order): Order val sirModule: Module val sirDeps: List[SIRModuleWithDeps] enum scalus.cardano.onchain.plutus.prelude.PairList object scalus.cardano.onchain.plutus.prelude.PairList val PairNil: PairList[Nothing, Nothing] enum scalus.cardano.onchain.plutus.prelude.PairList.PairCons val head: Tuple2[A, B] val tail: PairList[A, B] def empty[A, B]: PairList[A, B] def single[A, B](a: A, b: B): PairList[A, B] def from[A, B](it: IterableOnce[Tuple2[A, B]]): PairList[A, B] def head[A, B](self: PairList[A, B]): Tuple2[A, B] def tail[A, B](self: PairList[A, B]): PairList[A, B] def toList[A, B](self: PairList[A, B]): List[Tuple2[A, B]] def unsafeToSortedMap[A, B](self: PairList[A, B]): SortedMap[A, B] def unsafeToAssocMap[A, B](self: PairList[A, B]): AssocMap[A, B] def isEmpty[A, B](self: PairList[A, B]): Boolean def nonEmpty[A, B](self: PairList[A, B]): Boolean def length[A, B](self: PairList[A, B]): BigInt def mapValues[A, B](self: PairList[A, B])[C](f: Function1[B, C]): PairList[A, C] def map[A, B](self: PairList[A, B])[C, D](f: Function1[Tuple2[A, B], Tuple2[C, D]]): PairList[C, D] def filter[A, B](self: PairList[A, B])(p: Function1[Tuple2[A, B], Boolean]): PairList[A, B] def filterNot[A, B](self: PairList[A, B])(p: Function1[Tuple2[A, B], Boolean]): PairList[A, B] def foldLeft[A, B](self: PairList[A, B])[C](init: C)(f: Function2[C, Tuple2[A, B], C]): C def foldRight[A, B](self: PairList[A, B])[C](init: C)(f: Function2[Tuple2[A, B], C, C]): C def forall[A, B](self: PairList[A, B])(p: Function1[Tuple2[A, B], Boolean]): Boolean def exists[A, B](self: PairList[A, B])(p: Function1[Tuple2[A, B], Boolean]): Boolean def find[A, B](self: PairList[A, B])(p: Function1[Tuple2[A, B], Boolean]): Option[Tuple2[A, B]] def findMap[A, B](self: PairList[A, B])[C](f: Function1[Tuple2[A, B], Option[C]]): Option[C] def prepended[A, B](self: PairList[A, B])(elem: Tuple2[A, B]): PairList[A, B] def ++[A, B](self: PairList[A, B])(other: PairList[A, B]): PairList[A, B] def asScala[A, B](self: PairList[A, B]): scala.collection.immutable.List[Tuple2[A, B]] given pairListToData[A, B](evidence$1: ToData[A], evidence$2: ToData[B]): ToData[PairList[A, B]] given pairListFromData[A, B](evidence$1: FromData[A], evidence$2: FromData[B]): FromData[PairList[A, B]] given pairListEq[A, B](evidence$1: Eq[A], evidence$2: Eq[B]): Eq[PairList[A, B]] def toPairList[A, B](self: List[Tuple2[A, B]]): PairList[A, B] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] object scalus.cardano.onchain.plutus.prelude.Prelude def encodeHexByteString(input: ByteString): ByteString def encodeHex(input: ByteString): String def showByteStringBigInt(input: BigInt): ByteString def showBigInt(input: BigInt): String val sirModule: Module val sirDeps: List[SIRModuleWithDeps] case class scalus.cardano.onchain.plutus.prelude.Rational val numerator: BigInt val denominator: BigInt object scalus.cardano.onchain.plutus.prelude.Rational given rationalNoEq: Eq[Rational] given given_Ord_Rational: Ord[Rational] given rationalFromData: FromData[Rational] given rationalToData: ToData[Rational] def isZero(self: Rational): Boolean def checkDenominator(self: Rational)(): Unit def normalize(self: Rational): Rational val sirModule: Module val sirDeps: List[SIRModuleWithDeps] object scalus.cardano.onchain.plutus.prelude.RationalEq def equals(a: Rational, b: Rational): Boolean val sirModule: Module val sirDeps: List[SIRModuleWithDeps] trait scalus.cardano.onchain.plutus.prelude.Show def apply(v: A): String object scalus.cardano.onchain.plutus.prelude.Show def apply[A](evidence$1: Show[A]): Show[A] given given_Show_Unit: Show[Unit] given given_Show_BigInt: Show[BigInt] given given_Show_String: Show[String] given given_Show_Boolean: Show[Boolean] given given_Show_Data: Show[Data] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] trait scalus.cardano.onchain.plutus.prelude.ShowByteString def apply(v: A): ByteString object scalus.cardano.onchain.plutus.prelude.ShowByteString def apply[A](evidence$1: ShowByteString[A]): ShowByteString[A] given given_ShowByteString_Unit: ShowByteString[Unit] given given_ShowByteString_BigInt: ShowByteString[BigInt] given given_ShowByteString_ByteString: ShowByteString[ByteString] given given_ShowByteString_String: ShowByteString[String] given given_ShowByteString_Boolean: ShowByteString[Boolean] given given_ShowByteString_Data: ShowByteString[Data] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] case class scalus.cardano.onchain.plutus.prelude.SortedMap val toList: List[Tuple2[A, B]] object scalus.cardano.onchain.plutus.prelude.SortedMap def empty[A, B]: SortedMap[A, B] def singleton[A, B](key: A, value: B): SortedMap[A, B] def unsafeFromList[A, B](lst: List[Tuple2[A, B]]): SortedMap[A, B] def fromList[A, B](lst: List[Tuple2[A, B]])(evidence$1: Ord[A]): SortedMap[A, B] def fromStrictlyAscendingList[A, B](lst: List[Tuple2[A, B]])(evidence$1: Ord[A]): SortedMap[A, B] def from[A, B](it: IterableOnce[Tuple2[A, B]])(evidence$1: Ord[A]): SortedMap[A, B] def union[A, B, C](lhs: SortedMap[A, B], rhs: SortedMap[A, C])(evidence$1: Ord[A]): SortedMap[A, These[B, C]] def unionMap[A, B, C, D](lhs: SortedMap[A, B], rhs: SortedMap[A, C], f: Function1[These[B, C], D])(evidence$1: Ord[A]): SortedMap[A, D] given sortedMapEq[A, B](evidence$1: Eq[A], evidence$2: Eq[B]): Eq[SortedMap[A, B]] given sortedMapOrd[A, B](evidence$1: Ord[A], evidence$2: Ord[B]): Ord[SortedMap[A, B]] given sortedMapFromData[A, B](evidence$1: FromData[A], evidence$2: FromData[B]): FromData[SortedMap[A, B]] def sortedMapFromDataWithValidation[A, B](evidence$1: FromData[A], evidence$2: Ord[A], evidence$3: FromData[B]): FromData[SortedMap[A, B]] given sortedMapToData[A, B](evidence$1: ToData[A], evidence$2: ToData[B]): ToData[SortedMap[A, B]] def toPairList[A, B](self: SortedMap[A, B]): PairList[A, B] def isEmpty[A, B](self: SortedMap[A, B]): Boolean def nonEmpty[A, B](self: SortedMap[A, B]): Boolean def length[A, B](self: SortedMap[A, B]): BigInt def size[A, B](self: SortedMap[A, B]): BigInt def keys[A, B](self: SortedMap[A, B]): List[A] def values[A, B](self: SortedMap[A, B]): List[B] def forall[A, B](self: SortedMap[A, B])(f: Function1[Tuple2[A, B], Boolean]): Boolean def exists[A, B](self: SortedMap[A, B])(f: Function1[Tuple2[A, B], Boolean]): Boolean def mapValues[A, B](self: SortedMap[A, B])[C](f: Function1[B, C]): SortedMap[A, C] def filterKeys[A, B](self: SortedMap[A, B])(predicate: Function1[A, Boolean]): SortedMap[A, B] def filter[A, B](self: SortedMap[A, B])(predicate: Function1[Tuple2[A, B], Boolean]): SortedMap[A, B] def filterNot[A, B](self: SortedMap[A, B])(predicate: Function1[Tuple2[A, B], Boolean]): SortedMap[A, B] def find[A, B](self: SortedMap[A, B])(predicate: Function1[Tuple2[A, B], Boolean]): Option[Tuple2[A, B]] def findMap[A, B](self: SortedMap[A, B])[C](predicate: Function1[Tuple2[A, B], Option[C]]): Option[C] def foldLeft[A, B](self: SortedMap[A, B])[C](init: C)(combiner: Function2[C, Tuple2[A, B], C]): C def foldRight[A, B](self: SortedMap[A, B])[C](init: C)(combiner: Function2[Tuple2[A, B], C, C]): C def get[A, B](self: SortedMap[A, B])(key: A)(evidence$1: Ord[A]): Option[B] def getOrFail[A, B](self: SortedMap[A, B])(key: A, message: String)(evidence$1: Ord[A]): B def at[A, B](self: SortedMap[A, B])(key: A)(evidence$1: Ord[A]): B def contains[A, B](self: SortedMap[A, B])(key: A)(evidence$1: Ord[A]): Boolean def insert[A, B](self: SortedMap[A, B])(key: A, value: B)(evidence$1: Ord[A]): SortedMap[A, B] def delete[A, B](self: SortedMap[A, B])(key: A)(evidence$1: Ord[A]): SortedMap[A, B] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] enum scalus.cardano.onchain.plutus.prelude.These object scalus.cardano.onchain.plutus.prelude.These enum scalus.cardano.onchain.plutus.prelude.These.This val a: A enum scalus.cardano.onchain.plutus.prelude.These.That val b: B enum scalus.cardano.onchain.plutus.prelude.These.These val a: A val b: B given given_Eq_These[A, B](evidence$1: Eq[A], evidence$2: Eq[B]): Eq[scalus.cardano.onchain.plutus.prelude.These[A, B]] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] case class scalus.cardano.onchain.plutus.prelude.Varargs val list: List[T] case class scalus.cardano.onchain.plutus.v3.Committee val members: SortedMap[ColdCommitteeCredential, BigInt] val quorum: BigInt object scalus.cardano.onchain.plutus.v3.Committee given given_Eq_Committee: Eq[Committee] given given_Ord_Committee: Ord[Committee] given given_FromData_Committee: FromData[Committee] given given_ToData_Committee: ToData[Committee] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] enum scalus.cardano.onchain.plutus.v3.DRep object scalus.cardano.onchain.plutus.v3.DRep enum scalus.cardano.onchain.plutus.v3.DRep.DRep val credential: DRepCredential val AlwaysAbstain: DRep val AlwaysNoConfidence: DRep given given_Eq_DRep: Eq[scalus.cardano.onchain.plutus.v3.DRep] given given_Ord_DRep: Ord[scalus.cardano.onchain.plutus.v3.DRep] given given_FromData_DRep: FromData[scalus.cardano.onchain.plutus.v3.DRep] given given_ToData_DRep: ToData[scalus.cardano.onchain.plutus.v3.DRep] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] trait scalus.cardano.onchain.plutus.v3.DataParameterizedValidator def validate(param: Data)(scData: Data): Unit def spend(param: Data, datum: Option[Data], redeemer: Data, tx: TxInfo, ownRef: TxOutRef): Unit def mint(param: Data, redeemer: Data, policyId: PolicyId, tx: TxInfo): Unit def reward(param: Data, redeemer: Data, stakingKey: Credential, tx: TxInfo): Unit def certify(param: Data, redeemer: Data, cert: TxCert, tx: TxInfo): Unit def vote(param: Data, redeemer: Data, voter: Voter, tx: TxInfo): Unit def propose(param: Data, proposalProcedure: ProposalProcedure, tx: TxInfo): Unit enum scalus.cardano.onchain.plutus.v3.Delegatee object scalus.cardano.onchain.plutus.v3.Delegatee enum scalus.cardano.onchain.plutus.v3.Delegatee.Stake val pubKeyHash: PubKeyHash enum scalus.cardano.onchain.plutus.v3.Delegatee.Vote val dRep: DRep enum scalus.cardano.onchain.plutus.v3.Delegatee.StakeVote val pubKeyHash: PubKeyHash val dRep: DRep given given_Eq_Delegatee: Eq[Delegatee] given given_Ord_Delegatee: Ord[Delegatee] given given_FromData_Delegatee: FromData[Delegatee] given given_ToData_Delegatee: ToData[Delegatee] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] enum scalus.cardano.onchain.plutus.v3.GovernanceAction object scalus.cardano.onchain.plutus.v3.GovernanceAction enum scalus.cardano.onchain.plutus.v3.GovernanceAction.ParameterChange val id: Option[GovernanceActionId] val parameters: ChangedParameters val constitutionScript: Option[ScriptHash] enum scalus.cardano.onchain.plutus.v3.GovernanceAction.HardForkInitiation val id: Option[GovernanceActionId] val protocolVersion: ProtocolVersion enum scalus.cardano.onchain.plutus.v3.GovernanceAction.TreasuryWithdrawals val withdrawals: SortedMap[Credential, Lovelace] val constitutionScript: Option[ScriptHash] enum scalus.cardano.onchain.plutus.v3.GovernanceAction.NoConfidence val id: Option[GovernanceActionId] enum scalus.cardano.onchain.plutus.v3.GovernanceAction.UpdateCommittee val id: Option[GovernanceActionId] val removedMembers: List[ColdCommitteeCredential] val addedMembers: SortedMap[ColdCommitteeCredential, BigInt] val newQuorum: Rational enum scalus.cardano.onchain.plutus.v3.GovernanceAction.NewConstitution val id: Option[GovernanceActionId] val constitution: Constitution val InfoAction: GovernanceAction given given_Eq_GovernanceAction: Eq[GovernanceAction] given given_Ord_GovernanceAction: Ord[GovernanceAction] given given_FromData_GovernanceAction: FromData[GovernanceAction] given given_ToData_GovernanceAction: ToData[GovernanceAction] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] case class scalus.cardano.onchain.plutus.v3.GovernanceActionId val txId: TxId val govActionIx: BigInt object scalus.cardano.onchain.plutus.v3.GovernanceActionId given given_Eq_GovernanceActionId: Eq[GovernanceActionId] given given_Ord_GovernanceActionId: Ord[GovernanceActionId] given given_FromData_GovernanceActionId: FromData[GovernanceActionId] given given_ToData_GovernanceActionId: ToData[GovernanceActionId] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] trait scalus.cardano.onchain.plutus.v3.ParameterizedValidator def validate(param: A)(scData: Data): Unit def spend(param: A, datum: Option[Data], redeemer: Data, tx: TxInfo, ownRef: TxOutRef): Unit def mint(param: A, redeemer: Data, policyId: PolicyId, tx: TxInfo): Unit def reward(param: A, redeemer: Data, stakingKey: Credential, tx: TxInfo): Unit def certify(param: A, redeemer: Data, cert: TxCert, tx: TxInfo): Unit def vote(param: A, redeemer: Data, voter: Voter, tx: TxInfo): Unit def propose(param: A, proposalProcedure: ProposalProcedure, tx: TxInfo): Unit case class scalus.cardano.onchain.plutus.v3.ProposalProcedure val deposit: Lovelace val returnAddress: Credential val governanceAction: GovernanceAction object scalus.cardano.onchain.plutus.v3.ProposalProcedure given given_Eq_ProposalProcedure: Eq[ProposalProcedure] given given_Ord_ProposalProcedure: Ord[ProposalProcedure] given given_ToData_ProposalProcedure: ToData[ProposalProcedure] given given_FromData_ProposalProcedure: FromData[ProposalProcedure] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] case class scalus.cardano.onchain.plutus.v3.ProtocolVersion val pvMajor: BigInt val pvMinor: BigInt object scalus.cardano.onchain.plutus.v3.ProtocolVersion given given_Eq_ProtocolVersion: Eq[ProtocolVersion] given given_Ord_ProtocolVersion: Ord[ProtocolVersion] given given_FromData_ProtocolVersion: FromData[ProtocolVersion] given given_ToData_ProtocolVersion: ToData[ProtocolVersion] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] case class scalus.cardano.onchain.plutus.v3.ScriptContext val txInfo: TxInfo val redeemer: Redeemer val scriptInfo: ScriptInfo object scalus.cardano.onchain.plutus.v3.ScriptContext given given_Eq_ScriptContext: Eq[ScriptContext] given given_Ord_ScriptContext: Ord[ScriptContext] given given_FromData_ScriptContext: FromData[ScriptContext] given given_ToData_ScriptContext: ToData[ScriptContext] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] enum scalus.cardano.onchain.plutus.v3.ScriptInfo object scalus.cardano.onchain.plutus.v3.ScriptInfo enum scalus.cardano.onchain.plutus.v3.ScriptInfo.MintingScript val policyId: PolicyId enum scalus.cardano.onchain.plutus.v3.ScriptInfo.SpendingScript val txOutRef: TxOutRef val datum: Option[Datum] enum scalus.cardano.onchain.plutus.v3.ScriptInfo.RewardingScript val credential: Credential enum scalus.cardano.onchain.plutus.v3.ScriptInfo.CertifyingScript val index: BigInt val cert: TxCert enum scalus.cardano.onchain.plutus.v3.ScriptInfo.VotingScript val voter: Voter enum scalus.cardano.onchain.plutus.v3.ScriptInfo.ProposingScript val index: BigInt val procedure: ProposalProcedure given given_Eq_ScriptInfo: Eq[ScriptInfo] given given_Ord_ScriptInfo: Ord[ScriptInfo] given given_FromData_ScriptInfo: FromData[ScriptInfo] given given_ToData_ScriptInfo: ToData[ScriptInfo] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] enum scalus.cardano.onchain.plutus.v3.ScriptPurpose object scalus.cardano.onchain.plutus.v3.ScriptPurpose enum scalus.cardano.onchain.plutus.v3.ScriptPurpose.Minting val policyId: PolicyId enum scalus.cardano.onchain.plutus.v3.ScriptPurpose.Spending val txOutRef: TxOutRef enum scalus.cardano.onchain.plutus.v3.ScriptPurpose.Rewarding val credential: Credential enum scalus.cardano.onchain.plutus.v3.ScriptPurpose.Certifying val index: BigInt val cert: TxCert enum scalus.cardano.onchain.plutus.v3.ScriptPurpose.Voting val voter: Voter enum scalus.cardano.onchain.plutus.v3.ScriptPurpose.Proposing val index: BigInt val procedure: ProposalProcedure given given_Eq_ScriptPurpose: Eq[ScriptPurpose] given given_Ord_ScriptPurpose: Ord[ScriptPurpose] given given_FromData_ScriptPurpose: FromData[ScriptPurpose] given given_ToData_ScriptPurpose: ToData[ScriptPurpose] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] enum scalus.cardano.onchain.plutus.v3.TxCert object scalus.cardano.onchain.plutus.v3.TxCert enum scalus.cardano.onchain.plutus.v3.TxCert.RegStaking val credential: Credential val deposit: Option[Lovelace] enum scalus.cardano.onchain.plutus.v3.TxCert.UnRegStaking val credential: Credential val refund: Option[Lovelace] enum scalus.cardano.onchain.plutus.v3.TxCert.DelegStaking val credential: Credential val delegatee: Delegatee enum scalus.cardano.onchain.plutus.v3.TxCert.RegDeleg val credential: Credential val delegatee: Delegatee val deposit: Lovelace enum scalus.cardano.onchain.plutus.v3.TxCert.RegDRep val credential: DRepCredential val deposit: Lovelace enum scalus.cardano.onchain.plutus.v3.TxCert.UpdateDRep val credential: DRepCredential enum scalus.cardano.onchain.plutus.v3.TxCert.UnRegDRep val credential: DRepCredential val refund: Lovelace enum scalus.cardano.onchain.plutus.v3.TxCert.PoolRegister val poolId: PubKeyHash val poolVFR: PubKeyHash enum scalus.cardano.onchain.plutus.v3.TxCert.PoolRetire val pubKeyHash: PubKeyHash val epoch: BigInt enum scalus.cardano.onchain.plutus.v3.TxCert.AuthHotCommittee val cold: ColdCommitteeCredential val hot: HotCommitteeCredential enum scalus.cardano.onchain.plutus.v3.TxCert.ResignColdCommittee val cold: ColdCommitteeCredential given given_Eq_TxCert: Eq[TxCert] given given_Ord_TxCert: Ord[TxCert] given given_FromData_TxCert: FromData[TxCert] given given_ToData_TxCert: ToData[TxCert] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] case class scalus.cardano.onchain.plutus.v3.TxId val hash: ByteString object scalus.cardano.onchain.plutus.v3.TxId given given_Eq_TxId: Eq[TxId] given given_Ord_TxId: Ord[TxId] given given_FromData_TxId: FromData[TxId] given given_ToData_TxId: ToData[TxId] def txid(sc: StringContext)(args: Any*): TxId val sirModule: Module val sirDeps: List[SIRModuleWithDeps] case class scalus.cardano.onchain.plutus.v3.TxInInfo val outRef: TxOutRef val resolved: TxOut object scalus.cardano.onchain.plutus.v3.TxInInfo given given_Eq_TxInInfo: Eq[TxInInfo] given given_Ord_TxInInfo: Ord[TxInInfo] given given_FromData_TxInInfo: FromData[TxInInfo] given given_ToData_TxInInfo: ToData[TxInInfo] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] case class scalus.cardano.onchain.plutus.v3.TxInfo val inputs: List[TxInInfo] val referenceInputs: List[TxInInfo] val outputs: List[TxOut] val fee: Lovelace val mint: Value val certificates: List[TxCert] val withdrawals: SortedMap[Credential, Lovelace] val validRange: Interval val signatories: List[PubKeyHash] val redeemers: SortedMap[ScriptPurpose, Redeemer] val data: SortedMap[DatumHash, Datum] val id: TxId val votes: SortedMap[Voter, SortedMap[GovernanceActionId, Vote]] val proposalProcedures: List[ProposalProcedure] val currentTreasuryAmount: Option[Lovelace] val treasuryDonation: Option[Lovelace] object scalus.cardano.onchain.plutus.v3.TxInfo given given_Eq_TxInfo: Eq[TxInfo] given given_Ord_TxInfo: Ord[TxInfo] given given_FromData_TxInfo: FromData[TxInfo] given given_ToData_TxInfo: ToData[TxInfo] val placeholder: TxInfo def findOwnInput(self: TxInfo)(outRef: TxOutRef): Option[TxInInfo] def findOwnInputOrFail(self: TxInfo)(outRef: TxOutRef, message: String): TxInInfo def findOwnDatum(self: TxInfo)(datumHash: DatumHash): Option[Datum] def findOwnScriptOutputs(self: TxInfo)(scriptHash: ValidatorHash): List[v2.TxOut] def findOwnInputsByCredential(self: TxInfo)(cred: Credential): List[TxInInfo] def findOwnOutputsByCredential(self: TxInfo)(cred: Credential): List[v2.TxOut] def findOwnInputs(self: TxInfo)(pred: Function1[TxInInfo, Boolean]): List[TxInInfo] def findOwnOutputs(self: TxInfo)(pred: Function1[v2.TxOut, Boolean]): List[v2.TxOut] def isSignedBy(self: TxInfo)(pubKeyHash: PubKeyHash): Boolean def getValidityStartTime(self: TxInfo): BigInt val sirModule: Module val sirDeps: List[SIRModuleWithDeps] case class scalus.cardano.onchain.plutus.v3.TxOutRef val id: TxId val idx: BigInt object scalus.cardano.onchain.plutus.v3.TxOutRef given given_Eq_TxOutRef: Eq[TxOutRef] given given_Ord_TxOutRef: Ord[TxOutRef] given given_FromData_TxOutRef: FromData[TxOutRef] given given_ToData_TxOutRef: ToData[TxOutRef] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] object scalus.cardano.onchain.plutus.v3.Utils def findInput(inputs: List[TxInInfo], outRef: TxOutRef): Option[TxInInfo] def findDatum(outputs: List[TxOut], datum: SortedMap[DatumHash, Datum], datumHash: DatumHash): Option[Datum] def findScriptOutputs(outputs: List[TxOut], scriptHash: ValidatorHash): List[TxOut] def getAdaFromOutputs(outputs: List[v2.TxOut]): Lovelace def getAdaFromInputs(inputs: List[TxInInfo]): Lovelace val sirModule: Module val sirDeps: List[SIRModuleWithDeps] trait scalus.cardano.onchain.plutus.v3.Validator def validate(scData: Data): Unit def validateScriptContext(sc: ScriptContext): Unit def spend(datum: Option[Data], redeemer: Data, tx: TxInfo, ownRef: TxOutRef): Unit def mint(redeemer: Data, policyId: PolicyId, tx: TxInfo): Unit def reward(redeemer: Data, stakingKey: Credential, tx: TxInfo): Unit def certify(redeemer: Data, cert: TxCert, tx: TxInfo): Unit def vote(redeemer: Data, voter: Voter, tx: TxInfo): Unit def propose(proposalProcedure: ProposalProcedure, tx: TxInfo): Unit enum scalus.cardano.onchain.plutus.v3.Vote object scalus.cardano.onchain.plutus.v3.Vote val No: Vote val Yes: Vote val Abstain: Vote given given_Eq_Vote: Eq[Vote] given given_Ord_Vote: Ord[Vote] given given_ToData_Vote: ToData[Vote] given given_FromData_Vote: FromData[Vote] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] enum scalus.cardano.onchain.plutus.v3.Voter object scalus.cardano.onchain.plutus.v3.Voter enum scalus.cardano.onchain.plutus.v3.Voter.CommitteeVoter val credential: HotCommitteeCredential enum scalus.cardano.onchain.plutus.v3.Voter.DRepVoter val credential: DRepCredential enum scalus.cardano.onchain.plutus.v3.Voter.StakePoolVoter val pubKeyHash: PubKeyHash given given_Eq_Voter: Eq[Voter] given given_Ord_Voter: Ord[Voter] given given_ToData_Voter: ToData[Voter] given given_FromData_Voter: FromData[Voter] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] case class scalus.compiler.Options val targetLoweringBackend: TargetLoweringBackend val targetLanguage: Language val targetProtocolVersion: MajorProtocolVersion val generateErrorTraces: Boolean val removeTraces: Boolean val optimizeUplc: Boolean val uplcOptimizers: Seq[Optimizer] val cseIterations: Int val cceEnabled: Boolean val debugLevel: Int val debug: Boolean val addScalusTag: Boolean val warnListConversions: Boolean val noWarn: Boolean def withScalusTag(enable: Boolean): Options object scalus.compiler.Options val default: Options val debug: Options val release: Options val releaseUntagged: Options val vanRossem: Options val plomin: Options class scalus.uplc.CompiledPlutus val lazyCode: Function0[A] val sir: SIR val options: Options val optimizer: Optimizer def code: A def language: Language val program: Program val script: PlutusScript def address(network: Network): Address def withErrorTraces: CompiledPlutus[A] case class scalus.uplc.PlutusV1 val lazyCode: Function0[A] val sir: SIR val options: Options val optimizer: Optimizer def language: Language val script: Script.PlutusV1 def withErrorTraces: PlutusV1[A] object scalus.uplc.PlutusV1 def compile[A](code: A)(using opts: Options): PlutusV1[A] def alwaysOk: PlutusV1[Function1[Data, Function1[Data, Function1[Data, Unit]]]] def apply[A, B](self: PlutusV1[Function1[A, B]])(arg: A)(evidence$1: Constant.LiftValue[A]): PlutusV1[B] case class scalus.uplc.PlutusV2 val lazyCode: Function0[A] val sir: SIR val options: Options val optimizer: Optimizer def language: Language val script: Script.PlutusV2 def withErrorTraces: PlutusV2[A] object scalus.uplc.PlutusV2 def compile[A](code: A)(using opts: Options): PlutusV2[A] def alwaysOk: PlutusV2[Function1[Data, Function1[Data, Function1[Data, Unit]]]] def apply[A, B](self: PlutusV2[Function1[A, B]])(arg: A)(evidence$1: Constant.LiftValue[A]): PlutusV2[B] case class scalus.uplc.PlutusV3 val lazyCode: Function0[A] val sir: SIR val options: Options val optimizer: Optimizer def language: Language val script: Script.PlutusV3 def withErrorTraces: PlutusV3[A] def withOptions(newOptions: Options): PlutusV3[A] object scalus.uplc.PlutusV3 def compile[A](code: A)(using opts: Options): PlutusV3[A] def alwaysOk: PlutusV3[Function1[Data, Unit]] def apply[A, B](self: PlutusV3[Function1[A, B]])(arg: A)(evidence$1: Constant.LiftValue[A]): PlutusV3[B] case class scalus.uplc.Program val version: Tuple3[Int, Int, Int] val term: Term def alphaEq(that: Program): Boolean def α_==(that: Program): Boolean val flatEncoded: Array[Byte] val cborEncoded: Array[Byte] val cborByteString: ByteString val doubleCborEncoded: Array[Byte] val doubleCborHex: String def $(arg: Term): Program def $(arg: Data): Program val deBruijnedProgram: DeBruijnedProgram def pretty: Doc def prettyXTerm: Doc def show: String def showHighlighted: String def writePlutusFile(path: String, plutusVersion: Language): Unit def evaluate(using vm: PlutusVM): Term def evaluateDebug(using vm: PlutusVM): Result object scalus.uplc.Program def fromDoubleCborHex(doubleCborHex: String): Program def fromCborHex(cborHex: String): Program def fromCbor(cbor: Array[Byte]): Program def fromCborByteString(cbor: ByteString): Program def fromFlatEncoded(flatEncoded: Array[Byte]): Program def plutusV1(term: Term): Program def plutusV2(term: Term): Program def plutusV3(term: Term): Program def parseUplc(s: String): Either[String, Program] def parseUplc(s: String, version: Tuple3[Int, Int, Int]): Either[String, Program] given given_Pretty_Program: given_Pretty_Program object scalus.uplc.Program.given_Pretty_Program def pretty(program: Program, style: Style): Doc class scalus.uplc.builtin.AbstractBuiltins def addInteger(i1: BigInt, i2: BigInt): BigInt def subtractInteger(i1: BigInt, i2: BigInt): BigInt def multiplyInteger(i1: BigInt, i2: BigInt): BigInt def divideInteger(i1: BigInt, i2: BigInt): BigInt def quotientInteger(i1: BigInt, i2: BigInt): BigInt def remainderInteger(i1: BigInt, i2: BigInt): BigInt def modInteger(i1: BigInt, i2: BigInt): BigInt def equalsInteger(i1: BigInt, i2: BigInt): Boolean def lessThanInteger(i1: BigInt, i2: BigInt): Boolean def lessThanEqualsInteger(i1: BigInt, i2: BigInt): Boolean def expModInteger(base: BigInt, exponent: BigInt, modulus: BigInt): BigInt def appendByteString(a: ByteString, b: ByteString): ByteString def consByteString(char: BigInt, byteString: ByteString): ByteString def sliceByteString(from: BigInt, len: BigInt, bs: ByteString): ByteString def lengthOfByteString(bs: ByteString): BigInt def indexByteString(bs: ByteString, i: BigInt): BigInt def equalsByteString(a: ByteString, b: ByteString): Boolean def lessThanByteString(a: ByteString, b: ByteString): Boolean def lessThanEqualsByteString(a: ByteString, b: ByteString): Boolean def sha2_256(bs: ByteString): ByteString def sha3_256(bs: ByteString): ByteString def blake2b_256(bs: ByteString): ByteString def blake2b_224(bs: ByteString): ByteString def verifyEd25519Signature(pk: ByteString, msg: ByteString, sig: ByteString): Boolean def verifyEcdsaSecp256k1Signature(pk: ByteString, msg: ByteString, sig: ByteString): Boolean def verifySchnorrSecp256k1Signature(pk: ByteString, msg: ByteString, sig: ByteString): Boolean def appendString(s1: String, s2: String): String def equalsString(s1: String, s2: String): Boolean def encodeUtf8(s: String): ByteString def decodeUtf8(bs: ByteString): String def ifThenElse[A](cond: Boolean, a: A, b: A): A def chooseUnit[A]()(a: A): A def trace[A](s: String)(a: A): A def fstPair[A, B](p: BuiltinPair[A, B]): A def sndPair[A, B](p: BuiltinPair[A, B]): B def lengthOfArray[A](a: BuiltinArray[A]): BigInt def listToArray[A](a: BuiltinList[A]): BuiltinArray[A] def indexArray[A](a: BuiltinArray[A], n: BigInt): A def chooseList[A, B](l: BuiltinList[A], e: B, ne: B): B def mkCons[A](a: A, l: BuiltinList[A]): BuiltinList[A] def headList[A](l: BuiltinList[A]): A def tailList[A](l: BuiltinList[A]): BuiltinList[A] def nullList[A](l: BuiltinList[A]): Boolean def dropList[A](n: BigInt, l: BuiltinList[A]): BuiltinList[A] def chooseData[A](d: Data, constrCase: A, mapCase: A, listCase: A, iCase: A, bCase: A): A def constrData(ctor: BigInt, args: BuiltinList[Data]): Data def mapData(values: BuiltinList[BuiltinPair[Data, Data]]): Data def listData(values: BuiltinList[Data]): Data def iData(value: BigInt): Data def bData(value: ByteString): Data def unConstrData(d: Data): BuiltinPair[BigInt, BuiltinList[Data]] def unListData(d: Data): BuiltinList[Data] def unMapData(d: Data): BuiltinList[BuiltinPair[Data, Data]] def unIData(d: Data): BigInt def unBData(d: Data): ByteString def equalsData(d1: Data, d2: Data): Boolean def serialiseData(d: Data): ByteString def mkPairData(fst: Data, snd: Data): BuiltinPair[Data, Data] def mkNilData(): BuiltinList[Data] def mkNilPairData(): BuiltinList[BuiltinPair[Data, Data]] def integerToByteString(endianness: Boolean, length: BigInt, input: BigInt): ByteString def byteStringToInteger(endianness: Boolean, input: ByteString): BigInt def andByteString(shouldPad: Boolean, lhs: ByteString, rhs: ByteString): ByteString def orByteString(shouldPad: Boolean, lhs: ByteString, rhs: ByteString): ByteString def xorByteString(shouldPad: Boolean, lhs: ByteString, rhs: ByteString): ByteString def complementByteString(byteString: ByteString): ByteString def readBit(byteString: ByteString, index: BigInt): Boolean def writeBits(byteString: ByteString, indexes: BuiltinList[BigInt], bit: Boolean): ByteString def replicateByte(length: BigInt, byte: BigInt): ByteString def shiftByteString(byteString: ByteString, shift: BigInt): ByteString def rotateByteString(byteString: ByteString, rotation: BigInt): ByteString def countSetBits(byteString: ByteString): BigInt def findFirstSetBit(byteString: ByteString): BigInt def bls12_381_G1_equal(p1: G1Element, p2: G1Element): Boolean def bls12_381_G1_add(p1: G1Element, p2: G1Element): G1Element def bls12_381_G1_scalarMul(s: BigInt, p: G1Element): G1Element def bls12_381_G1_neg(p: G1Element): G1Element def bls12_381_G1_compress(p: G1Element): ByteString def bls12_381_G1_uncompress(bs: ByteString): G1Element def bls12_381_G1_hashToGroup(bs: ByteString, dst: ByteString): G1Element def bls12_381_G2_equal(p1: G2Element, p2: G2Element): Boolean def bls12_381_G2_add(p1: G2Element, p2: G2Element): G2Element def bls12_381_G2_scalarMul(s: BigInt, p: G2Element): G2Element def bls12_381_G2_neg(p: G2Element): G2Element def bls12_381_G2_compress(p: G2Element): ByteString def bls12_381_G2_uncompress(bs: ByteString): G2Element def bls12_381_G2_hashToGroup(bs: ByteString, dst: ByteString): G2Element def bls12_381_G2_compressed_zero: ByteString def bls12_381_G2_compressed_generator: ByteString def bls12_381_millerLoop(p1: G1Element, p2: G2Element): MLResult def bls12_381_mulMlResult(r1: MLResult, r2: MLResult): MLResult def bls12_381_finalVerify(p1: MLResult, p2: MLResult): Boolean def bls12_381_G1_multiScalarMul(scalars: Seq[BigInt], points: Seq[G1Element]): G1Element def bls12_381_G2_multiScalarMul(scalars: Seq[BigInt], points: Seq[G2Element]): G2Element def keccak_256(bs: ByteString): ByteString def ripemd_160(byteString: ByteString): ByteString def insertCoin(currency: ByteString, token: ByteString, amount: BigInt, value: BuiltinValue): BuiltinValue def lookupCoin(currency: ByteString, token: ByteString, value: BuiltinValue): BigInt def unionValue(v1: BuiltinValue, v2: BuiltinValue): BuiltinValue def valueContains(v1: BuiltinValue, v2: BuiltinValue): Boolean def valueData(value: BuiltinValue): Data def unValueData(data: Data): BuiltinValue def scaleValue(scalar: BigInt, value: BuiltinValue): BuiltinValue object scalus.uplc.builtin.BitwiseLogicalOperations def andByteString(shouldPad: Boolean, lhs: ByteString, rhs: ByteString): ByteString def orByteString(shouldPad: Boolean, lhs: ByteString, rhs: ByteString): ByteString def xorByteString(shouldPad: Boolean, lhs: ByteString, rhs: ByteString): ByteString def complementByteString(byteString: ByteString): ByteString def readBit(byteString: ByteString, index: BigInt): Boolean def writeBits(byteString: ByteString, indexes: Seq[BigInt], bit: Boolean): ByteString def replicateByte(length: BigInt, byte: BigInt): ByteString def shiftByteString(byteString: ByteString, shift: BigInt): ByteString def rotateByteString(byteString: ByteString, rotation: BigInt): ByteString def countSetBits(byteString: ByteString): Int def findFirstSetBit(byteString: ByteString): Int class scalus.uplc.builtin.BuiltinArray def length: BigInt def apply(n: BigInt): A object scalus.uplc.builtin.BuiltinArray def empty[A]: BuiltinArray[A] def apply[A](xs: A*): BuiltinArray[A] def from[A](xs: IterableOnce[A]): BuiltinArray[A] def fromList[A](a: BuiltinList[A]): BuiltinArray[A] enum scalus.uplc.builtin.BuiltinList def isEmpty: Boolean def head: A def tail: BuiltinList[A] def ::[B](x: B): BuiltinList[B] def toList: immutable.List[A] object scalus.uplc.builtin.BuiltinList val Nil: BuiltinList[Nothing] enum scalus.uplc.builtin.BuiltinList.Cons val h: A val tl: BuiltinList[A] def empty[A]: BuiltinList[A] def apply[A](xs: A*): BuiltinList[A] def from[A](xs: IterableOnce[A]): BuiltinList[A] case class scalus.uplc.builtin.BuiltinPair val fst: A val snd: B def toString: String class scalus.uplc.builtin.BuiltinValue val inner: InnerType def equals(that: Any): Boolean def hashCode(): Int def toString: String object scalus.uplc.builtin.BuiltinValue trait scalus.uplc.builtin.BuiltinValueApi val empty: BuiltinValue def unsafeFromInner(inner: InnerType): BuiltinValue def valueEquals(self: BuiltinValue, that: Any): Boolean def valueHashCode(self: BuiltinValue): Int def valueToString(self: BuiltinValue): String def toEntryList(value: BuiltinValue): List[Tuple2[ByteString, List[Tuple2[ByteString, BigInt]]]] def fromEntryList(entries: List[Tuple2[ByteString, List[Tuple2[ByteString, BigInt]]]]): BuiltinValue def toData(value: BuiltinValue): Data def fromData(data: Data): BuiltinValue object scalus.uplc.builtin.Builtins class scalus.uplc.builtin.Builtins enum scalus.uplc.builtin.ByteOrder class scalus.uplc.builtin.ByteString val bytes: Array[Byte] def apply(i: Int): Byte def toString: String def hashCode: Int def equals(obj: Any): Boolean val toHex: String def toBinaryString: String def concat(that: ByteString): ByteString def size: Int object scalus.uplc.builtin.ByteString given given_Show_ByteString: Show[ByteString] given given_Eq_ByteString: Eq[ByteString] given given_Ord_ByteString: Ord[ByteString] def fromBigIntBigEndian(value: BigInt, size: BigInt): ByteString def fromBigIntLittleEndian(value: BigInt, size: BigInt): ByteString def <(self: ByteString)(that: ByteString): Boolean def <=(self: ByteString)(that: ByteString): Boolean def >(self: ByteString)(that: ByteString): Boolean def >=(self: ByteString)(that: ByteString): Boolean def equiv(self: ByteString)(that: ByteString): Boolean def nonEquiv(self: ByteString)(that: ByteString): Boolean def slice(self: ByteString)(from: BigInt, len: BigInt): ByteString def take(self: ByteString)(n: BigInt): ByteString def drop(self: ByteString)(n: BigInt): ByteString def at(self: ByteString)(index: BigInt): BigInt def length(self: ByteString): BigInt def isEmpty(self: ByteString): Boolean def nonEmpty(self: ByteString): Boolean def ++(self: ByteString)(that: ByteString): ByteString def +:(bs: ByteString)(b: BigInt): ByteString val sirModule: Module val sirDeps: List[SIRModuleWithDeps] trait scalus.uplc.builtin.ByteStringFlatInstance given given_Flat_ByteString: given_Flat_ByteString object scalus.uplc.builtin.ByteStringFlatInstance.given_Flat_ByteString val flatArray: Flat[Array[Byte]] def bitSize(a: ByteString): Int def encode(a: ByteString, encode: EncoderState): Unit def decode(decode: DecoderState): ByteString trait scalus.uplc.builtin.ByteStringOffchainApi val empty: ByteString def fromArray(bytes: Array[Byte]): ByteString def apply(bytes: Byte*): ByteString def fill(size: Int, byte: Byte): ByteString def unsafeFromArray(bytes: Array[Byte]): ByteString def fromHex(bytes: String): ByteString def fromString(s: String): ByteString def hex(sc: StringContext)(args: Any*): ByteString def utf8(sc: StringContext)(args: Any*): ByteString given given_Encoder_ByteString: given_Encoder_ByteString object scalus.uplc.builtin.ByteStringOffchainApi.given_Encoder_ByteString def write(w: Writer, value: ByteString): Writer given given_Decoder_ByteString: given_Decoder_ByteString object scalus.uplc.builtin.ByteStringOffchainApi.given_Decoder_ByteString def read(r: Reader): ByteString given given_Ordering_ByteString: given_Ordering_ByteString object scalus.uplc.builtin.ByteStringOffchainApi.given_Ordering_ByteString def compare(x: ByteString, y: ByteString): Int object scalus.uplc.builtin.ByteStringToInteger def byteStringToInteger(statedEndiannessArg: Boolean, input: ByteString): BigInt class scalus.uplc.builtin.Data def toString: String object scalus.uplc.builtin.Data def toData[A](a: A)(evidence$1: ToData[A]): Data def to(data: Data)[A](using ev: FromData[A]): A def fromData[A](data: Data)(using ev: scalus.uplc.builtin.FromData[A]): A case class scalus.uplc.builtin.Data.Constr val constr: BigInt val args: List[Data] case class scalus.uplc.builtin.Data.Map val values: List[Tuple2[Data, Data]] def hashCode(): Int def equals(x: Any): Boolean case class scalus.uplc.builtin.Data.List val values: List[Data] case class scalus.uplc.builtin.Data.I val value: BigInt case class scalus.uplc.builtin.Data.B val value: ByteString val unit: Data trait scalus.uplc.builtin.DataApi def dataHash(self: Data): ByteString given DataReadWriter: ReadWriter[Data] given dataCborEncoder: dataCborEncoder object scalus.uplc.builtin.DataApi.dataCborEncoder def write(writer: borer.Writer, data: Data): borer.Writer given dataCborDecoder: dataCborDecoder object scalus.uplc.builtin.DataApi.dataCborDecoder def read(r: Reader): Data def toJson[A](a: A)(evidence$1: Writer[A]): String def toJsonIndented[A](a: A)(indent: Int)(evidence$1: Writer[A]): String def toCbor[A](a: A): Array[Byte] def toCborByteString[A](a: A): ByteString def field(data: Data)[A](expr: Function1[A, Any]): Data def toConstr(data: Data): BuiltinPair[BigInt, scalus.uplc.builtin.BuiltinList[Data]] def toMap(data: Data): BuiltinList[BuiltinPair[Data, Data]] def toList(data: Data): BuiltinList[Data] def toI(data: Data): BigInt def toBigInt(data: Data): BigInt def toB(data: Data): ByteString def toByteString(data: Data): ByteString def fromJson(json: String): Data def toJson(data: Data, indent: Int): String def fromCbor(bytes: Array[Byte]): Data def fromCbor(is: InputStream): Data def fromCbor(bs: ByteString): Data def tryFromData[T](d: Data)(using fd: FromData[T]): Try[T] given given_Flat_Data: given_Flat_Data object scalus.uplc.builtin.DataApi.given_Flat_Data def bitSize(a: Data): Int def encode(a: Data, encode: EncoderState): Unit def decode(decode: DecoderState): Data given given_Pretty_Data: given_Pretty_Data object scalus.uplc.builtin.DataApi.given_Pretty_Data def pretty(a: Data, style: Style): Doc trait scalus.uplc.builtin.FromData def apply(v: Data): A object scalus.uplc.builtin.FromData def derived[A]: FromData[A] given given_FromData_BigInt: FromData[BigInt] given given_FromData_ByteString: FromData[ByteString] given given_FromData_String: FromData[String] given given_FromData_Data: FromData[Data] given given_FromData_Unit: FromData[Unit] given given_FromData_Boolean: FromData[Boolean] given unsafeTupleFromData[A, B](using fromA: FromData[A], fromB: FromData[B]): FromData[Tuple2[A, B]] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] object scalus.uplc.builtin.FromDataMacros def fromDataImpl[A](evidence$1: Type[A], x$1: Quotes): Expr[FromData[A]] def deriveFromDataCaseClassConstructor[T](evidence$1: Type[T], x$1: Quotes): Expr[Function1[scalus.uplc.builtin.BuiltinList[Data], T]] object scalus.uplc.builtin.IntegerToByteString val maximumOutputLength: Int def integerToByteString(endiannessArg: Boolean, lengthArg: BigInt, input: BigInt): ByteString object scalus.uplc.builtin.JVMPlatformSpecific trait scalus.uplc.builtin.JVMPlatformSpecific def sha2_256(bs: ByteString): ByteString def sha2_512(bs: ByteString): ByteString def sha3_256(bs: ByteString): ByteString def blake2b_224(bs: ByteString): ByteString def blake2b_256(bs: ByteString): ByteString def verifySchnorrSecp256k1Signature(pk: ByteString, msg: ByteString, sig: ByteString): Boolean def verifyEd25519Signature(pk: ByteString, msg: ByteString, sig: ByteString): Boolean def signEd25519(privateKey: ByteString, message: ByteString): ByteString def verifyEcdsaSecp256k1Signature(pk: ByteString, msg: ByteString, sig: ByteString): Boolean def bls12_381_G1_equal(p1: G1Element, p2: G1Element): Boolean def bls12_381_G1_add(p1: G1Element, p2: G1Element): G1Element def bls12_381_G1_scalarMul(s: BigInt, p: G1Element): G1Element def bls12_381_G1_neg(p: G1Element): G1Element def bls12_381_G1_compress(p: G1Element): ByteString def bls12_381_G1_uncompress(bs: ByteString): G1Element def bls12_381_G1_hashToGroup(bs: ByteString, dst: ByteString): G1Element def bls12_381_G2_equal(p1: G2Element, p2: G2Element): Boolean def bls12_381_G2_add(p1: G2Element, p2: G2Element): G2Element def bls12_381_G2_scalarMul(s: BigInt, p: G2Element): G2Element def bls12_381_G2_neg(p: G2Element): G2Element def bls12_381_G2_compress(p: G2Element): ByteString def bls12_381_G2_uncompress(bs: ByteString): G2Element def bls12_381_G2_hashToGroup(bs: ByteString, dst: ByteString): G2Element def bls12_381_millerLoop(p1: G1Element, p2: G2Element): MLResult def bls12_381_mulMlResult(r1: MLResult, r2: MLResult): MLResult def bls12_381_finalVerify(p1: MLResult, p2: MLResult): Boolean def bls12_381_G1_multiScalarMul(scalars: Seq[BigInt], points: Seq[G1Element]): G1Element def bls12_381_G2_multiScalarMul(scalars: Seq[BigInt], points: Seq[G2Element]): G2Element def keccak_256(bs: ByteString): ByteString def ripemd_160(byteString: ByteString): ByteString def modPow(base: BigInt, exp: BigInt, modulus: BigInt): BigInt def readFile(path: String): Array[Byte] def writeFile(path: String, bytes: Array[Byte]): Unit def appendFile(path: String, bytes: Array[Byte]): Unit def createDirectories(path: String): Unit def fileExists(path: String): Boolean object scalus.uplc.builtin.PippengerMSM def msm[P](scalars: Array[BigInteger], points: Array[P], identity: => P, dup: Function1[P, P], addInPlace: Function2[P, P, P], dblInPlace: Function1[P, P], mulScalar: Function2[P, BigInteger, P]): P trait scalus.uplc.builtin.PlatformSpecific def sha2_256(bs: ByteString): ByteString def sha2_512(bs: ByteString): ByteString def sha3_256(bs: ByteString): ByteString def blake2b_224(bs: ByteString): ByteString def blake2b_256(bs: ByteString): ByteString def verifyEd25519Signature(pk: ByteString, msg: ByteString, sig: ByteString): Boolean def signEd25519(privateKey: ByteString, msg: ByteString): ByteString def verifyEcdsaSecp256k1Signature(pk: ByteString, msg: ByteString, sig: ByteString): Boolean def verifySchnorrSecp256k1Signature(pk: ByteString, msg: ByteString, sig: ByteString): Boolean def bls12_381_G1_equal(p1: G1Element, p2: G1Element): Boolean def bls12_381_G1_add(p1: G1Element, p2: G1Element): G1Element def bls12_381_G1_scalarMul(s: BigInt, p: G1Element): G1Element def bls12_381_G1_neg(p: G1Element): G1Element def bls12_381_G1_compress(p: G1Element): ByteString def bls12_381_G1_uncompress(bs: ByteString): G1Element def bls12_381_G1_hashToGroup(bs: ByteString, dst: ByteString): G1Element def bls12_381_G2_equal(p1: G2Element, p2: G2Element): Boolean def bls12_381_G2_add(p1: G2Element, p2: G2Element): G2Element def bls12_381_G2_scalarMul(s: BigInt, p: G2Element): G2Element def bls12_381_G2_neg(p: G2Element): G2Element def bls12_381_G2_compress(p: G2Element): ByteString def bls12_381_G2_uncompress(bs: ByteString): G2Element def bls12_381_G2_hashToGroup(bs: ByteString, dst: ByteString): G2Element def bls12_381_millerLoop(p1: G1Element, p2: G2Element): MLResult def bls12_381_mulMlResult(r1: MLResult, r2: MLResult): MLResult def bls12_381_finalVerify(p1: MLResult, p2: MLResult): Boolean def bls12_381_G1_multiScalarMul(scalars: Seq[BigInt], points: Seq[G1Element]): G1Element def bls12_381_G2_multiScalarMul(scalars: Seq[BigInt], points: Seq[G2Element]): G2Element def keccak_256(bs: ByteString): ByteString def ripemd_160(byteString: ByteString): ByteString def modPow(base: BigInt, exp: BigInt, modulus: BigInt): BigInt def readFile(path: String): Array[Byte] def writeFile(path: String, bytes: Array[Byte]): Unit def appendFile(path: String, bytes: Array[Byte]): Unit def createDirectories(path: String): Unit def fileExists(path: String): Boolean object scalus.uplc.builtin.PlatformSpecific val bls12_381_scalar_period: BigInt val bls12_381_G1_compressed_zero: ByteString val bls12_381_G1_compressed_generator: ByteString val bls12_381_G2_compressed_zero: ByteString val bls12_381_G2_compressed_generator: ByteString val sirModule: Module val sirDeps: List[SIRModuleWithDeps] trait scalus.uplc.builtin.ToData def apply(v1: A): Data object scalus.uplc.builtin.ToData def derived[A]: ToData[A] given given_ToData_Boolean: ToData[Boolean] given bigIntToData: ToData[BigInt] given given_ToData_Data: ToData[Data] given given_ToData_ByteString: ToData[ByteString] given given_ToData_String: ToData[String] given given_ToData_Unit: ToData[Unit] given tupleToData[A, B](evidence$1: ToData[A], evidence$2: ToData[B]): ToData[Tuple2[A, B]] val sirModule: Module val sirDeps: List[SIRModuleWithDeps] object scalus.uplc.builtin.ToDataMacros def toDataImpl[A](evidence$1: Type[A], x$1: Quotes): Expr[ToData[A]] trait scalus.uplc.builtin.ToDataOffchainApi given given_ToData_Byte: ToData[Byte] given given_ToData_Short: ToData[Short] given given_ToData_Int: ToData[Int] given given_ToData_Long: ToData[Long] given given_ToData_BigInteger: ToData[BigInteger] given given_ToData_Integer: ToData[Integer] given given_ToData_jsLong: ToData[java.lang.Long] given eitherToData[A, B](evidence$1: ToData[A], evidence$2: ToData[B]): ToData[Either[A, B]] object scalus.uplc.builtin.UTF8Decoder def decode(bytes: Array[Byte]): String class scalus.uplc.builtin.uplcIntrinsic object scalus.cardano.ledger.ArbitraryInstances trait scalus.cardano.ledger.ArbitraryInstances def genMapOfSizeFromArbitrary[A, B](from: Int, to: Int)(evidence$1: Arbitrary[A], evidence$2: Arbitrary[B]): Gen[immutable.Map[A, B]] def genVectorOfSizeFromArbitrary[A](from: Int, to: Int)(evidence$1: Arbitrary[A]): Gen[immutable.IndexedSeq[A]] def genSetOfSizeFromArbitrary[A](from: Int, to: Int)(evidence$1: Arbitrary[A]): Gen[immutable.Set[A]] given given_Arbitrary_Hash[HF, Purpose](evidence$1: HashSize[HF]): Arbitrary[Hash[HF, Purpose]] given given_Arbitrary_Anchor: Arbitrary[Anchor] given given_Arbitrary_Credential: Arbitrary[Credential] given given_Arbitrary_Coin: Arbitrary[Coin] given given_Arbitrary_AssetName: Arbitrary[AssetName] given given_Arbitrary_Language: Arbitrary[Language] given given_Arbitrary_AddressBytes: Arbitrary[AddressBytes] given given_Arbitrary_Slot: Arbitrary[Slot] given given_Arbitrary_ExUnits: Arbitrary[ExUnits] given given_Arbitrary_ExUnitPrices: Arbitrary[ExUnitPrices] given given_Arbitrary_CostModels: Arbitrary[CostModels] given given_Arbitrary_Constitution: Arbitrary[Constitution] given given_Arbitrary_KeepRaw[A](evidence$1: Arbitrary[A], evidence$2: Encoder[A]): Arbitrary[KeepRaw[A]] given given_Arbitrary_Sized[A](evidence$1: Arbitrary[A], evidence$2: Encoder[A]): Arbitrary[Sized[A]] def genMultiAsset(minPolicies: Int, maxPolicies: Int, minAssets: Int, maxAssets: Int): Gen[MultiAsset] def genMint(minPolicies: Int, maxPolicies: Int, minAssets: Int, maxAssets: Int): Gen[Mint] given given_Arbitrary_MultiAsset: Arbitrary[MultiAsset] given given_Arbitrary_Mint: Arbitrary[Mint] given given_Arbitrary_Value: Arbitrary[Value] given given_Arbitrary_DRep: Arbitrary[DRep] given given_Arbitrary_GovActionId: Arbitrary[GovActionId] given given_Arbitrary_OperationalCert: Arbitrary[OperationalCert] given given_Arbitrary_PoolMetadata: Arbitrary[PoolMetadata] given given_Arbitrary_DatumOption: Arbitrary[DatumOption] val TimelockGen: TimelockGen object scalus.cardano.ledger.ArbitraryInstances.TimelockGen val genKeyHash: Gen[AddrKeyHash] val genSlotNo: Gen[SlotNo] val genTimelock: Gen[Timelock] given given_Arbitrary_Script: Arbitrary[Script] given given_Arbitrary_ScriptRef: Arbitrary[ScriptRef] given given_Arbitrary_Timelock: Arbitrary[Timelock] given given_Arbitrary_TransactionInput: Arbitrary[TransactionInput] given given_Arbitrary_TransactionOutput: Arbitrary[TransactionOutput] given given_Arbitrary_ProtocolVersion: Arbitrary[ProtocolVersion] given given_Arbitrary_RewardAccount: Arbitrary[RewardAccount] given given_Arbitrary_NonNegativeInterval: Arbitrary[NonNegativeInterval] given given_Arbitrary_VrfCert: Arbitrary[VrfCert] given given_Arbitrary_BlockHeaderBody: Arbitrary[BlockHeaderBody] given given_Arbitrary_BlockHeader: Arbitrary[BlockHeader] given given_Arbitrary_Metadatum: Arbitrary[Metadatum] given given_Arbitrary_Word64: Arbitrary[Word64] given given_Arbitrary_AuxiliaryData: Arbitrary[AuxiliaryData] given given_Arbitrary_VKeyWitness: Arbitrary[VKeyWitness] given given_Arbitrary_BootstrapWitness: Arbitrary[BootstrapWitness] given given_Arbitrary_RedeemerTag: Arbitrary[RedeemerTag] given given_Arbitrary_Redeemer: Arbitrary[Redeemer] given given_Arbitrary_Redeemers: Arbitrary[Redeemers] given given_Arbitrary_Native: Arbitrary[Script.Native] given given_Arbitrary_PlutusV1: Arbitrary[Script.PlutusV1] given given_Arbitrary_PlutusV2: Arbitrary[Script.PlutusV2] given given_Arbitrary_PlutusV3: Arbitrary[Script.PlutusV3] given given_Arbitrary_PlutusV4: Arbitrary[Script.PlutusV4] given given_Arbitrary_TaggedOrderedSet[A](evidence$1: Arbitrary[A]): Arbitrary[TaggedOrderedSet[A]] given given_Arbitrary_TaggedOrderedStrictSet[A](evidence$1: Arbitrary[A]): Arbitrary[TaggedOrderedStrictSet[A]] given given_Arbitrary_TaggedSortedSet[A](evidence$1: Arbitrary[A], evidence$2: Ordering[A]): Arbitrary[TaggedSortedSet[A]] given given_Arbitrary_TaggedSortedMap[A, K](evidence$1: Arbitrary[A], evidence$2: Ordering[K], x$1: TaggedSortedMap.KeyOf[K, A]): Arbitrary[TaggedSortedMap[K, A]] given given_Arbitrary_TaggedSortedStrictMap[A, K](evidence$1: Arbitrary[A], evidence$2: Ordering[K], x$1: TaggedSortedStrictMap.KeyOf[K, A]): Arbitrary[TaggedSortedStrictMap[K, A]] given given_Arbitrary_TransactionWitnessSet: Arbitrary[TransactionWitnessSet] given given_Arbitrary_UnitInterval: Arbitrary[UnitInterval] given given_Arbitrary_ProposalProcedure: Arbitrary[ProposalProcedure] given given_Arbitrary_Set: Arbitrary[Set[ProposalProcedure]] given given_Arbitrary_Vote: Arbitrary[Vote] given given_Arbitrary_Voter: Arbitrary[Voter] given given_Arbitrary_VotingProcedure: Arbitrary[VotingProcedure] given arbVotingProcedureMap: Arbitrary[SortedMap[GovActionId, VotingProcedure]] given arbVotingProceduresMap: Arbitrary[SortedMap[Voter, SortedMap[GovActionId, VotingProcedure]]] given given_Arbitrary_VotingProcedures: Arbitrary[VotingProcedures] given given_Arbitrary_PoolVotingThresholds: Arbitrary[PoolVotingThresholds] given given_Arbitrary_DRepVotingThresholds: Arbitrary[DRepVotingThresholds] given given_Arbitrary_ProtocolParamUpdate: Arbitrary[ProtocolParamUpdate] given given_Arbitrary_GovAction: Arbitrary[GovAction] given given_Arbitrary_Relay: Arbitrary[Relay] given given_Arbitrary_Certificate: Arbitrary[Certificate] given given_Arbitrary_Withdrawals: Arbitrary[Withdrawals] given given_Arbitrary_TransactionBody: Arbitrary[TransactionBody] given given_Arbitrary_Block: Arbitrary[Block] given given_Arbitrary_BlockFile: Arbitrary[BlockFile] given given_Arbitrary_Transaction: Arbitrary[Transaction] object scalus.cardano.onchain.plutus.v3.ArbitraryInstances trait scalus.cardano.onchain.plutus.v3.ArbitraryInstances given given_Arbitrary_TxId: Arbitrary[TxId] given given_Arbitrary_TxOutRef: Arbitrary[TxOutRef] given given_Arbitrary_TxInInfo: Arbitrary[TxInInfo] given given_Arbitrary_TxInfo: Arbitrary[TxInfo] given given_Arbitrary_ScriptPurpose: Arbitrary[ScriptPurpose] enum scalus.testing.dsl.EvalSubject class scalus.testing.dsl.EvalTestBuilder def withConfig(newConfig: EvalConfig): EvalTestBuilder[A] def onAllBackends: EvalTestBuilder[A] def withUplcCli: EvalTestBuilder[A] def onVM(vm: PlutusVM): EvalTestBuilder[A] def expectSuccess(): EvalTestResult def expectTerm(term: Term): EvalTestResult def expectValue[V](value: V)(evidence$1: Constant.LiftValue[V]): EvalTestResult def expectFailure(): EvalTestResult def expectFailureWith(message: String): EvalTestResult def expectSameOnAllBackends(): EvalTestResult def expectBudgetWithin(memory: Long, steps: Long): EvalTestResult object scalus.testing.dsl.EvalTestDsl def eval(sir: SIR): EvalTestBuilder[SIR] def eval[A](compiled: CompiledPlutus[A]): EvalTestBuilder[A] def eval(term: Term): EvalTestBuilder[Term] def eval(program: Program): EvalTestBuilder[Program] case class scalus.testing.dsl.EvalTestResult val result: Result val config: EvalConfig def assertSuccess(): EvalTestResult def assertFailure(): EvalTestResult def assertFailureWith(message: String): EvalTestResult def assertTermEquals(expected: Term): EvalTestResult def assertValueEquals[V](expected: V)(evidence$1: Constant.LiftValue[V]): EvalTestResult def assertBudgetWithin(memory: Long, steps: Long): EvalTestResult def assertBudgetEquals(memory: Long, steps: Long): EvalTestResult def budget: ExUnits def logs: Seq[String] trait scalus.testing.kit.ArbitraryInstances class scalus.testing.kit.BaseValidatorTest given given_PlutusVM: PlutusVM class scalus.testing.kit.BaseValidatorTestJvm trait scalus.testing.kit.EvalTestKit def check(p: Prop, configParams: _*)(config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position): Assertion def check(p: Prop, prms: Parameters)(prettifier: Prettifier, pos: Position): Assertion def check[A1, A2, A3, A4, A5, A6, P](f: Function6[A1, A2, A3, A4, A5, A6, P], configParams: _*)(config: PropertyCheckConfiguration, p: Function1[P, Prop], a1: Arbitrary[A1], s1: Shrink[A1], pp1: Function1[A1, Pretty], a2: Arbitrary[A2], s2: Shrink[A2], pp2: Function1[A2, Pretty], a3: Arbitrary[A3], s3: Shrink[A3], pp3: Function1[A3, Pretty], a4: Arbitrary[A4], s4: Shrink[A4], pp4: Function1[A4, Pretty], a5: Arbitrary[A5], s5: Shrink[A5], pp5: Function1[A5, Pretty], a6: Arbitrary[A6], s6: Shrink[A6], pp6: Function1[A6, Pretty], prettifier: Prettifier, pos: Position): Assertion def check[A1, A2, A3, A4, A5, P](f: Function5[A1, A2, A3, A4, A5, P], configParams: _*)(config: PropertyCheckConfiguration, p: Function1[P, Prop], a1: Arbitrary[A1], s1: Shrink[A1], pp1: Function1[A1, Pretty], a2: Arbitrary[A2], s2: Shrink[A2], pp2: Function1[A2, Pretty], a3: Arbitrary[A3], s3: Shrink[A3], pp3: Function1[A3, Pretty], a4: Arbitrary[A4], s4: Shrink[A4], pp4: Function1[A4, Pretty], a5: Arbitrary[A5], s5: Shrink[A5], pp5: Function1[A5, Pretty], prettifier: Prettifier, pos: Position): Assertion def check[A1, A2, A3, A4, P](f: Function4[A1, A2, A3, A4, P], configParams: _*)(config: PropertyCheckConfiguration, p: Function1[P, Prop], a1: Arbitrary[A1], s1: Shrink[A1], pp1: Function1[A1, Pretty], a2: Arbitrary[A2], s2: Shrink[A2], pp2: Function1[A2, Pretty], a3: Arbitrary[A3], s3: Shrink[A3], pp3: Function1[A3, Pretty], a4: Arbitrary[A4], s4: Shrink[A4], pp4: Function1[A4, Pretty], prettifier: Prettifier, pos: Position): Assertion def check[A1, A2, A3, P](f: Function3[A1, A2, A3, P], configParams: _*)(config: PropertyCheckConfiguration, p: Function1[P, Prop], a1: Arbitrary[A1], s1: Shrink[A1], pp1: Function1[A1, Pretty], a2: Arbitrary[A2], s2: Shrink[A2], pp2: Function1[A2, Pretty], a3: Arbitrary[A3], s3: Shrink[A3], pp3: Function1[A3, Pretty], prettifier: Prettifier, pos: Position): Assertion def check[A1, A2, P](f: Function2[A1, A2, P], configParams: _*)(config: PropertyCheckConfiguration, p: Function1[P, Prop], a1: Arbitrary[A1], s1: Shrink[A1], pp1: Function1[A1, Pretty], a2: Arbitrary[A2], s2: Shrink[A2], pp2: Function1[A2, Pretty], prettifier: Prettifier, pos: Position): Assertion def check[A1, P](f: Function1[A1, P], configParams: _*)(config: PropertyCheckConfiguration, p: Function1[P, Prop], a1: Arbitrary[A1], s1: Shrink[A1], pp1: Function1[A1, Pretty], prettifier: Prettifier, pos: Position): Assertion def Arbitrary: Arbitrary.type def Gen: Gen.type def Shrink: Shrink.type def !==[A](x: A)(y: A @InlineParam)(using eq: Eq[A] @InlineParam): Boolean def <=>[A](self: A)(other: A @InlineParam)(evidence$1: Ord[A]): Order def ===[A](x: A)(y: A @InlineParam)(using eq: Eq[A] @InlineParam): Boolean object scalus.testing.kit.KeyPairGenerator def generateKeyPair(): Tuple2[ByteString, ByteString] enum scalus.testing.kit.Party val account: HdAccount val addrKeyHash: AddrKeyHash def address(network: Network): ShelleyAddress def address(using env: CardanoInfo): ShelleyAddress val signer: TransactionSigner object scalus.testing.kit.Party val Alice: Party val Bob: Party val Charles: Party val Dave: Party val Eve: Party val Faith: Party val Grace: Party val Hal: Party val Ivan: Party val Judy: Party val Kevin: Party val Laura: Party val Mallory: Party val Nick: Party val Oracle: Party val Peggy: Party val Sybil: Party val Trent: Party val Victor: Party val Wendy: Party val genParty: Gen[Party] val genParties: Gen[Seq[Party]] given given_Arbitrary_Party: Arbitrary[Party] trait scalus.testing.kit.ScalusTest def runScript(self: SIR)(using scalusOptions: Options)(scriptContext: ScriptContext, param: Option[Data]): Result def scriptV3(self: SIR)(using scalusOptions: Options)(errorTraces: Boolean): Program def runWithDebug(self: Program)(scriptContext: ScriptContext): Result def runWithProfile(self: Program)(scriptContext: ScriptContext)(using vm: PlutusVM): Result def runWithProfileReport(self: Program)(scriptContext: ScriptContext)(using vm: PlutusVM): Result def compareBudgetWithReferenceValue(testName: String, scalusBudget: ExUnits, refBudget: ExUnits, isPrintComparison: Boolean): Unit object scalus.testing.kit.ScalusTest object scalus.testing.kit.TestUtil val rootKeyHash: ByteString val rootTxHash: ByteString def mockPubKeyHash(variation: BigInt): PubKeyHash def mockScriptHash(variation: BigInt): ValidatorHash def mockTxOutRef(variation: BigInt, idx: BigInt): TxOutRef def mockTxInput(variation: BigInt, idx: BigInt): TransactionInput val testEnvironment: CardanoInfo val genesisHash: TransactionHash val testEvaluator: PlutusScriptEvaluator def createTestAddress(keyHash: String): ShelleyAddress def createTestAddress(addrKeyHash: AddrKeyHash): ShelleyAddress def genAdaOnlyPubKeyUtxo(party: Party, params: ProtocolParams, min: Coin)(using x$4: CardanoInfo): Gen[Utxo] def scriptContexts(tx: Transaction)(utxos: Utxos)(using env: CardanoInfo): Map[Redeemer, ScriptContext] def scriptContextsV1(tx: Transaction)(utxos: Utxos)(using x$3: CardanoInfo): Map[Redeemer, v1.ScriptContext] def scriptContextsV2(tx: Transaction)(utxos: Utxos)(using x$3: CardanoInfo): Map[Redeemer, v2.ScriptContext] def scriptContextsV3(tx: Transaction)(utxos: Utxos)(using x$3: CardanoInfo): Map[Redeemer, v3.ScriptContext] def getScriptContextV1(tx: Transaction)(utxos: Utxos, purpose: RedeemerPurpose)(using x$4: CardanoInfo): v1.ScriptContext def getScriptContextV2(tx: Transaction)(utxos: Utxos, purpose: RedeemerPurpose)(using x$4: CardanoInfo): v2.ScriptContext def getScriptContextV3(tx: Transaction)(utxos: Utxos, purpose: RedeemerPurpose)(using x$4: CardanoInfo): v3.ScriptContext