Class Transaction

Index

Constructors

Accessors

Methods

addCertificate addCollateral addInput addMint addOutput addProposalProcedure addReferenceInput addRequiredSigner addVotingProcedure addWithdrawal addWitness buildTransaction calculateFee calculateMinUtxoAmountBabbage calculateTxSize getAdditionalInputAda getAdditionalOutputAda getAuxiliaryData getAuxiliaryDataHashHex getBurnTokens getCertificates getCollateralAmount getCollateralOutput getCollaterals getDonationAmount getFee getInputAmount getInputs getMints getMintTokens getOutputAmount getOutputs getProposalProcedures getRedeemers getRequiredNativeScriptWitnesses getRequiredSigners getRequiredWitnesses getScriptIntegrityHash getTotalCollateral getTransactionHash getTreasuryAmount getTTL getValidityIntervalStart getVotingProcedures getWithdrawals hasInput isPlutusTransaction paymentTransaction prepareTransaction setAuxiliaryData setCollateralOutput setDonationAmount setFee setTotalCollateral setTreasuryAmount setTTL setValidityIntervalStart

Constructors

constructor

new Transaction(
__namedParameters: { protocolParams: ProtocolParams },
): Transaction
Parameters
- __namedParameters: { protocolParams: ProtocolParams }
Returns Transaction

Accessors

protocolParams

get protocolParams(): ProtocolParams

Returns ProtocolParams

Methods

addCertificate

addCertificate(certificate: Certificate): void
The method will add a certificate to the transaction to be included in cbor This method will automatically scan and include each unique required witnesses in the map to help sign the transaction
Parameters
- certificate: Certificate
  a certificate to include in the transaction
Returns void

addCollateral

addCollateral(input: CollateralInput): void
Parameters
- input: CollateralInput
Returns void

addInput

addInput(input: Input): void
Parameters
- input: Input
Returns void

addMint

addMint(mint: Mint): void
Parameters
- mint: Mint
Returns void

addOutput

addOutput(output: Output): void
Parameters
- output: Output
Returns void

addProposalProcedure

addProposalProcedure(proposalProcedure: ProposalProcedure): void
Parameters
- proposalProcedure: ProposalProcedure
Returns void

addReferenceInput

addReferenceInput(input: ReferenceInput): void
Adds a reference input. A Plutus script it holds, given as plutusScript or on the address credential, sets the script's language in the script integrity hash once the transaction runs that script, i.e. spends from, mints with, withdraws with, certifies with or votes with its hash.
Parameters
- input: ReferenceInput
Returns void

addRequiredSigner

addRequiredSigner(credential: HashCredential): void
Parameters
- credential: HashCredential
Returns void

addVotingProcedure

addVotingProcedure(votingProcedure: VotingProcedure): void
Parameters
- votingProcedure: VotingProcedure
Returns void

addWithdrawal

addWithdrawal(withdrawal: Withdrawal): void
Parameters
- withdrawal: Withdrawal
Returns void

addWitness

addWitness(witness: VKeyWitness): void
Parameters
- witness: VKeyWitness
Returns void

buildTransaction

buildTransaction(): { hash: string; payload: string }

Returns { hash: string; payload: string }

calculateFee

calculateFee(extraOutputs?: Output[]): bigint
Parameters
- OptionalextraOutputs: Output[]
Returns bigint

calculateMinUtxoAmountBabbage

calculateMinUtxoAmountBabbage(output: Output): bigint
Parameters
- output: Output
Returns bigint

calculateTxSize

calculateTxSize(extraOutputs?: Output[]): number
Parameters
- OptionalextraOutputs: Output[]
Returns number

getAdditionalInputAda

getAdditionalInputAda(): bigint

This method scans the certificates added in the transaction to calculate additional ADA available in inputs as part of the deposit refund. Essentially ADA to be considered as additional input due to deposit refunds.

Returns bigint
additional ADA available as input

getAdditionalOutputAda

getAdditionalOutputAda(): bigint
This method scans the certificates and proposal procedures added in the transaction to calculate additional ADA required for transaction validity.
1. deposits of stake key, stake key with delegation and DRep registrations
2. proposal procedure deposit ADA
3. donation amount
Returns bigint
additional ADA required for a valid transaction

getAuxiliaryData

getAuxiliaryData(): AuxiliaryData | undefined

Returns AuxiliaryData | undefined

getAuxiliaryDataHashHex

getAuxiliaryDataHashHex(): string | undefined

Returns string | undefined

getBurnTokens

getBurnTokens(): Token[]

Returns Token[]

getCertificates

getCertificates(): Certificate[]

Returns Certificate[]

getCollateralAmount

getCollateralAmount(): bigint

Returns bigint

getCollateralOutput

getCollateralOutput(): Output | undefined

Returns Output | undefined

getCollaterals

getCollaterals(): CollateralInput[]

Returns CollateralInput[]

getDonationAmount

getDonationAmount(): bigint | undefined

Returns bigint | undefined

getFee

getFee(): bigint

Returns bigint

getInputAmount

