Contract.Transaction

type TxBlueprint (ctx :: Type) = { balancer :: TxBalancer Contract Error ctx, balancerCtx :: ctx, buildSteps :: Array TransactionBuilderStep }

Blueprint containing the steps and context required to construct and balance a transaction.

type TxReceipt = { submittedTx :: Transaction, txHash :: TransactionHash }

Represents the result of submitting a transaction via submitTxFromBlueprint, which includes the balanced signed transaction along with its hash.

balanceMultipleTxs :: forall (ctx :: Type). TxBalancer Contract Error ctx -> Array { balancerCtx :: ctx, transaction :: Transaction } -> Contract (Array Transaction)

Balances each transaction using the specified TxBalancer and locks the used inputs so that they cannot be reused by subsequent transactions.

balanceTx :: Warn (Text "Deprecated, use a standalone transaction balancer instead") => Transaction -> UtxoMap -> BalancerConstraints -> Contract Transaction

Balance a single transaction.

UtxoMap is a collection of UTxOs used as inputs that are coming from outside of the user wallet.

balanceTxE is a non-throwing version of this function.

Use balanceTxs to balance multiple transactions and prevent them from using the same input UTxOs.

balanceTxE :: Warn (Text "Deprecated, use a standalone transaction balancer instead (see `defaultBalancerWithErr`)") => Transaction -> UtxoMap -> BalancerConstraints -> Contract (Either BalanceTxError Transaction)

A variant of balanceTx that returns a balancer error value.

balanceTxs :: Warn (Text "Deprecated, use `balanceMultipleTxs` instead") => Array { balancerConstraints :: BalancerConstraints, transaction :: Transaction, usedUtxos :: UtxoMap } -> Contract (Array Transaction)

Balances each transaction using specified balancer constraint sets and locks the used inputs so that they cannot be reused by subsequent transactions.

buildTx :: Array TransactionBuilderStep -> Contract Transaction

createAdditionalUtxos :: forall (tx :: Type). Coercible tx Transaction => tx -> Contract UtxoMap

Builds an expected utxo set from transaction outputs. Predicts output references (TransactionInputs) for each output by calculating the transaction hash and indexing the outputs in the order they appear in the transaction. This function should be used for transaction chaining in conjunction with mustUseAdditionalUtxos balancer constraint.

getTxAuxiliaryData :: TransactionHash -> Contract (Either GetTxMetadataError AuxiliaryData)

Fetch transaction auxiliary data. Returns Right when the transaction exists and auxiliary data is not empty

hashTransaction :: Warn (Text "Deprecated: hashTransaction. Use Cardano.Types.Transaction.hash") => Transaction -> TransactionHash

lookupTxHash :: TransactionHash -> UtxoMap -> Array TransactionUnspentOutput

mkPoolPubKeyHash :: Bech32String -> Maybe PoolPubKeyHash

submit :: Transaction -> Contract TransactionHash

Submits a Transaction, which is the output of signTransaction.

submitE :: Transaction -> Contract (Either ClientError TransactionHash)

Submits a Transaction that normally should be retreived from signTransaction. Preserves the errors returned by the backend in the case they need to be inspected.

submitTxFromBlueprint :: forall (ctx :: Type). TxBlueprint ctx -> Contract TxReceipt

Builds, balances, signs, and submits a transaction defined by the given TxBlueprint. Returns a TxReceipt containing the submitted transaction and its hash.

submitTxFromBuildPlan :: Warn (Text "Deprecated, use `submitTxFromBlueprint` instead") => UtxoMap -> BalancerConstraints -> Array TransactionBuilderStep -> Contract Transaction

submitTxFromConstraints :: Warn (Text "Contract.TxConstraints is deprecated. Use `submitTxFromBlueprint` instead") => ScriptLookups -> TxConstraints -> Contract TransactionHash

withBalancedTx :: forall (ctx :: Type) (a :: Type). TxBalancer Contract Error ctx -> Transaction -> ctx -> (Transaction -> Contract a) -> Contract a

Execute an action on a balanced transaction (the provided balancer will be called). Within this function, all transaction inputs used by this transaction will be locked, so that they are not used in any other context. After the function completes, the locks will be removed. Errors will be thrown.

withBalancedTxs :: forall (ctx :: Type) (a :: Type). TxBalancer Contract Error ctx -> Array { balancerCtx :: ctx, transaction :: Transaction } -> (Array Transaction -> Contract a) -> Contract a

Execute an action on an array of balanced transactions (balanceMultipleTxs will be called). Within this function, all transaction inputs used by these transactions will be locked, so that they are not used in any other context. After the function completes, the locks will be removed. Errors will be thrown.

data GetTxMetadataError

Constructors

• GetTxMetadataTxNotFoundError
• GetTxMetadataMetadataEmptyOrMissingError
• GetTxMetadataClientError ClientError

Instances

• Eq GetTxMetadataError
• Show GetTxMetadataError

newtype Expected

Constructors

• Expected Value

Instances

• Generic Expected _
• Newtype Expected _
• Show Expected

data BalanceTxError

Errors conditions that may possibly arise during transaction balancing

Constructors

• BalanceInsufficientError Val Val
• CouldNotConvertScriptOutputToTxInput
• CouldNotGetCollateral
• InsufficientCollateralUtxos UtxoMap
• CouldNotGetUtxos
• CollateralReturnError
• CollateralReturnMinAdaValueCalcError Coin TransactionOutput
• ExUnitsEvaluationFailed Transaction TxEvaluationFailure
• InsufficientUtxoBalanceToCoverAsset String
• ReindexRedeemersError DetachedRedeemer
• UtxoLookupFailedFor TransactionInput UtxoMap
• UtxoMinAdaValueCalculationFailed

Instances

• Generic BalanceTxError _
• Show BalanceTxError

newtype Actual

Constructors

• Actual Value

Instances

• Generic Actual _
• Newtype Actual _
• Show Actual

explainBalanceTxError :: BalanceTxError -> String

calculateMinFee :: forall (r :: Row Type). CalculateMinFeeData r -> Transaction -> UtxoMap -> UInt -> Aff Coin

Calculate the minimum transaction fee.

newtype TransactionUnspentOutput

Constructors

• TransactionUnspentOutput { input :: TransactionInput, output :: TransactionOutput }

Instances

• Generic TransactionUnspentOutput _
• Newtype TransactionUnspentOutput _
• Eq TransactionUnspentOutput
• Ord TransactionUnspentOutput
• EncodeAeson TransactionUnspentOutput
• DecodeAeson TransactionUnspentOutput
• Show TransactionUnspentOutput
• AsCbor TransactionUnspentOutput

newtype TransactionOutput

Constructors

• TransactionOutput { address :: Address, amount :: Value, datum :: Maybe OutputDatum, scriptRef :: Maybe ScriptRef }

Instances

• Generic TransactionOutput _
• Newtype TransactionOutput _
• Eq TransactionOutput
• Ord TransactionOutput
• EncodeAeson TransactionOutput
• DecodeAeson TransactionOutput
• Show TransactionOutput
• AsCbor TransactionOutput
• Arbitrary TransactionOutput

newtype TransactionInput

Constructors

• TransactionInput { index :: UInt, transactionId :: TransactionHash }

Instances

• Newtype TransactionInput _
• Generic TransactionInput _
• Eq TransactionInput
• EncodeAeson TransactionInput
• DecodeAeson TransactionInput
• Ord TransactionInput
• Show TransactionInput
• FromData TransactionInput
• ToData TransactionInput
• Arbitrary TransactionInput
• Coarbitrary TransactionInput
• AsCbor TransactionInput

newtype TransactionHash

32-bytes blake2b256 hash of a tx body. NOTE. Plutus docs might incorrectly state that it uses SHA256 for this purposes.

Constructors

• TransactionHash TransactionHash

Instances

• Generic TransactionHash _
• Newtype TransactionHash _
• Eq TransactionHash
• Ord TransactionHash
• Show TransactionHash
• Arbitrary TransactionHash
• Coarbitrary TransactionHash
• FromData TransactionHash
• ToData TransactionHash
• AsCbor TransactionHash
• EncodeAeson TransactionHash
• DecodeAeson TransactionHash

data NativeScript

Constructors

• ScriptPubkey Ed25519KeyHash
• ScriptAll (Array NativeScript)
• ScriptAny (Array NativeScript)
• ScriptNOfK Int (Array NativeScript)
• TimelockStart Slot
• TimelockExpiry Slot

Instances

• Eq NativeScript
• Generic NativeScript _
• Ord NativeScript
• Show NativeScript
• Arbitrary NativeScript
• DecodeAeson NativeScript
• EncodeAeson NativeScript
• AsCbor NativeScript

newtype Epoch

Constructors

• Epoch UInt

Instances

• Newtype Epoch _
• Generic Epoch _
• Eq Epoch
• Ord Epoch
• EncodeAeson Epoch
• DecodeAeson Epoch
• Show Epoch

newtype DataHash

Constructors

• DataHash DataHash

Instances