getInputAmount(): { ada: bigint; tokens: Token[] }

Returns { ada: bigint; tokens: Token[] }

getInputs

getInputs(): Input[]

Returns Input[]

getMints

getMints(): Mint[]

Returns Mint[]

getMintTokens

getMintTokens(): Token[]

Returns Token[]

getOutputAmount

getOutputAmount(): { ada: bigint; tokens: Token[] }

Returns { ada: bigint; tokens: Token[] }

getOutputs

getOutputs(): Output[]

Returns Output[]

getProposalProcedures

getProposalProcedures(): ProposalProcedure[]

Returns ProposalProcedure[]

getRedeemers

getRedeemers(): TaggedRedeemer[]

Every redeemer with the pointer the ledger identifies it by: what it's for (tag) and the index of the item it redeems. The redeemer is the object you passed in, so setting its exUnits, say from evaluating the transaction, updates the fee and what gets built.

Returns TaggedRedeemer[]

getRequiredNativeScriptWitnesses

getRequiredNativeScriptWitnesses(): Map<string, undefined>

Returns Map<string, undefined>

getRequiredSigners

getRequiredSigners(): Map<string, BipPath | undefined>

Returns Map<string, BipPath | undefined>

getRequiredWitnesses

getRequiredWitnesses(): Map<string, BipPath | undefined>

Returns Map<string, BipPath | undefined>

getScriptIntegrityHash

getScriptIntegrityHash(): Uint8Array<ArrayBufferLike> | undefined

Returns Uint8Array<ArrayBufferLike> | undefined

getTotalCollateral

getTotalCollateral(): bigint | undefined

Returns bigint | undefined

getTransactionHash

getTransactionHash(): Uint8Array

Returns Uint8Array

getTreasuryAmount

getTreasuryAmount(): bigint | undefined

Returns bigint | undefined

getTTL

getTTL(): number | undefined

Returns number | undefined

getValidityIntervalStart

getValidityIntervalStart(): number | undefined

Returns number | undefined

getVotingProcedures

getVotingProcedures(): VotingProcedure[]

Returns VotingProcedure[]

getWithdrawals

getWithdrawals(): Withdrawal[]

Returns Withdrawal[]

hasInput

hasInput(input: { index: number; txId: string }): boolean
Parameters
- input: { index: number; txId: string }
Returns boolean

isPlutusTransaction

isPlutusTransaction(): boolean

Returns boolean

paymentTransaction

paymentTransaction(
    __namedParameters: {
        auxiliaryData?: AuxiliaryData;
        changeAddress: CardanoAddress;
        inputs: Input[];
        outputs: Output[];
        ttl: number;
    },
): Transaction
Function for a simple send ADA transaction Provide necessary outputs, and available inputs, returns a final tx
Parameters
- __namedParameters: {
      auxiliaryData?: AuxiliaryData;
      changeAddress: CardanoAddress;
      inputs: Input[];
      outputs: Output[];
      ttl: number;
  }
Returns Transaction

prepareTransaction

prepareTransaction(
    __namedParameters: {
        changeAddress: CardanoAddress;
        collateralInputs?: CollateralInput[];
        inputs: Input[];
    },
): Transaction
Function to prepare transaction automatically There are other helper methods for preparing transactions that use this method This method should be used when you know what you are doing sets required inputs, fees, change etc resulting transaction is the final tx that can be built for signing

A transaction that runs Plutus scripts also gets as many of collateralInputs as it takes to cover the fee. A collateral return sends what a failing script wouldn't take back to the change address, and the total collateral is set to what it would take. Both replace any collateral return or total collateral set before.

Call it again after changing the transaction, such as setting execution units from an evaluation, and it balances the transaction again. It replaces the change outputs it added before and keeps the inputs and collateral it spent, adding more if the fee needs them. When it throws, the transaction is left as it was.

When the transaction needs optional protocol parameters that are missing, such as the Plutus ones, it throws an error naming all of them.
Parameters
- __namedParameters: {
      changeAddress: CardanoAddress;
      collateralInputs?: CollateralInput[];
      inputs: Input[];
  }
Returns Transaction

setAuxiliaryData

setAuxiliaryData(auxData: AuxiliaryData): void
Parameters
- auxData: AuxiliaryData
Returns void

setCollateralOutput

setCollateralOutput(output: Output | undefined): void
Parameters
- output: Output | undefined
Returns void

setDonationAmount

setDonationAmount(amount: bigint): void
Parameters
- amount: bigint
Returns void

setFee

setFee(fee: bigint): void
Parameters
- fee: bigint
Returns void

setTotalCollateral

setTotalCollateral(amount: bigint): void
Parameters
- amount: bigint
Returns void

setTreasuryAmount

setTreasuryAmount(amount: bigint): void
Parameters
- amount: bigint
Returns void

setTTL

setTTL(ttl: number): void
Parameters
- ttl: number
Returns void

setValidityIntervalStart

setValidityIntervalStart(validityIntervalStart: number): void
Parameters
- validityIntervalStart: number
Returns void