• Generic DataHash _
• Newtype DataHash _
• Eq DataHash
• AsCbor DataHash
• EncodeAeson DataHash
• DecodeAeson DataHash
• Ord DataHash
• Show DataHash
• FromData DataHash
• ToData DataHash
• Arbitrary DataHash
• Coarbitrary DataHash

data OutputDatum

Constructors

• OutputDatumHash DataHash
• OutputDatum PlutusData

Instances

• Generic OutputDatum _
• Eq OutputDatum
• Ord OutputDatum
• Show OutputDatum
• HasPlutusSchema OutputDatum (ApPCons (MkField_ "OutputDatumHash" (MkIxK_ PNil Z)) (ApPCons (MkField_ "OutputDatum" (MkIxK_ PNil (S Z))) PNil))
• ToData OutputDatum
• FromData OutputDatum
• EncodeAeson OutputDatum
• DecodeAeson OutputDatum
• AsCbor OutputDatum
• Arbitrary OutputDatum

newtype PoolPubKeyHash

Constructors

• PoolPubKeyHash Ed25519KeyHash

Instances

• Newtype PoolPubKeyHash _
• Eq PoolPubKeyHash
• Ord PoolPubKeyHash
• Generic PoolPubKeyHash _
• ToData PoolPubKeyHash
• FromData PoolPubKeyHash
• AsCbor PoolPubKeyHash
• EncodeAeson PoolPubKeyHash
• DecodeAeson PoolPubKeyHash
• Show PoolPubKeyHash

data ScriptRef

Constructors

• NativeScriptRef NativeScript
• PlutusScriptRef PlutusScript

Instances

• Eq ScriptRef
• Ord ScriptRef
• Generic ScriptRef _
• Arbitrary ScriptRef
• Show ScriptRef
• AsCbor ScriptRef
• EncodeAeson ScriptRef
• DecodeAeson ScriptRef

newtype Transaction

Constructors

• Transaction { auxiliaryData :: Maybe AuxiliaryData, body :: TransactionBody, isValid :: Boolean, witnessSet :: TransactionWitnessSet }

Instances

• Newtype Transaction _
• Eq Transaction
• Generic Transaction _
• Ord Transaction
• Show Transaction
• AsCbor Transaction
• EncodeAeson Transaction
• DecodeAeson Transaction

empty :: Transaction

type CtlBalancerContext = { balancerConstraints :: BalancerConstraints, extraUtxos :: UtxoMap }

Additional context required by the default CTL balancer.

balancerConstraints: A set of rules that guide or modify the behavior of the balancer.

extraUtxos: Extra (non-wallet) utxos to be considered during balancing, typically used to resolve pre-specified inputs of the unbalanced transaction. See getInputVal in Cardano.Transaction.Balancer for further details.

type CtlBalancer (err :: Type) = TxBalancer Contract err CtlBalancerContext

emptyBalancerCtx :: CtlBalancerContext

defaultBalancerWithErr :: CtlBalancer BalanceTxError

Balances an unbalanced transaction using the specified balancer constraints.

defaultBalancer :: CtlBalancer Error

isTxConfirmed :: TransactionHash -> Contract Boolean

Check if a transaction is confirmed at the moment, i.e. if its UTxOs are available to spend. If you want to delay until a transaction is confirmed, use awaitTxConfirmed or its variants.

awaitTxConfirmedWithTimeoutSlots :: Int -> TransactionHash -> Contract Unit

Same as awaitTxConfirmed, but allows to specify a timeout in slots for waiting. Throws an exception on timeout. Will fail to confirm if the transaction includes no outputs. https://github.com/Plutonomicon/cardano-transaction-lib/issues/1293

awaitTxConfirmedWithTimeout :: Seconds -> TransactionHash -> Contract Unit

Same as awaitTxConfirmed, but allows to specify a timeout in seconds for waiting. Throws an exception on timeout. Will fail to confirm if the transaction includes no outputs. https://github.com/Plutonomicon/cardano-transaction-lib/issues/1293

awaitTxConfirmed :: TransactionHash -> Contract Unit

Wait until a transaction with given hash is confirmed. Use awaitTxConfirmedWithTimeout if you want to limit the time of waiting. Will fail to confirm if the transaction includes no outputs. https://github.com/Plutonomicon/cardano-transaction-lib/issues/1293

signTransaction :: Transaction -> Contract Transaction

Signs a transaction with potential failure.

type TxBalancer :: (Type -> Type) -> Type -> Type -> Typetype TxBalancer (m :: Type -> Type) (err :: Type) (ctx :: Type) = Transaction -> ctx -> m (Either err Transaction)