ApolloBuilder.go

package apollo

import (
	"bytes"
	"crypto/ed25519"
	"encoding/hex"
	"errors"
	"fmt"
	"slices"
	"strconv"

	"github.com/Salvionied/apollo/apollotypes"
	"github.com/Salvionied/apollo/constants"
	"github.com/Salvionied/apollo/serialization"
	"github.com/Salvionied/apollo/serialization/Address"
	"github.com/Salvionied/apollo/serialization/Amount"
	"github.com/Salvionied/apollo/serialization/Certificate"
	"github.com/Salvionied/apollo/serialization/HDWallet"
	"github.com/Salvionied/apollo/serialization/Key"
	"github.com/Salvionied/apollo/serialization/Metadata"
	"github.com/Salvionied/apollo/serialization/MultiAsset"
	"github.com/Salvionied/apollo/serialization/NativeScript"
	"github.com/Salvionied/apollo/serialization/PlutusData"
	"github.com/Salvionied/apollo/serialization/Redeemer"
	RelayPkg "github.com/Salvionied/apollo/serialization/Relay"
	"github.com/Salvionied/apollo/serialization/Transaction"
	"github.com/Salvionied/apollo/serialization/TransactionBody"
	"github.com/Salvionied/apollo/serialization/TransactionInput"
	"github.com/Salvionied/apollo/serialization/TransactionOutput"
	"github.com/Salvionied/apollo/serialization/TransactionWitnessSet"
	"github.com/Salvionied/apollo/serialization/UTxO"
	"github.com/Salvionied/apollo/serialization/Value"
	"github.com/Salvionied/apollo/serialization/VerificationKeyWitness"
	"github.com/Salvionied/apollo/serialization/Withdrawal"
	"github.com/Salvionied/apollo/txBuilding/Backend/Base"
	"github.com/Salvionied/apollo/txBuilding/Utils"
	"github.com/fxamacker/cbor/v2"
)

const (
	EX_MEMORY_BUFFER = 0.2
	EX_STEP_BUFFER   = 0.2
	STAKE_DEPOSIT    = 2_000_000
)

type Apollo struct {
	Context                  Base.ChainContext
	payments                 []PaymentI
	isEstimateRequired       bool
	auxiliaryData            *Metadata.AuxiliaryData
	utxos                    []UTxO.UTxO
	preselectedUtxos         []UTxO.UTxO
	inputAddresses           []Address.Address
	tx                       *Transaction.Transaction
	datums                   []PlutusData.PlutusData
	requiredSigners          []serialization.PubKeyHash
	v1scripts                []PlutusData.PlutusV1Script
	v2scripts                []PlutusData.PlutusV2Script
	v3scripts                []PlutusData.PlutusV3Script
	redeemers                []Redeemer.Redeemer
	redeemersToUTxO          map[string]Redeemer.Redeemer
	stakeRedeemers           map[string]Redeemer.Redeemer
	mintRedeemers            map[string]Redeemer.Redeemer
	mint                     []Unit
	collaterals              []UTxO.UTxO
	Fee                      int64
	FeePadding               int64
	Ttl                      int64
	ValidityStart            int64
	collateralAmount         int
	totalCollateral          int64
	referenceInputs          []TransactionInput.TransactionInput
	referenceInputsV3        []TransactionInput.TransactionInput
	collateralReturn         *TransactionOutput.TransactionOutput
	withdrawals              *Withdrawal.Withdrawal
	certificates             *Certificate.Certificates
	nativescripts            []NativeScript.NativeScript
	usedUtxos                []string
	referenceScripts         []PlutusData.ScriptHashable
	wallet                   apollotypes.Wallet
	scriptHashes             []string
	forceFee                 bool
	additionalUtxos          []UTxO.UTxO
	referencedScriptVersions map[string]bool
	// err records the first error encountered during builder method calls.
	// It is checked and returned by Complete(), so individual builder methods
	// do not propagate errors directly and callers must inspect the result of Complete().
	err error
}

// Plutus script version identifiers used in the builder.
const PlutusV1 = "V1"
const PlutusV2 = "V2"
const PlutusV3 = "V3"

// PlutusV1CostModelKey returns the CBOR map key for the
// Plutus V1 cost model in the script data hash.
func PlutusV1CostModelKey() serialization.CustomBytes {
	return serialization.CustomBytes{Value: "00"}
}

// PlutusV2CostModelKey returns the CBOR map key for the
// Plutus V2 cost model in the script data hash.
func PlutusV2CostModelKey() serialization.CustomBytes {
	return serialization.NewCustomBytesInt(1)
}

// PlutusV3CostModelKey returns the CBOR map key for the
// Plutus V3 cost model in the script data hash.
func PlutusV3CostModelKey() serialization.CustomBytes {
	return serialization.NewCustomBytesInt(2)
}

/*
*

	New creates and initializes a new Apollo instance with the specified chain context,


	in which sets up various internal data structures for building and handling transactions.

	Params:


		cc (Base.ChainContext): The chain context to use for transaction building.

	Returns:
		*Apollo: A pointer to the initialized Apollo instance.
*/
func New(cc Base.ChainContext) *Apollo {
	return &Apollo{
		Context:                  cc,
		payments:                 []PaymentI{},
		isEstimateRequired:       false,
		auxiliaryData:            &Metadata.AuxiliaryData{},
		utxos:                    []UTxO.UTxO{},
		preselectedUtxos:         []UTxO.UTxO{},
		inputAddresses:           []Address.Address{},
		tx:                       nil,
		datums:                   make([]PlutusData.PlutusData, 0),
		requiredSigners:          make([]serialization.PubKeyHash, 0),
		v1scripts:                make([]PlutusData.PlutusV1Script, 0),
		v2scripts:                make([]PlutusData.PlutusV2Script, 0),
		redeemers:                make([]Redeemer.Redeemer, 0),
		redeemersToUTxO:          make(map[string]Redeemer.Redeemer),
		stakeRedeemers:           make(map[string]Redeemer.Redeemer),
		mint:                     make([]Unit, 0),
		collaterals:              make([]UTxO.UTxO, 0),
		Fee:                      0,
		FeePadding:               0,
		usedUtxos:                make([]string, 0),
		referenceInputs:          make([]TransactionInput.TransactionInput, 0),
		referenceInputsV3:        make([]TransactionInput.TransactionInput, 0),
		referenceScripts:         make([]PlutusData.ScriptHashable, 0),
		mintRedeemers:            make(map[string]Redeemer.Redeemer),
		referencedScriptVersions: make(map[string]bool),
	}
}

/*
*

	GetWallet returns the wallet associated with the Apollo instance.

	Returns:
		apollotypes.Wallet: The wallet associated with the Apollo instance.
*/
func (b *Apollo) GetWallet() apollotypes.Wallet {
	return b.wallet
}

/*
*

	AddInput appends one or more UTxOs to the list of preselected
	UTxOs for transaction inputs.

	Params:
		utxos (...UTxO.UTxO): A set of UTxOs to be added as inputs.

	Returns:
		*Apollo: A pointer to the modified Apollo instance.
*/
func (b *Apollo) AddInput(utxos ...UTxO.UTxO) *Apollo {
	b.preselectedUtxos = append(b.preselectedUtxos, utxos...)
	for _, utxo := range utxos {
		b.usedUtxos = append(b.usedUtxos, utxo.GetKey())
	}
	return b
}

/*
*

	ConsumeUTxO adds a UTxO as an input to the transaction and deducts the specified payments from it.

	Params:
		utxo (UTxO.UTxO): The UTxO to be consumed as an input.
		payments (...PaymentI): A set of payments to be deducted from the UTxO.

	Returns:
		*Apollo: A pointer to the modified Apollo instance.
		error: An error if the payments exceed the UTxO value.
*/
func (b *Apollo) ConsumeUTxO(
	utxo UTxO.UTxO,
	payments ...PaymentI,
) (*Apollo, error) {
	b.preselectedUtxos = append(b.preselectedUtxos, utxo)
	selectedValue := utxo.Output.GetAmount()
	for _, payment := range payments {
		selectedValue = selectedValue.Sub(payment.ToValue())
	}
	if selectedValue.Less(Value.Value{}) {
		return nil, errors.New("ConsumeUTxO: payments exceed UTxO value")
	}
	b.payments = append(b.payments, payments...)
	selectedValue = selectedValue.RemoveZeroAssets()
	p := NewPaymentFromValue(utxo.Output.GetAddress(), selectedValue)
	b.payments = append(b.payments, p)
	return b, nil
}

/*
*

		ConsumeAssetsFromUtxo adds a UTxO as an input to the transaction and deducts the specified asset payments from it.

	 	Params:
	   		utxo (UTxO.UTxO): The UTxO to be consumed as an input.


	   		payments (...PaymentI): Asset payments to be deducted from the UTxO.

	 	Returns:
		   	*Apollo: A pointer to the modified Apollo instance.
		   	error: An error if the payments exceed the UTxO value.
*/
func (b *Apollo) ConsumeAssetsFromUtxo(
	utxo UTxO.UTxO,
	payments ...PaymentI,
) (*Apollo, error) {
	b.preselectedUtxos = append(b.preselectedUtxos, utxo)
	selectedValue := utxo.Output.GetAmount()
	for _, payment := range payments {
		selectedValue = selectedValue.Sub(
			Value.SimpleValue(0, payment.ToValue().GetAssets()),
		)
	}
	if selectedValue.Less(Value.Value{}) {
		return nil, errors.New(
			"ConsumeAssetsFromUtxo: payments exceed UTxO value",
		)
	}
	b.payments = append(b.payments, payments...)
	selectedValue = selectedValue.RemoveZeroAssets()
	p := NewPaymentFromValue(utxo.Output.GetAddress(), selectedValue)
	b.payments = append(b.payments, p)
	return b, nil
}

/*
*

	AddLoadedUTxOs appends one or more UTxOs to the list of loaded UTxOs.

	Params:
		utxos (...UTxO.UTxO): A set of UTxOs to be added to the loaded UTxOs.

	Returns:
		*Apollo: A pointer to the modified Apollo instance.
*/
func (b *Apollo) AddLoadedUTxOs(utxos ...UTxO.UTxO) *Apollo {
	b.utxos = append(b.utxos, utxos...)
	return b
}

// SetAdditionalUTxOs sets extra UTxOs to pass to the backend
// during transaction evaluation (e.g. for reference inputs).
func (b *Apollo) SetAdditionalUTxOs(
	utxos []UTxO.UTxO,
) *Apollo {
	b.additionalUtxos = utxos
	return b
}

// AddReferenceScriptV1 marks that the transaction references
// a Plutus V1 script, ensuring the V1 cost model is included
// in the script data hash.
func (b *Apollo) AddReferenceScriptV1() *Apollo {
	b.referencedScriptVersions[PlutusV1] = true
	return b
}

// AddReferenceScriptV2 marks that the transaction references
// a Plutus V2 script, ensuring the V2 cost model is included
// in the script data hash.
func (b *Apollo) AddReferenceScriptV2() *Apollo {
	b.referencedScriptVersions[PlutusV2] = true
	return b
}

// AddReferenceScriptV3 marks that the transaction references
// a Plutus V3 script, ensuring the V3 cost model is included
// in the script data hash.
func (b *Apollo) AddReferenceScriptV3() *Apollo {
	b.referencedScriptVersions[PlutusV3] = true
	return b
}

/*
*

	AddInputAddress appends an input address to the list of input addresses for the transaction.

	Params:
		address (Address.Address): The input address to be added.

	Returns:
		*Apollo: A pointer to the modified Apollo instance.
*/
func (b *Apollo) AddInputAddress(address Address.Address) *Apollo {
	b.inputAddresses = append(b.inputAddresses, address)
	return b

}

/*
*

	AddInputAddressFromBech32 decodes a Bech32 address and
	appends it to the list of input addresses for the transaction.

	Params:
		address (string): The Bech32 address to be decoded and added

	Returns:
		*Apollo: A pointer to the modified Apollo instance.
*/
func (b *Apollo) AddInputAddressFromBech32(address string) *Apollo {
	decoded_addr, _ := Address.DecodeAddress(address)
	b.inputAddresses = append(b.inputAddresses, decoded_addr)
	return b
}

/*
*

	AddPayment appends a payment to the list of payments for the transaction.

	Params:
		payment (PaymentI): The payment to be added.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with the payment added.
*/
func (b *Apollo) AddPayment(payment PaymentI) *Apollo {
	b.payments = append(b.payments, payment)
	return b
}

/*
*

	PayToAddressBech32 creates a payment to the specified Bech32 address
	with the given lovelace and units.

	Params:
		address (string): The Bech32 address to which the payment will be made.
		lovelace (int): The amount in lovelace to be paid.
		units (...Unit): The units (assets) to be paid along with the lovelace.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with the payment added.
*/
func (b *Apollo) PayToAddressBech32(
	address string,
	lovelace int,
	units ...Unit,
) *Apollo {
	if b.err != nil {
		return b
	}
	decoded_addr, err := Address.DecodeAddress(address)
	if err != nil {
		if b.err == nil {
			b.err = err
		}
		return b
	}
	return b.AddPayment(
		&Payment{Lovelace: lovelace, Receiver: decoded_addr, Units: units},
	)
}

/*
*

		PayToAddress creates a payment to the specified address with the given lovelace and units,
		then adds it to the list of payment.

		Params:
			address (Address.Address): The recipient's address for the payment.
	   		lovelace (int): The amount in lovelace to send in the payment.
	   		units (...Unit): A set of units to include in the payment.

		Returns:


	*Apollo: A pointer to the modified Apollo instance with the payment added.
*/
func (b *Apollo) PayToAddress(
	address Address.Address,
	lovelace int,
	units ...Unit,
) *Apollo {
	if b.err != nil {
		return b
	}
	return b.AddPayment(&Payment{Lovelace: lovelace, Receiver: address, Units: units})
}

/*
*

		AddDatum appends a Plutus datum to the list of data associated with the Apollo instance.

		Params:
	   		pd (*PlutusData.PlutusData): The Plutus datum to be added.

		Returns:


	*Apollo: A pointer to the modified Apollo instance with the datum added.
*/
func (b *Apollo) AddDatum(pd *PlutusData.PlutusData) *Apollo {
	b.datums = append(b.datums, *pd)
	return b
}

/*
*

	PayToContractAsHash creates a payment to a smart
	contract address using a pre-computed datum hash
	instead of inline datum data.

	Params:

		contractAddress (Address.Address): The contract
		  address to send the payment to.
		pdHash ([]byte): The pre-computed datum hash.
		lovelace (int): The amount in lovelace to send.
		isInline (bool): Whether the datum is inline.
		units (...Unit): Units to include in the payment.

	Returns:

		*Apollo: A pointer to the modified Apollo instance.
*/
func (b *Apollo) PayToContractAsHash(
	contractAddress Address.Address,
	pdHash []byte,
	lovelace int,
	isInline bool,
	units ...Unit,
) *Apollo {
	b = b.AddPayment(
		&Payment{
			Lovelace:  lovelace,
			Receiver:  contractAddress,
			Units:     units,
			Datum:     nil,
			DatumHash: pdHash,
			IsInline:  false,
		},
	)
	return b
}

/*
*

	PayToContract creates a payment to a smart contract address and includes a Plutus datum, which


	 	is added to the list of payments, and if a datum is provided, it is added to the data list.

		Params:


	contractAddress (Address.Address): The smart contract address to send the payment to.
	pd (*PlutusData.PlutusData): Plutus datum to include in the payment.
	lovelace (int): The amount in lovelace to send in the payment.
	isInline (bool): Indicates if the payment is inline with the datum.
	units (...Unit): A set of units to include in the payment.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with the payment and datum added.
*/
func (b *Apollo) PayToContract(
	contractAddress Address.Address,
	pd *PlutusData.PlutusData,
	lovelace int,
	isInline bool,
	units ...Unit,
) *Apollo {
	if b.err != nil {
		return b
	}
	if isInline {
		b = b.AddPayment(
			&Payment{Lovelace: lovelace, Receiver: contractAddress, Units: units, Datum: pd, IsInline: isInline},
		)
	} else if pd != nil {
		dataHash, err := PlutusData.PlutusDataHash(pd)
		if err != nil {
			if b.err == nil {
				b.err = err
			}
			return b
		}
		b = b.AddPayment(&Payment{Lovelace: lovelace, Receiver: contractAddress, Units: units, Datum: pd, DatumHash: dataHash.Payload})
	} else {
		b = b.AddPayment(&Payment{Lovelace: lovelace, Receiver: contractAddress, Units: units})
	}
	if pd != nil && !isInline {
		b = b.AddDatum(pd)
	}
	return b
}

// PayToAddressWithV1ReferenceScript creates a payment to the specified address
// with a Plutus V1 reference script attached to the output.
func (b *Apollo) PayToAddressWithV1ReferenceScript(
	address Address.Address,
	lovelace int,
	script PlutusData.PlutusV1Script,
	units ...Unit,
) *Apollo {
	if b.err != nil {
		return b
	}
	sr, err := PlutusData.NewV1ScriptRef(script)
	if err != nil {
		if b.err == nil {
			b.err = err
		}
		return b
	}
	return b.AddPayment(&Payment{Lovelace: lovelace, Receiver: address, Units: units, ScriptRef: &sr})
}

// PayToAddressWithV2ReferenceScript creates a payment to the specified address
// with a Plutus V2 reference script attached to the output.
func (b *Apollo) PayToAddressWithV2ReferenceScript(
	address Address.Address,
	lovelace int,
	script PlutusData.PlutusV2Script,
	units ...Unit,
) *Apollo {
	if b.err != nil {
		return b
	}
	sr, err := PlutusData.NewV2ScriptRef(script)
	if err != nil {
		if b.err == nil {
			b.err = err
		}
		return b
	}
	return b.AddPayment(&Payment{Lovelace: lovelace, Receiver: address, Units: units, ScriptRef: &sr})
}

// PayToAddressWithV3ReferenceScript creates a payment to the specified address
// with a Plutus V3 reference script attached to the output.
func (b *Apollo) PayToAddressWithV3ReferenceScript(
	address Address.Address,
	lovelace int,
	script PlutusData.PlutusV3Script,
	units ...Unit,
) *Apollo {
	if b.err != nil {
		return b
	}
	sr, err := PlutusData.NewV3ScriptRef(script)
	if err != nil {
		if b.err == nil {
			b.err = err
		}
		return b
	}
	return b.AddPayment(&Payment{Lovelace: lovelace, Receiver: address, Units: units, ScriptRef: &sr})
}

// PayToContractWithV1ReferenceScript creates a payment to a contract address with a datum
// and a Plutus V1 reference script attached to the output.
func (b *Apollo) PayToContractWithV1ReferenceScript(
	contractAddress Address.Address,
	pd *PlutusData.PlutusData,
	lovelace int,
	isInline bool,
	script PlutusData.PlutusV1Script,
	units ...Unit,
) *Apollo {
	if b.err != nil {
		return b
	}
	sr, err := PlutusData.NewV1ScriptRef(script)
	if err != nil {
		if b.err == nil {
			b.err = err
		}
		return b
	}
	return b.payToContractWithScriptRef(contractAddress, pd, lovelace, isInline, &sr, units...)
}

// PayToContractWithV2ReferenceScript creates a payment to a contract address with a datum
// and a Plutus V2 reference script attached to the output.
func (b *Apollo) PayToContractWithV2ReferenceScript(
	contractAddress Address.Address,
	pd *PlutusData.PlutusData,
	lovelace int,
	isInline bool,
	script PlutusData.PlutusV2Script,
	units ...Unit,
) *Apollo {
	if b.err != nil {
		return b
	}
	sr, err := PlutusData.NewV2ScriptRef(script)
	if err != nil {
		if b.err == nil {
			b.err = err
		}
		return b
	}
	return b.payToContractWithScriptRef(contractAddress, pd, lovelace, isInline, &sr, units...)
}

// PayToContractWithV3ReferenceScript creates a payment to a contract address with a datum
// and a Plutus V3 reference script attached to the output.
func (b *Apollo) PayToContractWithV3ReferenceScript(
	contractAddress Address.Address,
	pd *PlutusData.PlutusData,
	lovelace int,
	isInline bool,
	script PlutusData.PlutusV3Script,
	units ...Unit,
) *Apollo {
	if b.err != nil {
		return b
	}
	sr, err := PlutusData.NewV3ScriptRef(script)
	if err != nil {
		if b.err == nil {
			b.err = err
		}
		return b
	}
	return b.payToContractWithScriptRef(contractAddress, pd, lovelace, isInline, &sr, units...)
}

// payToContractWithScriptRef is a helper that creates a contract payment with a reference script.
// It handles both inline datums and datum hashes, and adds the datum to the witness set when not inline.
func (b *Apollo) payToContractWithScriptRef(
	contractAddress Address.Address,
	pd *PlutusData.PlutusData,
	lovelace int,
	isInline bool,
	sr *PlutusData.ScriptRef,
	units ...Unit,
) *Apollo {
	if b.err != nil {
		return b
	}
	if isInline {
		b = b.AddPayment(
			&Payment{Lovelace: lovelace, Receiver: contractAddress, Units: units, Datum: pd, IsInline: isInline, ScriptRef: sr},
		)
	} else if pd != nil {
		dataHash, err := PlutusData.PlutusDataHash(pd)
		if err != nil {
			if b.err == nil {
				b.err = err
			}
			return b
		}
		b = b.AddPayment(&Payment{Lovelace: lovelace, Receiver: contractAddress, Units: units, Datum: pd, DatumHash: dataHash.Payload, ScriptRef: sr})
	} else {
		b = b.AddPayment(&Payment{Lovelace: lovelace, Receiver: contractAddress, Units: units, ScriptRef: sr})
	}
	if pd != nil && !isInline {
		b = b.AddDatum(pd)
	}
	return b
}

/*
*

	AddRequiredSignerFromBech32 decodes an address in Bech32 format and adds
	its payment and staking parts as required signers.

	Params:


	address (string): The Bech32-encoded address to decode and add its parts as required signers.


	addPaymentPart (bool): Indicates whether to add the payment part as a required signer.


	   		addStakingPart (bool): Indicates whether to add the staking part as a required signer.

		Returns:


	*Apollo: A pointer to the modified Apollo instance with the required signers added.
*/
func (b *Apollo) AddRequiredSignerFromBech32(
	address string,
	addPaymentPart, addStakingPart bool,
) *Apollo {
	decoded_addr, _ := Address.DecodeAddress(address)
	if addPaymentPart {
		b.requiredSigners = append(
			b.requiredSigners,
			serialization.PubKeyHash(decoded_addr.PaymentPart[0:28]),
		)

	}
	if addStakingPart {
		b.requiredSigners = append(
			b.requiredSigners,
			serialization.PubKeyHash(decoded_addr.StakingPart[0:28]),
		)
	}
	return b

}

/*
*

		AddRequiredSigner appends a public key hash to the list of required signers.

	 	Params:


	  		pkh (serialization.PubKeyHash): The public key hash to add as a required signer.

		Returns:


	*Apollo: A pointer to the modified Apollo instance with the required signer added.
*/
func (b *Apollo) AddRequiredSigner(pkh serialization.PubKeyHash) *Apollo {
	b.requiredSigners = append(b.requiredSigners, pkh)
	return b
}

/*
*

		AddRequiredSignerFromAddress extracts the payment and staking parts from an address and adds them as required signers.

	 	Params:


	address (Address.Address): The address from which to extract the parts and add them as required signers.


	addPaymentPart (bool): Indicates whether to add the payment part as a required signer.


	  		addStakingPart (bool): Indicates whether to add the staking part as a required signer.

		Returns:


	*Apollo: A pointer to the modified Apollo instance with the required signers added.
*/
func (b *Apollo) AddRequiredSignerFromAddress(
	address Address.Address,
	addPaymentPart, addStakingPart bool,
) *Apollo {
	if addPaymentPart {
		pkh := serialization.PubKeyHash(address.PaymentPart)

		b.requiredSigners = append(b.requiredSigners, pkh)

	}
	if addStakingPart {
		pkh := serialization.PubKeyHash(address.StakingPart)

		b.requiredSigners = append(b.requiredSigners, pkh)

	}
	return b
}

func (b *Apollo) SetFeePadding(padding int64) *Apollo {
	b.FeePadding = padding
	return b
}

/**
buildOutputs constructs and returns the transaction outputs based on the payments.

Returns:
	[]TransactionOutput.TransactionOutput: A slice of transaction outputs.
*/

func (b *Apollo) buildOutputs() []TransactionOutput.TransactionOutput {
	outputs := make([]TransactionOutput.TransactionOutput, 0, len(b.payments))
	for _, payment := range b.payments {
		outputs = append(outputs, *payment.ToTxOut())
	}
	return outputs

}

/*
*

	buildWitnessSet constructs and returns the witness set for the transaction.

	Returns:


	TransactionWitnessSet.TransactionWitnessSet: The transaction's witness set.
*/
func (b *Apollo) buildWitnessSet() TransactionWitnessSet.TransactionWitnessSet {
	plutusdata := make([]PlutusData.PlutusData, 0, len(b.datums))
	plutusdata = append(plutusdata, b.datums...)
	return TransactionWitnessSet.TransactionWitnessSet{
		NativeScripts:  b.nativescripts,
		PlutusV1Script: b.v1scripts,
		PlutusV2Script: b.v2scripts,
		PlutusV3Script: b.v3scripts,
		PlutusData:     PlutusData.PlutusIndefArray(plutusdata),
		Redeemer:       b.redeemers,
	}
}

/*
*

	buildFakeWitnessSet constructs and returns a fake witness set used for testing.

	Returns:
		TransactionWitnessSet.TransactionWitnessSet: A fake witness set for testing.
*/
func (b *Apollo) buildFakeWitnessSet() TransactionWitnessSet.TransactionWitnessSet {
	plutusdata := make([]PlutusData.PlutusData, 0, len(b.datums))
	plutusdata = append(plutusdata, b.datums...)
	fakeVkWitnesses := make(
		[]VerificationKeyWitness.VerificationKeyWitness,
		0,
		1+len(b.requiredSigners),
	)
	fakeVkWitnesses = append(
		fakeVkWitnesses,
		VerificationKeyWitness.VerificationKeyWitness{
			Vkey:      constants.FAKE_VKEY,
			Signature: constants.FAKE_SIGNATURE},
	)
	for range b.requiredSigners {
		fakeVkWitnesses = append(
			fakeVkWitnesses,
			VerificationKeyWitness.VerificationKeyWitness{
				Vkey:      constants.FAKE_VKEY,
				Signature: constants.FAKE_SIGNATURE},
		)
	}
	return TransactionWitnessSet.TransactionWitnessSet{
		NativeScripts:  b.nativescripts,
		PlutusV1Script: b.v1scripts,
		PlutusV2Script: b.v2scripts,
		PlutusV3Script: b.v3scripts,
		PlutusData:     PlutusData.PlutusIndefArray(plutusdata),
		Redeemer:       b.redeemers,
		VkeyWitnesses:  fakeVkWitnesses,
	}
}

/**
scriptDataHash computes the hash of script data based on redeemers and datums.

Returns:
	*serialization.ScriptDataHash: The computed script data hash.
	error: An error if the scriptDataHash fails.
*/

func (b *Apollo) scriptDataHash() (*serialization.ScriptDataHash, error) {
	if len(b.datums) == 0 && len(b.redeemers) == 0 {
		return nil, nil
	}
	redeemers := b.redeemers
	PV1Scripts := b.v1scripts
	PV2Scripts := b.v2scripts
	PV3Scripts := b.v3scripts
	datums := b.datums
	usedCms := map[any]cbor.Marshaler{}
	if len(redeemers) > 0 {
		if len(PV1Scripts) > 0 ||
			b.referencedScriptVersions[PlutusV1] {
			key := PlutusV1CostModelKey()
			cm := b.Context.CostModelsV1()
			if len(cm) > 0 {
				usedCms[key] =
					PlutusData.CostModelV1(cm)
			} else {
				usedCms[key] =
					PlutusData.PLUTUSV1COSTMODEL
			}
		}
		if len(PV2Scripts) > 0 ||
			len(b.referenceInputs) > 0 ||
			b.referencedScriptVersions[PlutusV2] {
			key := PlutusV2CostModelKey()
			cm := b.Context.CostModelsV2()
			if len(cm) > 0 {
				usedCms[key] =
					PlutusData.CostModelV2(cm)
			} else {
				usedCms[key] =
					PlutusData.PLUTUSV2COSTMODEL
			}
		}
		if len(PV3Scripts) > 0 ||
			len(b.referenceInputsV3) > 0 ||
			b.referencedScriptVersions[PlutusV3] {
			key := PlutusV3CostModelKey()
			cm := b.Context.CostModelsV3()
			if len(cm) > 0 {
				usedCms[key] =
					PlutusData.CostModelV3(cm)
			} else {
				usedCms[key] =
					PlutusData.PLUTUSV3COSTMODEL
			}
		}
	}

	var redeemer_bytes []byte
	if len(redeemers) == 0 {
		redeemer_bytes, _ = hex.DecodeString("a0")
	} else {
		redeemer_bytes, _ = cbor.Marshal(redeemers)
	}
	var err error
	var datum_bytes []byte
	if len(datums) > 0 {
		datum_bytes, err = cbor.Marshal(
			PlutusData.PlutusIndefArray(datums),
		)
		if err != nil {
			return nil, err
		}
	} else {
		datum_bytes = []byte{}
	}
	var cost_model_bytes []byte
	cost_model_bytes, _ = cbor.Marshal(usedCms)
	total_bytes := append(redeemer_bytes, datum_bytes...)
	total_bytes = append(total_bytes, cost_model_bytes...)
	hash, err := serialization.Blake2bHash(total_bytes)
	if err != nil {
		return nil, err
	}
	return &serialization.ScriptDataHash{Payload: hash}, nil
}

/*
*

	getMints returns the multi-assets generated from minting.

	Returns:
		MultiAsset.MultiAsset[int64]: The generated multi-assets.
*/
func (b *Apollo) getMints() MultiAsset.MultiAsset[int64] {
	ma := make(MultiAsset.MultiAsset[int64])
	for _, mintUnit := range b.mint {
		ma = ma.Add(mintUnit.ToValue().GetAssets())
	}
	return ma
}

/*
*

	MintAssets adds a minting unit to the transaction's minting set.

	Params:
		mintUnit Unit: The minting unit to add.

	Returns:
		*Apollo: A pointer to the Apollo object to support method chaining.
*/
func (b *Apollo) MintAssets(mintUnit Unit) *Apollo {
	b.mint = append(b.mint, mintUnit)
	return b
}

/*
*

	MintAssetsWithRedeemer adds a minting unit with an
	associated redeemer to the transaction's minting set.
	The redeemer is auto-created with the MINT tag from
	the provided PlutusData.

	Params:
		mintUnit Unit: The minting unit to add.
		redeemerData PlutusData.PlutusData: The redeemer
			data for the minting unit.

	Returns:
		*Apollo: A pointer to the Apollo object with
		the minting unit added.
*/
func (b *Apollo) MintAssetsWithRedeemer(
	mintUnit Unit,
	redeemerData PlutusData.PlutusData,
) *Apollo {
	b.mint = append(b.mint, mintUnit)
	newRedeemer := Redeemer.Redeemer{
		Tag:     Redeemer.MINT,
		Index:   0,
		Data:    redeemerData,
		ExUnits: Redeemer.ExecutionUnits{},
	}
	b.mintRedeemers[mintUnit.PolicyId+mintUnit.Name] = newRedeemer
	b.isEstimateRequired = true
	return b
}

/**
buildTxBody constructs and returns the transaction body for the transaction.

Returns:
	TransactionBody.TransactionBody: The transaction body.
	error: An error if the build fails.
*/

func (b *Apollo) buildTxBody() (TransactionBody.TransactionBody, error) {
	inputs := make(
		[]TransactionInput.TransactionInput,
		0,
		len(b.preselectedUtxos),
	)
	for _, utxo := range b.preselectedUtxos {
		inputs = append(inputs, utxo.Input)
	}
	collaterals := make(
		[]TransactionInput.TransactionInput,
		0,
		len(b.collaterals),
	)
	for _, utxo := range b.collaterals {
		collaterals = append(collaterals, utxo.Input)
	}
	dataHash, err := b.scriptDataHash()
	if err != nil {
		return TransactionBody.TransactionBody{}, err
	}
	scriptDataHash := make([]byte, 0)
	if dataHash != nil {
		scriptDataHash = dataHash.Payload
	}
	aux_data_hash := b.auxiliaryData.Hash()
	mints := b.getMints()
	var withdrawals *Withdrawal.Withdrawal
	if b.withdrawals != nil &&
		b.withdrawals.Size() > 0 {
		withdrawals = b.withdrawals
	}
	txb := TransactionBody.TransactionBody{
		Inputs:            inputs,
		Outputs:           b.buildOutputs(),
		Fee:               b.Fee,
		Ttl:               b.Ttl,
		Mint:              mints,
		AuxiliaryDataHash: aux_data_hash,
		ScriptDataHash:    scriptDataHash,
		RequiredSigners:   b.requiredSigners,
		ValidityStart:     b.ValidityStart,
		Collateral:        collaterals,
		Certificates:      b.certificates,
		Withdrawals:       withdrawals,
		ReferenceInputs: append(
			b.referenceInputs,
			b.referenceInputsV3...,
		),
	}
	if b.totalCollateral != 0 {
		txb.TotalCollateral = b.totalCollateral
		txb.CollateralReturn = b.collateralReturn
	}
	return txb, nil
}

func (b *Apollo) SetCertificates(c *Certificate.Certificates) *Apollo {
	b.certificates = c
	return b
}

/*
*

	GetStakeCredentialFromAddress extracts a stake credential from an address's staking part.

	Params:


		address (Address.Address): The address from which to extract the stake credential.

	Returns:


	*Certificate.Credential: The stake credential, or nil if the address has no staking part.
	error: An error if the staking part is invalid.
*/
func GetStakeCredentialFromAddress(
	address Address.Address,
) (*Certificate.Credential, error) {
	if len(address.StakingPart) == 0 {
		return nil, errors.New("address has no staking part")
	}
	if len(address.StakingPart) != 28 {
		return nil, errors.New("invalid staking part length, expected 28 bytes")
	}
	// Code 0 = key hash, Code 1 = script hash
	// For standard addresses, we use key hash (0)
	return &Certificate.Credential{
		Code: 0,
		Hash: serialization.ConstrainedBytes{
			Payload: address.StakingPart,
		},
	}, nil
}

/*
*

	GetStakeCredentialFromWallet extracts a stake credential from the wallet's stake verification key.

	Returns:
		*Certificate.Credential: The stake credential.
		error: An error if the wallet doesn't have a stake key or extraction fails.
*/
func (b *Apollo) GetStakeCredentialFromWallet() (*Certificate.Credential, error) {
	if b.wallet == nil {
		return nil, errors.New("wallet not set")
	}
	genericWallet, ok := b.wallet.(*apollotypes.GenericWallet)
	if !ok {
		return nil, errors.New("wallet does not have stake keys")
	}
	if len(genericWallet.StakeVerificationKey.Payload) == 0 {
		return nil, errors.New("wallet does not have a stake verification key")
	}
	stakeKeyHash, err := genericWallet.StakeVerificationKey.Hash()
	if err != nil {
		return nil, err
	}
	return &Certificate.Credential{
		Code: 0, // key hash
		Hash: serialization.ConstrainedBytes{
			Payload: stakeKeyHash[:],
		},
	}, nil
}

/*
*

	RegisterStake registers a stake key for staking.

	Params:


		stakeCredential (*Certificate.Credential): The stake credential to register.
		If nil, it will attempt to extract from the wallet.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with stake registration certificate added.
	error: An error if the stake credential cannot be determined.
*/
func (b *Apollo) RegisterStake(
	stakeCredential *Certificate.Credential,
) (*Apollo, error) {
	var cred *Certificate.Credential
	var err error

	if stakeCredential != nil {
		cred = stakeCredential
	} else {
		cred, err = b.GetStakeCredentialFromWallet()
		if err != nil {
			return b, err
		}
	}

	regCert := Certificate.StakeRegistration{Stake: *cred}
	var certs Certificate.Certificates
	if b.certificates != nil {
		certs = *b.certificates
	}
	certs = append(certs, regCert)
	b.certificates = &certs
	return b, nil
}

/*
*

	RegisterStakeFromAddress registers a stake key from an address.

	Params:


		address (Address.Address): The address containing the stake key to register.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with stake registration certificate added.


	error: An error if the stake credential cannot be extracted from the address.
*/
func (b *Apollo) RegisterStakeFromAddress(
	address Address.Address,
) (*Apollo, error) {
	cred, err := GetStakeCredentialFromAddress(address)
	if err != nil {
		return b, err
	}
	return b.RegisterStake(cred)
}

/*
*

	RegisterStakeFromBech32 registers a stake key from a Bech32 address.

	Params:


		address (string): The Bech32 address containing the stake key to register.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with stake registration certificate added.
	error: An error if the address cannot be decoded.
*/
func (b *Apollo) RegisterStakeFromBech32(address string) (*Apollo, error) {
	decodedAddr, err := Address.DecodeAddress(address)
	if err != nil {
		return b, err
	}
	return b.RegisterStakeFromAddress(decodedAddr)
}

/*
*

	DeregisterStake deregisters a stake key, allowing the stake deposit to be returned.

	Params:


		stakeCredential (*Certificate.Credential): The stake credential to deregister.
		If nil, it will attempt to extract from the wallet.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with stake deregistration certificate added.
	error: An error if the stake credential cannot be determined.
*/
func (b *Apollo) DeregisterStake(
	stakeCredential *Certificate.Credential,
) (*Apollo, error) {
	var cred *Certificate.Credential
	var err error

	if stakeCredential != nil {
		cred = stakeCredential
	} else {
		cred, err = b.GetStakeCredentialFromWallet()
		if err != nil {
			return b, err
		}
	}

	deregCert := Certificate.StakeDeregistration{Stake: *cred}
	var certs Certificate.Certificates
	if b.certificates != nil {
		certs = *b.certificates
	}
	certs = append(certs, deregCert)
	b.certificates = &certs
	return b, nil
}

/*
*

	DeregisterStakeFromAddress deregisters a stake key from an address.

	Params:


		address (Address.Address): The address containing the stake key to deregister.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with stake deregistration certificate added.


	error: An error if the stake credential cannot be extracted from the address.
*/
func (b *Apollo) DeregisterStakeFromAddress(
	address Address.Address,
) (*Apollo, error) {
	cred, err := GetStakeCredentialFromAddress(address)
	if err != nil {
		return b, err
	}
	return b.DeregisterStake(cred)
}

/*
*

	DeregisterStakeFromBech32 deregisters a stake key from a Bech32 address.

	Params:


		address (string): The Bech32 address containing the stake key to deregister.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with stake deregistration certificate added.
	error: An error if the address cannot be decoded.
*/
func (b *Apollo) DeregisterStakeFromBech32(address string) (*Apollo, error) {
	decodedAddr, err := Address.DecodeAddress(address)
	if err != nil {
		return b, err
	}
	return b.DeregisterStakeFromAddress(decodedAddr)
}

/*
*

	DelegateStake delegates a stake key to a stake pool.

	Params:


	stakeCredential (*Certificate.Credential): The stake credential to delegate.
	If nil, it will attempt to extract from the wallet.


		poolKeyHash (serialization.PubKeyHash): The pool key hash to delegate to.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with stake delegation certificate added.
	error: An error if the stake credential cannot be determined.
*/
func (b *Apollo) DelegateStake(
	stakeCredential *Certificate.Credential,
	poolKeyHash serialization.PubKeyHash,
) (*Apollo, error) {
	var cred *Certificate.Credential
	var err error

	if stakeCredential != nil {
		cred = stakeCredential
	} else {
		cred, err = b.GetStakeCredentialFromWallet()
		if err != nil {
			return b, err
		}
	}

	delegCert := Certificate.StakeDelegation{
		Stake:       *cred,
		PoolKeyHash: poolKeyHash,
	}
	var certs Certificate.Certificates
	if b.certificates != nil {
		certs = *b.certificates
	}
	certs = append(certs, delegCert)
	b.certificates = &certs
	return b, nil
}

/*
*

	DelegateStakeFromAddress delegates a stake key from an address to a stake pool.

	Params:


	address (Address.Address): The address containing the stake key to delegate.


		poolKeyHash (serialization.PubKeyHash): The pool key hash to delegate to.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with stake delegation certificate added.


	error: An error if the stake credential cannot be extracted from the address.
*/
func (b *Apollo) DelegateStakeFromAddress(
	address Address.Address,
	poolKeyHash serialization.PubKeyHash,
) (*Apollo, error) {
	cred, err := GetStakeCredentialFromAddress(address)
	if err != nil {
		return b, err
	}
	return b.DelegateStake(cred, poolKeyHash)
}

/*
*

	DelegateStakeFromBech32 delegates a stake key from a Bech32 address to a stake pool.

	Params:


	address (string): The Bech32 address containing the stake key to delegate.


		poolKeyHash (serialization.PubKeyHash): The pool key hash to delegate to.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with stake delegation certificate added.
	error: An error if the address cannot be decoded.
*/
func (b *Apollo) DelegateStakeFromBech32(
	address string,
	poolKeyHash serialization.PubKeyHash,
) (*Apollo, error) {
	decodedAddr, err := Address.DecodeAddress(address)
	if err != nil {
		return b, err
	}
	return b.DelegateStakeFromAddress(decodedAddr, poolKeyHash)
}

/*
*

	RegisterAndDelegateStake registers a stake key and delegates it to a stake pool in one transaction.

	Params:


	stakeCredential (*Certificate.Credential): The stake credential to register and delegate.
	If nil, it will attempt to extract from the wallet.


		poolKeyHash (serialization.PubKeyHash): The pool key hash to delegate to.
		coin (int64): The coin to register and delegate.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with both certificates added.
	error: An error if the stake credential cannot be determined.
*/
func (b *Apollo) RegisterAndDelegateStake(
	stakeCredential *Certificate.Credential,
	poolKeyHash serialization.PubKeyHash,
	coin int64,
) (*Apollo, error) {
	var cred *Certificate.Credential
	var err error

	if stakeCredential != nil {
		cred = stakeCredential
	} else {
		cred, err = b.GetStakeCredentialFromWallet()
		if err != nil {
			return b, err
		}
	}

	stakeRegDelegCert := Certificate.StakeRegDelegCert{
		Stake:       *cred,
		PoolKeyHash: poolKeyHash,
		Coin:        coin,
	}
	var certs Certificate.Certificates
	if b.certificates != nil {
		certs = *b.certificates
	}
	certs = append(certs, stakeRegDelegCert)
	b.certificates = &certs
	return b, nil
}

/*
*

	RegisterAndDelegateStakeFromAddress registers and delegates a stake key from an address to a stake pool.

	Params:
		address (Address.Address): The address containing the stake key.


		poolKeyHash (serialization.PubKeyHash): The pool key hash to delegate to.
		coin (int64): The coin to register and delegate.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with both certificates added.


	error: An error if the stake credential cannot be extracted from the address.
*/
func (b *Apollo) RegisterAndDelegateStakeFromAddress(
	address Address.Address,
	poolKeyHash serialization.PubKeyHash,
	coin int64,
) (*Apollo, error) {
	cred, err := GetStakeCredentialFromAddress(address)
	if err != nil {
		return b, err
	}
	return b.RegisterAndDelegateStake(cred, poolKeyHash, coin)
}

/*
*

	RegisterAndDelegateStakeFromBech32 registers and delegates a stake key from a Bech32 address to a stake pool.

	Params:
		address (string): The Bech32 address containing the stake key.


		poolKeyHash (serialization.PubKeyHash): The pool key hash to delegate to.
		coin (int64): The coin to register and delegate.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with both certificates added.
	error: An error if the address cannot be decoded.
*/
func (b *Apollo) RegisterAndDelegateStakeFromBech32(
	address string,
	poolKeyHash serialization.PubKeyHash,
	coin int64,
) (*Apollo, error) {
	decodedAddr, err := Address.DecodeAddress(address)
	if err != nil {
		return b, err
	}
	return b.RegisterAndDelegateStakeFromAddress(decodedAddr, poolKeyHash, coin)
}

/*
*

	DelegateVote delegates a stake key to vote for a DRep (vote-delegation-certificate).

	Params:


		stakeCredential (*Certificate.Credential): The stake credential to delegate.
		If nil, it will attempt to extract from the wallet.
		drep (*Certificate.Drep): The DRep to delegate votes to.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with vote delegation certificate added.
	error: An error if the stake credential cannot be determined.
*/
func (b *Apollo) DelegateVote(
	stakeCredential *Certificate.Credential,
	drep *Certificate.Drep,
) (*Apollo, error) {
	var cred *Certificate.Credential
	var err error

	if stakeCredential != nil {
		cred = stakeCredential
	} else {
		cred, err = b.GetStakeCredentialFromWallet()
		if err != nil {
			return b, err
		}
	}

	voteDelegCert := Certificate.VoteDelegCert{
		Stake: *cred,
		Drep:  *drep,
	}
	var certs Certificate.Certificates
	if b.certificates != nil {
		certs = *b.certificates
	}
	certs = append(certs, voteDelegCert)
	b.certificates = &certs
	return b, nil
}

/*
*

	DelegateVoteFromAddress delegates a stake key from an address to vote for a DRep.

	Params:


		address (Address.Address): The address containing the stake key to delegate.
		drep (*Certificate.Drep): The DRep to delegate votes to.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with vote delegation certificate added.


	error: An error if the stake credential cannot be extracted from the address.
*/
func (b *Apollo) DelegateVoteFromAddress(
	address Address.Address,
	drep *Certificate.Drep,
) (*Apollo, error) {
	cred, err := GetStakeCredentialFromAddress(address)
	if err != nil {
		return b, err
	}
	return b.DelegateVote(cred, drep)
}

/*
*

	DelegateVoteFromBech32 delegates a stake key from a Bech32 address to vote for a DRep.

	Params:


		address (string): The Bech32 address containing the stake key to delegate.
		drep (*Certificate.Drep): The DRep to delegate votes to.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with vote delegation certificate added.
	error: An error if the address cannot be decoded.
*/
func (b *Apollo) DelegateVoteFromBech32(
	address string,
	drep *Certificate.Drep,
) (*Apollo, error) {
	decodedAddr, err := Address.DecodeAddress(address)
	if err != nil {
		return b, err
	}
	return b.DelegateVoteFromAddress(decodedAddr, drep)
}

/*
*

	DelegateStakeAndVote delegates a stake key to both a stake pool and a DRep (stake-and-vote-delegation-certificate).

	Params:


	stakeCredential (*Certificate.Credential): The stake credential to delegate.
	If nil, it will attempt to extract from the wallet.


		poolKeyHash (serialization.PubKeyHash): The pool key hash to delegate to.
		drep (*Certificate.Drep): The DRep to delegate votes to.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with stake and vote delegation certificate added.
	error: An error if the stake credential cannot be determined.
*/
func (b *Apollo) DelegateStakeAndVote(
	stakeCredential *Certificate.Credential,
	poolKeyHash serialization.PubKeyHash,
	drep *Certificate.Drep,
) (*Apollo, error) {
	var cred *Certificate.Credential
	var err error

	if stakeCredential != nil {
		cred = stakeCredential
	} else {
		cred, err = b.GetStakeCredentialFromWallet()
		if err != nil {
			return b, err
		}
	}

	stakeVoteDelegCert := Certificate.StakeVoteDelegCert{
		Stake:       *cred,
		PoolKeyHash: poolKeyHash,
		Drep:        *drep,
	}
	var certs Certificate.Certificates
	if b.certificates != nil {
		certs = *b.certificates
	}
	certs = append(certs, stakeVoteDelegCert)
	b.certificates = &certs
	return b, nil
}

/*
*

	DelegateStakeAndVoteFromAddress delegates a stake key from an address to both a stake pool and a DRep.

	Params:


	address (Address.Address): The address containing the stake key to delegate.


		poolKeyHash (serialization.PubKeyHash): The pool key hash to delegate to.
		drep (*Certificate.Drep): The DRep to delegate votes to.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with stake and vote delegation certificate added.


	error: An error if the stake credential cannot be extracted from the address.
*/
func (b *Apollo) DelegateStakeAndVoteFromAddress(
	address Address.Address,
	poolKeyHash serialization.PubKeyHash,
	drep *Certificate.Drep,
) (*Apollo, error) {
	cred, err := GetStakeCredentialFromAddress(address)
	if err != nil {
		return b, err
	}
	return b.DelegateStakeAndVote(cred, poolKeyHash, drep)
}

/*
*

	DelegateStakeAndVoteFromBech32 delegates a stake key from a Bech32 address to both a stake pool and a DRep.

	Params:


	address (string): The Bech32 address containing the stake key to delegate.


		poolKeyHash (serialization.PubKeyHash): The pool key hash to delegate to.
		drep (*Certificate.Drep): The DRep to delegate votes to.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with stake and vote delegation certificate added.
	error: An error if the address cannot be decoded.
*/
func (b *Apollo) DelegateStakeAndVoteFromBech32(
	address string,
	poolKeyHash serialization.PubKeyHash,
	drep *Certificate.Drep,
) (*Apollo, error) {
	decodedAddr, err := Address.DecodeAddress(address)
	if err != nil {
		return b, err
	}
	return b.DelegateStakeAndVoteFromAddress(decodedAddr, poolKeyHash, drep)
}

/*
*

	RegisterAndDelegateVote registers a stake key and delegates it to vote for a DRep in one transaction (registration-and-vote-delegation-certificate).

	Params:


		stakeCredential (*Certificate.Credential): The stake credential to register and delegate.
		If nil, it will attempt to extract from the wallet.
		drep (*Certificate.Drep): The DRep to delegate votes to.
		coin (int64): The coin to register and delegate.
	Returns:


	*Apollo: A pointer to the modified Apollo instance with both certificates added.
	error: An error if the stake credential cannot be determined.
*/
func (b *Apollo) RegisterAndDelegateVote(
	stakeCredential *Certificate.Credential,
	drep *Certificate.Drep,
	coin int64,
) (*Apollo, error) {
	var cred *Certificate.Credential
	var err error

	if stakeCredential != nil {
		cred = stakeCredential
	} else {
		cred, err = b.GetStakeCredentialFromWallet()
		if err != nil {
			return b, err
		}
	}

	voteRegDelegCert := Certificate.VoteRegDelegCert{
		Stake: *cred,
		Drep:  *drep,
		Coin:  coin,
	}
	var certs Certificate.Certificates
	if b.certificates != nil {
		certs = *b.certificates
	}
	certs = append(certs, voteRegDelegCert)
	b.certificates = &certs
	return b, nil
}

/*
*

	RegisterAndDelegateVoteFromAddress registers and delegates a stake key from an address to vote for a DRep.

	Params:
		address (Address.Address): The address containing the stake key.
		drep (*Certificate.Drep): The DRep to delegate votes to.
		coin (int64): The coin to register and delegate.
	Returns:


	*Apollo: A pointer to the modified Apollo instance with both certificates added.


	error: An error if the stake credential cannot be extracted from the address.
*/
func (b *Apollo) RegisterAndDelegateVoteFromAddress(
	address Address.Address,
	drep *Certificate.Drep,
	coin int64,
) (*Apollo, error) {
	cred, err := GetStakeCredentialFromAddress(address)
	if err != nil {
		return b, err
	}
	return b.RegisterAndDelegateVote(cred, drep, coin)
}

/*
*

	RegisterAndDelegateVoteFromBech32 registers and delegates a stake key from a Bech32 address to vote for a DRep.

	Params:
		address (string): The Bech32 address containing the stake key.
		drep (*Certificate.Drep): The DRep to delegate votes to.
		coin (int64): The coin to register and delegate.
	Returns:


	*Apollo: A pointer to the modified Apollo instance with both certificates added.
	error: An error if the address cannot be decoded.
*/
func (b *Apollo) RegisterAndDelegateVoteFromBech32(
	address string,
	drep *Certificate.Drep,
	coin int64,
) (*Apollo, error) {
	decodedAddr, err := Address.DecodeAddress(address)
	if err != nil {
		return b, err
	}
	return b.RegisterAndDelegateVoteFromAddress(decodedAddr, drep, coin)
}

/*
*

	RegisterAndDelegateStakeAndVote registers a stake key and delegates it to both a stake pool and a DRep in one transaction (registration-stake-and-vote-delegation-certificate).

	Params:


	stakeCredential (*Certificate.Credential): The stake credential to register and delegate.
	If nil, it will attempt to extract from the wallet.


		poolKeyHash (serialization.PubKeyHash): The pool key hash to delegate to.
		drep (*Certificate.Drep): The DRep to delegate votes to.
		coin (int64): The coin to register and delegate.
	Returns:


	*Apollo: A pointer to the modified Apollo instance with all certificates added.
	error: An error if the stake credential cannot be determined.
*/
func (b *Apollo) RegisterAndDelegateStakeAndVote(
	stakeCredential *Certificate.Credential,
	poolKeyHash serialization.PubKeyHash,
	drep *Certificate.Drep,
	coin int64,
) (*Apollo, error) {
	var cred *Certificate.Credential
	var err error

	if stakeCredential != nil {
		cred = stakeCredential
	} else {
		cred, err = b.GetStakeCredentialFromWallet()
		if err != nil {
			return b, err
		}
	}

	stakeVoteRegDelegCert := Certificate.StakeVoteRegDelegCert{
		Stake:       *cred,
		PoolKeyHash: poolKeyHash,
		Drep:        *drep,
		Coin:        coin,
	}
	var certs Certificate.Certificates
	if b.certificates != nil {
		certs = *b.certificates
	}
	certs = append(certs, stakeVoteRegDelegCert)
	b.certificates = &certs
	return b, nil
}

/*
*

	RegisterAndDelegateStakeAndVoteFromAddress registers and delegates a stake key from an address to both a stake pool and a DRep.

	Params:
		address (Address.Address): The address containing the stake key.


		poolKeyHash (serialization.PubKeyHash): The pool key hash to delegate to.
		drep (*Certificate.Drep): The DRep to delegate votes to.
		coin (int64): The coin to register and delegate.
	Returns:


	*Apollo: A pointer to the modified Apollo instance with all certificates added.


	error: An error if the stake credential cannot be extracted from the address.
*/
func (b *Apollo) RegisterAndDelegateStakeAndVoteFromAddress(
	address Address.Address,
	poolKeyHash serialization.PubKeyHash,
	drep *Certificate.Drep,
	coin int64,
) (*Apollo, error) {
	cred, err := GetStakeCredentialFromAddress(address)
	if err != nil {
		return b, err
	}
	return b.RegisterAndDelegateStakeAndVote(cred, poolKeyHash, drep, coin)
}

/*
*

	RegisterAndDelegateStakeAndVoteFromBech32 registers and delegates a stake key from a Bech32 address to both a stake pool and a DRep.

	Params:
		address (string): The Bech32 address containing the stake key.


		poolKeyHash (serialization.PubKeyHash): The pool key hash to delegate to.
		drep (*Certificate.Drep): The DRep to delegate votes to.
		coin (int64): The coin to register and delegate.
	Returns:


	*Apollo: A pointer to the modified Apollo instance with all certificates added.
	error: An error if the address cannot be decoded.
*/
func (b *Apollo) RegisterAndDelegateStakeAndVoteFromBech32(
	address string,
	poolKeyHash serialization.PubKeyHash,
	drep *Certificate.Drep,
	coin int64,
) (*Apollo, error) {
	decodedAddr, err := Address.DecodeAddress(address)
	if err != nil {
		return b, err
	}
	return b.RegisterAndDelegateStakeAndVoteFromAddress(
		decodedAddr,
		poolKeyHash,
		drep,
		coin,
	)
}

/*
*

	CreatePoolParams creates a PoolParams structure for pool registration.


	Note: PoolMetadata must be set manually after creation if needed, as it uses an anonymous struct type.

	Params:


	operator (serialization.PubKeyHash): The pool operator's public key hash.
	vrfKeyHash ([]byte): The VRF key hash (32 bytes).
	pledge (int64): The pool pledge amount in lovelace.
	cost (int64): The pool cost in lovelace.


	margin (Certificate.UnitInterval): The pool margin (fraction between 0 and 1).


	rewardAccount ([]byte): The reward account (29 bytes: 1 byte header + 28 bytes stake credential).


		poolOwners ([]serialization.PubKeyHash): List of pool owner public key hashes.
		relays (RelayPkg.Relays): List of relay entries.

	Returns:


	*Certificate.PoolParams: A pointer to the created pool parameters with PoolMetadata set to nil.
*/
func CreatePoolParams(
	operator serialization.PubKeyHash,
	vrfKeyHash []byte,
	pledge int64,
	cost int64,
	margin Certificate.UnitInterval,
	rewardAccount []byte,
	poolOwners []serialization.PubKeyHash,
	relays RelayPkg.Relays,
) *Certificate.PoolParams {
	return &Certificate.PoolParams{
		Operator:      operator,
		VrfKeyHash:    vrfKeyHash,
		Pledge:        pledge,
		Cost:          cost,
		Margin:        margin,
		RewardAccount: rewardAccount,
		PoolOwners:    poolOwners,
		Relays:        relays,
		PoolMetadata:  nil,
	}
}

/*
*

	RegisterPool registers a stake pool (pool-registration-certificate).

	Params:


		poolParams (*Certificate.PoolParams): The pool parameters including operator, VRF key hash, pledge, cost, margin, reward account, pool owners, relays, and optional metadata.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with pool registration certificate added.
*/
func (b *Apollo) RegisterPool(poolParams *Certificate.PoolParams) *Apollo {
	poolRegCert := Certificate.PoolRegistration{Params: *poolParams}
	var certs Certificate.Certificates
	if b.certificates != nil {
		certs = *b.certificates
	}
	certs = append(certs, poolRegCert)
	b.certificates = &certs
	return b
}

/*
*

	DeregisterPool deregisters a stake pool (pool-retirement-certificate).

	Params:


		poolKeyHash (serialization.PubKeyHash): The pool key hash of the pool to retire.
		epochNo (uint64): The epoch number when the pool should be retired.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with pool retirement certificate added.
*/
func (b *Apollo) DeregisterPool(
	poolKeyHash serialization.PubKeyHash,
	epochNo uint64,
) *Apollo {
	poolRetCert := Certificate.PoolRetirement{
		PoolKeyHash: poolKeyHash,
		EpochNo:     epochNo,
	}
	var certs Certificate.Certificates
	if b.certificates != nil {
		certs = *b.certificates
	}
	certs = append(certs, poolRetCert)
	b.certificates = &certs
	return b
}

/*
*

	buildFullFakeTx constructs and returns a full fake transaction for testing.

	Returns:
		*Transaction.Transaction: A pointer to the fake transaction.
		error: An error if the transaction construction fails.
*/
func (b *Apollo) buildFullFakeTx() (*Transaction.Transaction, error) {
	txBody, err := b.buildTxBody()
	if err != nil {
		return nil, err
	}
	if txBody.Fee == 0 {
		maxFee, err := b.Context.MaxTxFee()
		if err != nil {
			return nil, err
		}
		txBody.Fee = int64(maxFee)
	}
	witness := b.buildFakeWitnessSet()
	tx := Transaction.Transaction{
		TransactionBody:       txBody,
		TransactionWitnessSet: witness,
		Valid:                 true,
		AuxiliaryData:         b.auxiliaryData}
	bytes, _ := tx.Bytes()
	pp, err := b.Context.GetProtocolParams()
	if err != nil {
		return nil, err
	}
	if len(bytes) > pp.MaxTxSize {
		return nil, errors.New("transaction too large")
	}
	return &tx, nil
}

/*
*

	estimateFee estimates the transaction fee based on execution units and transaction size.

	Returns:
		int64: The estimated transaction fee.
*/
func (b *Apollo) estimateFee() (int64, error) {
	if b.forceFee {
		return b.Fee, nil
	}
	return b.GetEstimatedFee()
}

/*
*

	GetEstimatedFee estimates the transaction fee based on
	execution units and transaction size. This is the public
	wrapper around the internal fee estimation logic.

	Returns:

		int64: The estimated transaction fee.
		error: An error if fee estimation fails.
*/
func (b *Apollo) GetEstimatedFee() (int64, error) {
	pExU := Redeemer.ExecutionUnits{
		Mem: 0, Steps: 0,
	}
	for _, redeemer := range b.redeemers {
		pExU.Sum(redeemer.ExUnits)
	}
	for _, mintRedeemer := range b.mintRedeemers {
		pExU.Sum(mintRedeemer.ExUnits)
	}
	for _, stakeRedeemer := range b.stakeRedeemers {
		pExU.Sum(stakeRedeemer.ExUnits)
	}
	fftx, err := b.buildFullFakeTx()
	if err != nil {
		return 0, err
	}
	fakeTxBytes, _ := fftx.Bytes()
	fakeTxLength := len(
		[]byte(hex.EncodeToString(fakeTxBytes)),
	)
	estimatedFee, err := Utils.Fee(
		b.Context,
		fakeTxLength,
		pExU.Steps,
		pExU.Mem,
		fftx.TransactionBody.ReferenceInputs,
	)
	if err != nil {
		return 0, err
	}
	estimatedFee += b.FeePadding
	return estimatedFee, nil
}

/*
*

	ForceFee sets a fixed fee for the transaction,
	bypassing automatic fee estimation. When set,
	the estimateFee method will return this fee
	instead of computing one.

	Params:

		fee (int64): The fee to use for the transaction.

	Returns:

		*Apollo: A pointer to the modified Apollo instance.
*/
func (b *Apollo) ForceFee(fee int64) *Apollo {
	b.Fee = fee
	b.forceFee = true
	return b
}

/*
*

	getAvailableUtxos returns the available unspent transaction outputs (UTXOs) for the transaction.

	Returns:
		[]UTxO.UTxO: A slice of available UTXOs.
*/
func (b *Apollo) getAvailableUtxos() []UTxO.UTxO {
	availableUtxos := make([]UTxO.UTxO, 0)
	for _, utxo := range b.utxos {
		if !slices.Contains(b.usedUtxos, utxo.GetKey()) {
			availableUtxos = append(availableUtxos, utxo)
		}
	}
	return availableUtxos
}

/*
*

	setRedeemerIndexes function sets indexes for redeemers in
	the transaction based on UTxO inputs.

	Returns:
		*Apollo: A pointer to the Apollo object with indexes and redeemers set.
*/
func (b *Apollo) setRedeemerIndexes() *Apollo {
	sorted_inputs := SortInputs(b.preselectedUtxos)
	for i, utxo := range sorted_inputs {
		key := hex.EncodeToString(
			utxo.Input.TransactionId,
		) + strconv.Itoa(
			utxo.Input.Index,
		)
		val, ok := b.redeemersToUTxO[key]
		if ok && val.Tag == Redeemer.SPEND {
			redeem := b.redeemersToUTxO[key]
			redeem.Index = i
			b.redeemersToUTxO[key] = redeem
		} else if ok && val.Tag == Redeemer.MINT {
			// TODO: IMPLEMENT FOR MINTS
			continue
		}
	}
	return b
}

/*
*

	AttachDatum attaches a datum to the transaction.

	Params:
		datum *PlutusData.PlutusData: The datum to attach.

	Returns:
		*Apollo: A pointer to the Apollo object with the datum added.
*/
func (b *Apollo) AttachDatum(datum *PlutusData.PlutusData) *Apollo {
	b.datums = append(b.datums, *datum)
	return b
}

/**
setCollateral function sets collateral for the transaction.

Returns:
	*Apollo: A pointer to the Apollo object to support method chaining.
	error: An error if the setCollateral fails.
*/

func (b *Apollo) setCollateral() (*Apollo, error) {
	collateral_amount := 5_000_000

	if b.collateralAmount > 0 {
		collateral_amount = b.collateralAmount
	}

	if len(b.collaterals) > 0 {
		for _, utxo := range b.collaterals {
			if int(
				utxo.Output.GetValue().GetCoin(),
			) >= collateral_amount+1_000_000 &&
				len(utxo.Output.GetValue().GetAssets()) <= 5 {
				b.totalCollateral = int64(collateral_amount)
				return_amount := utxo.Output.GetValue().
					GetCoin() -
					int64(
						collateral_amount,
					)
				returnOutput := TransactionOutput.SimpleTransactionOutput(
					b.inputAddresses[0],
					Value.SimpleValue(
						return_amount,
						utxo.Output.GetValue().GetAssets(),
					),
				)
				b.collateralReturn = &returnOutput
			}
		}
		return b, nil
	}
	witnesses := b.buildWitnessSet()
	if len(witnesses.PlutusV1Script) == 0 &&
		len(witnesses.PlutusV2Script) == 0 &&
		len(
			b.referenceInputs,
		) == 0 && len(witnesses.PlutusV3Script) == 0 && len(b.referenceInputsV3) == 0 {
		return b, nil
	}

	for _, utxo := range b.utxos {
		if int(utxo.Output.GetValue().GetCoin()) >= collateral_amount &&
			len(utxo.Output.GetValue().GetAssets()) <= 5 {
			return_amount := utxo.Output.GetValue().
				GetCoin() -
				int64(
					collateral_amount,
				)
			min_lovelace, err := Utils.MinLovelacePostAlonzo(
				TransactionOutput.SimpleTransactionOutput(
					b.inputAddresses[0],
					Value.SimpleValue(
						return_amount,
						utxo.Output.GetAmount().GetAssets(),
					),
				),
				b.Context,
			)
			if err != nil {
				return b, err
			}
			if min_lovelace > return_amount && return_amount != 0 {
				continue
			} else if return_amount == 0 && len(utxo.Output.GetAmount().GetAssets()) == 0 {
				b.collaterals = append(b.collaterals, utxo)
				b.totalCollateral = int64(collateral_amount)
				return b, nil
			} else {
				returnOutput := TransactionOutput.SimpleTransactionOutput(b.inputAddresses[0], Value.SimpleValue(return_amount, utxo.Output.GetValue().GetAssets()))
				b.collaterals = append(b.collaterals, utxo)
				b.collateralReturn = &returnOutput
				b.totalCollateral = int64(collateral_amount)
				return b, nil
			}
		}
	}
	for _, utxo := range b.utxos {
		if int(utxo.Output.GetValue().GetCoin()) >= collateral_amount {
			return_amount := utxo.Output.GetValue().
				GetCoin() -
				int64(
					collateral_amount,
				)
			min_lovelace, err := Utils.MinLovelacePostAlonzo(
				TransactionOutput.SimpleTransactionOutput(
					b.inputAddresses[0],
					Value.SimpleValue(
						return_amount,
						utxo.Output.GetAmount().GetAssets(),
					),
				),
				b.Context,
			)
			if err != nil {
				return b, err
			}
			if min_lovelace > return_amount && return_amount != 0 {
				continue
			} else if return_amount == 0 && len(utxo.Output.GetAmount().GetAssets()) == 0 {
				b.collaterals = append(b.collaterals, utxo)
				b.totalCollateral = int64(collateral_amount)
				return b, nil
			} else {
				returnOutput := TransactionOutput.SimpleTransactionOutput(b.inputAddresses[0], Value.SimpleValue(return_amount, utxo.Output.GetValue().GetAssets()))
				b.collaterals = append(b.collaterals, utxo)
				b.collateralReturn = &returnOutput
				b.totalCollateral = int64(collateral_amount)
				return b, nil
			}
		}
	}
	return b, errors.New("NoCollateral")
}

/*
*

	Clone creates a deep copy of the Apollo object.

	Returns:
		*Apollo: A pointer to the cloned Apollo object.
*/
func (b *Apollo) Clone() *Apollo {
	clone := *b
	return &clone
}

/*
*

	estimateExUnits estimates the execution units for redeemers and updates them.

	Returns:
		map[string]Redeemer.ExecutionUnits: A map of estimated execution units.
*/
func (b *Apollo) estimateExunits() (
	map[string]Redeemer.ExecutionUnits,
	[]byte,
	error,
) {
	cloned_b := b.Clone()
	cloned_b.isEstimateRequired = false
	updated_b, _, err := cloned_b.Complete()
	if err != nil {
		return make(
			map[string]Redeemer.ExecutionUnits, 0,
		), nil, err
	}
	tx_cbor, err := cbor.Marshal(updated_b.tx)
	if err != nil {
		return make(
			map[string]Redeemer.ExecutionUnits, 0,
		), nil, err
	}
	var result map[string]Redeemer.ExecutionUnits
	if len(b.additionalUtxos) > 0 {
		result, err = b.Context.EvaluateTxWithAdditionalUtxos(
			tx_cbor,
			b.additionalUtxos,
		)
	} else {
		result, err = b.Context.EvaluateTx(tx_cbor)
	}
	if err != nil {
		return result, tx_cbor, err
	}
	return result, nil, nil
}

/*
*

	updateExUnits updates the execution units in the transaction based on estimates.

	Returns:
		*Apollo: A pointer to the Apollo object to support method chaining.
*/
func (b *Apollo) updateExUnits() (
	*Apollo, []byte, error,
) {
	if b.isEstimateRequired {
		estimated_execution_units, tx_cbor, err :=
			b.estimateExunits()
		if err != nil {
			return b, tx_cbor, fmt.Errorf(
				"could not estimate ExUnits: %w", err,
			)
		}
		for k, redeemer := range b.redeemersToUTxO {
			key := fmt.Sprintf(
				"%s:%d",
				Redeemer.RedeemerTagNames[redeemer.Tag],
				redeemer.Index,
			)
			if _, ok := estimated_execution_units[key]; ok {
				redeemer.ExUnits = estimated_execution_units[key]
				redeemer.ExUnits.Mem = int64(
					float32(redeemer.ExUnits.Mem) * 1.2,
				)
				redeemer.ExUnits.Steps = int64(
					float32(redeemer.ExUnits.Steps) * 1.2,
				)
				b.redeemersToUTxO[k] = redeemer
			}
		}
		for k, redeemer := range b.stakeRedeemers {
			key := fmt.Sprintf(
				"%s:%d",
				Redeemer.RedeemerTagNames[redeemer.Tag],
				redeemer.Index,
			)
			if _, ok := estimated_execution_units[key]; ok {
				redeemer.ExUnits = estimated_execution_units[key]
				redeemer.ExUnits.Mem = int64(
					float32(redeemer.ExUnits.Mem) * 1.2,
				)
				redeemer.ExUnits.Steps = int64(
					float32(redeemer.ExUnits.Steps) * 1.2,
				)
				b.stakeRedeemers[k] = redeemer
			}
		}
		for k, redeemer := range b.mintRedeemers {
			key := fmt.Sprintf(
				"%s:%d",
				Redeemer.RedeemerTagNames[redeemer.Tag],
				redeemer.Index,
			)
			if _, ok := estimated_execution_units[key]; ok {
				redeemer.ExUnits = estimated_execution_units[key]
				redeemer.ExUnits.Mem = int64(
					float32(redeemer.ExUnits.Mem) * 1.2,
				)
				redeemer.ExUnits.Steps = int64(
					float32(redeemer.ExUnits.Steps) * 1.2,
				)
				b.mintRedeemers[k] = redeemer
			}
		}
		for _, redeemer := range b.redeemersToUTxO {
			b.redeemers = append(b.redeemers, redeemer)
		}
		for _, redeemer := range b.stakeRedeemers {
			b.redeemers = append(b.redeemers, redeemer)
		}
		for _, redeemer := range b.mintRedeemers {
			b.redeemers = append(b.redeemers, redeemer)

		}
	} else {
		for _, redeemer := range b.redeemersToUTxO {
			b.redeemers = append(b.redeemers, redeemer)
		}
		for _, redeemer := range b.stakeRedeemers {
			b.redeemers = append(b.redeemers, redeemer)
		}
		for _, redeemer := range b.mintRedeemers {
			b.redeemers = append(b.redeemers, redeemer)
		}

	}
	// Sort redeemers by (Tag, Index) to ensure deterministic ordering.
	// Without sorting, Go's map iteration produces non-deterministic order,
	// causing different script_data_hash values on each run.
	slices.SortFunc(b.redeemers, func(a, b Redeemer.Redeemer) int {
		if a.Tag != b.Tag {
			return int(a.Tag) - int(b.Tag)
		}
		return a.Index - b.Index
	})
	return b, nil, nil
}

/*
*

	GetTx returns the transaction associated with the Apollo object.

	Returns:
		*Transacction.Transaction: A pointer to the transaction.
*/
func (b *Apollo) GetTx() *Transaction.Transaction {
	return b.tx
}

func CountRequiredAssets(assets MultiAsset.MultiAsset[int64]) int {
	count := 0
	for _, asset := range assets {
		for _, amt := range asset {
			if amt > 0 {
				count++
			}
		}
	}
	return count
}

/*
*

	Complete assembles and finalizes the Apollo
	transaction, handling inputs, change, fees,
	collateral and witness data.

	If this fails due to a script failure, it
	returns the failed tx cbor as bytes for
	diagnostic purposes.

	Returns:

	*Apollo: A pointer to the Apollo object
	representing the completed transaction.
	[]byte: The failed transaction bytes for
	diagnostics, or nil on success.
	error: An error if any issues are encountered
	during the process.
*/
func (b *Apollo) Complete() (
	*Apollo, []byte, error,
) {
	if b.err != nil {
		return nil, nil, b.err
	}
	selectedUtxos := make([]UTxO.UTxO, 0)
	selectedAmount := Value.Value{}
	for _, utxo := range b.preselectedUtxos {
		selectedAmount = selectedAmount.Add(utxo.Output.GetValue())
	}
	burnedValue := b.GetBurns()
	mintedValue := b.getPositiveMints()
	selectedAmount = selectedAmount.Add(mintedValue)
	requestedAmount := Value.Value{}
	requestedAmount.Add(burnedValue)
	for _, payment := range b.payments {
		payment.EnsureMinUTXO(b.Context)
		requestedAmount = requestedAmount.Add(payment.ToValue())
	}
	if b.certificates != nil {
		// Add STAKE_DEPOSIT for registration certificates:
		// Kind 0 = StakeRegistration
		// Kind 7 = RegCert
		// Kind 11 = StakeRegDelegCert
		// Kind 12 = VoteRegDelegCert
		// Kind 13 = StakeVoteRegDelegCert
		// Deregistration (kind 1, 8) refunds the deposit, delegation (kind 2) doesn't require it
		registrationCount := 0
		deregistrationCount := 0
		for _, cert := range *b.certificates {
			kind := cert.Kind()
			switch kind {
			case 0, 7, 11, 12, 13:
				registrationCount++
			case 1, 8:
				deregistrationCount++
			}
		}
		if registrationCount > 0 {
			requestedAmount = requestedAmount.Add(
				Value.PureLovelaceValue(
					int64(STAKE_DEPOSIT * registrationCount),
				),
			)
		}
		if deregistrationCount > 0 {
			// Refund deposit for deregistrations
			requestedAmount = requestedAmount.Sub(
				Value.PureLovelaceValue(
					int64(STAKE_DEPOSIT * deregistrationCount),
				),
			)
		}
	}
	estimatedFee, err := b.estimateFee()
	if err != nil {
		return b, nil, err
	}
	requestedAmount.AddLovelace(estimatedFee + constants.MIN_LOVELACE)
	unfulfilledAmount := requestedAmount.Sub(selectedAmount)
	unfulfilledAmount = unfulfilledAmount.RemoveZeroAssets()
	available_utxos := SortUtxos(b.getAvailableUtxos())
	//BALANCE TX
	requiredAssetsCount := CountRequiredAssets(unfulfilledAmount.GetAssets())
	if unfulfilledAmount.GetCoin() > 0 || requiredAssetsCount > 0 {
		//BALANCE
		if len(unfulfilledAmount.GetAssets()) > 0 {
			//BALANCE WITH ASSETS
			for pol, assets := range unfulfilledAmount.GetAssets() {
				for asset, amt := range assets {
					found := false
					selectedSoFar := int64(0)
					usedIdxs := make([]int, 0)
					for idx, utxo := range available_utxos {
						ma := utxo.Output.GetValue().GetAssets()
						if ma.GetByPolicyAndId(pol, asset) >= amt {
							selectedUtxos = append(selectedUtxos, utxo)
							selectedAmount = selectedAmount.Add(
								utxo.Output.GetValue(),
							)
							usedIdxs = append(usedIdxs, idx)
							b.usedUtxos = append(b.usedUtxos, utxo.GetKey())
							found = true
							break
						} else if ma.GetByPolicyAndId(pol, asset) > 0 {
							selectedUtxos = append(selectedUtxos, utxo)
							selectedAmount = selectedAmount.Add(utxo.Output.GetValue())
							usedIdxs = append(usedIdxs, idx)
							b.usedUtxos = append(b.usedUtxos, utxo.GetKey())
							selectedSoFar += ma.GetByPolicyAndId(pol, asset)
							if selectedSoFar >= amt {
								found = true
								break
							}
						}
					}
					newAvailUtxos := make([]UTxO.UTxO, 0)
					for idx, availutxo := range available_utxos {
						if !slices.Contains(usedIdxs, idx) {
							newAvailUtxos = append(newAvailUtxos, availutxo)
						}
					}
					available_utxos = newAvailUtxos
					if !found {
						return nil, nil, errors.New(
							"missing required assets",
						)
					}

				}
			}
		}
		for !selectedAmount.Greater(
			requestedAmount.Add(
				Value.Value{Am: Amount.Amount{}, Coin: 1_000_000, HasAssets: false},
			),
		) {

			if len(available_utxos) == 0 {
				return nil, nil, errors.New(
					"not enough funds",
				)
			}
			utxo := available_utxos[0]
			selectedUtxos = append(selectedUtxos, utxo)
			selectedAmount = selectedAmount.Add(utxo.Output.GetValue())
			available_utxos = available_utxos[1:]
			b.usedUtxos = append(b.usedUtxos, utxo.GetKey())
		}

	}
	// ADD NEW SELECTED INPUTS TO PRE SELECTION
	b.preselectedUtxos = append(b.preselectedUtxos, selectedUtxos...)

	//SET REDEEMER INDEXES
	b = b.setRedeemerIndexes()
	//SET COLLATERAL
	b, err = b.setCollateral()
	if err != nil {
		return nil, nil, err
	}
	//UPDATE EXUNITS
	b, txCbor, err := b.updateExUnits()
	if err != nil {
		return b, txCbor, err
	}
	//ADDCHANGEANDFEE
	b, err = b.addChangeAndFee()
	if err != nil {
		return nil, txCbor, err
	}
	//FINALIZE TX
	body, err := b.buildTxBody()
	if err != nil {
		return nil, txCbor, err
	}
	witnessSet := b.buildWitnessSet()
	b.tx = &Transaction.Transaction{
		TransactionBody:       body,
		TransactionWitnessSet: witnessSet,
		AuxiliaryData:         b.auxiliaryData,
		Valid:                 true,
	}
	return b, nil, nil
}

/*
*

	Check if adding change to a transaction output would exceed
	the UTxO limit for the given address.

	Params:
		change: The change amount to add.
		address: The address for which change is being calculated.
		b: The ChainContext providing protocol parameters.

	Returns:


	bool: True if adding change would exceed the UTXO limit, false otherwise.
*/
func isOverUtxoLimit(
	change Value.Value,
	address Address.Address,
	b Base.ChainContext,
) (bool, error) {
	txOutput := TransactionOutput.SimpleTransactionOutput(
		address,
		Value.SimpleValue(0, change.GetAssets()),
	)
	encoded, _ := cbor.Marshal(txOutput)
	pps, err := b.GetProtocolParams()
	if err != nil {
		return false, err
	}
	maxValSize, _ := strconv.Atoi(pps.MaxValSize)
	return len(encoded) > maxValSize, nil

}

/*
*

	Split payments into multiple payments if adding change
	exceeds the UTxO limit.

	Params:
		c: The change amount.
		a: The address to which change is being sent.
		b: The ChainContext providing protocol parameters.

	Returns:


	[]*Payment: An array of payment objects, split if necessary to avoid exceeding the UTxO limit.
*/
func splitPayments(
	c Value.Value,
	a Address.Address,
	b Base.ChainContext,
) ([]*Payment, error) {
	lovelace := c.GetCoin()
	assets := c.GetAssets()
	payments := make([]*Payment, 0)
	newPayment := new(Payment)
	newPayment.Receiver = a
	newPayment.Lovelace = 0
	newPayment.Units = make([]Unit, 0)
	for policy, assets := range assets {
		for asset, amt := range assets {
			isOver, err := isOverUtxoLimit(newPayment.ToValue(), a, b)
			if err != nil {
				return nil, err
			}
			if !isOver {
				if amt > 0 {
					newPayment.Units = append(newPayment.Units, Unit{
						PolicyId: policy.String(),
						Name:     asset.String(),
						Quantity: int(amt),
					})
				}
			} else {

				minLovelace, err := Utils.MinLovelacePostAlonzo(
					*newPayment.ToTxOut(), b)
				if err != nil {
					return nil, err
				}
				newPayment.Lovelace = int(minLovelace)
				lovelace -= minLovelace
				payments = append(payments, newPayment)
				newPayment = new(Payment)
				newPayment.Receiver = a
				newPayment.Lovelace = 0
				newPayment.Units = make([]Unit, 0)
				if amt > 0 {
					newPayment.Units = append(newPayment.Units, Unit{
						PolicyId: policy.String(),
						Name:     asset.String(),
						Quantity: int(amt),
					})
				}
			}
		}
	}
	payments = append(payments, newPayment)

	payments[len(payments)-1].Lovelace += int(lovelace)
	totalCoin := 0
	for _, payment := range payments {
		totalCoin += payment.Lovelace
	}
	return payments, nil

}

func (b *Apollo) GetBurns() (burns Value.Value) {
	burns = Value.Value{}
	for _, mintUnit := range b.mint {
		if mintUnit.Quantity < 0 {
			usedUnit := Unit{
				PolicyId: mintUnit.PolicyId,
				Name:     mintUnit.Name,
				Quantity: -mintUnit.Quantity,
			}
			burns = burns.Add(usedUnit.ToValue())
		}

	}
	return burns

}

func (b *Apollo) getPositiveMints() (mints Value.Value) {
	mints = Value.Value{}
	for _, mintUnit := range b.mint {
		if mintUnit.Quantity > 0 {
			usedUnit := Unit{
				PolicyId: mintUnit.PolicyId,
				Name:     mintUnit.Name,
				Quantity: mintUnit.Quantity,
			}
			mints = mints.Add(usedUnit.ToValue())
		}

	}
	return mints

}

/*
*

	GetMints returns all pending mints (both positive
	and negative quantities) as a Value. This exposes
	the internal mint tracking for external callers.

	Returns:

		Value.Value: The total minted value.
*/
func (b *Apollo) GetMints() Value.Value {
	mints := Value.Value{}
	for _, mintUnit := range b.mint {
		usedUnit := Unit{
			PolicyId: mintUnit.PolicyId,
			Name:     mintUnit.Name,
			Quantity: mintUnit.Quantity,
		}
		mints = mints.Add(usedUnit.ToValue())
	}
	return mints
}

/*
*
Add change and fees to the transaction.

Returns:

	*Apollo: A pointer to the Apollo object with change and fees added.
	error: An error if addChangeAndFee fails.
*/
func (b *Apollo) addChangeAndFee() (*Apollo, error) {
	burns := b.GetBurns()
	mints := b.getPositiveMints()
	providedAmount := Value.Value{}
	for _, utxo := range b.preselectedUtxos {
		providedAmount = providedAmount.Add(utxo.Output.GetValue())
	}
	providedAmount = providedAmount.Add(mints)
	requestedAmount := Value.Value{}
	for _, payment := range b.payments {
		requestedAmount = requestedAmount.Add(payment.ToValue())
	}
	if b.certificates != nil {
		// Add STAKE_DEPOSIT for registration certificates:
		// Kind 0 = StakeRegistration
		// Kind 7 = RegCert
		// Kind 11 = StakeRegDelegCert
		// Kind 12 = VoteRegDelegCert
		// Kind 13 = StakeVoteRegDelegCert
		// Deregistration (kind 1, 8) refunds the deposit, delegation (kind 2) doesn't require it
		registrationCount := 0
		deregistrationCount := 0
		for _, cert := range *b.certificates {
			kind := cert.Kind()
			switch kind {
			case 0, 7, 11, 12, 13:
				registrationCount++
			case 1, 8:
				deregistrationCount++
			}
		}
		if registrationCount > 0 {
			requestedAmount = requestedAmount.Add(
				Value.PureLovelaceValue(
					int64(STAKE_DEPOSIT * registrationCount),
				),
			)
		}
		if deregistrationCount > 0 {
			// Refund deposit for deregistrations
			requestedAmount = requestedAmount.Sub(
				Value.PureLovelaceValue(
					int64(STAKE_DEPOSIT * deregistrationCount),
				),
			)
		}
	}
	requestedAmount = requestedAmount.Add(burns)
	var err error
	b.Fee, err = b.estimateFee()
	if err != nil {
		return b, err
	}

	requestedAmount.AddLovelace(b.Fee)
	change := providedAmount.Sub(requestedAmount)
	minLovelaceRequired, err := Utils.MinLovelacePostAlonzo(
		TransactionOutput.SimpleTransactionOutput(
			b.inputAddresses[0],
			Value.SimpleValue(0, change.GetAssets()),
		),
		b.Context,
	)
	if err != nil {
		return b, err
	}
	if change.GetCoin() < minLovelaceRequired {
		if len(b.getAvailableUtxos()) == 0 {
			return b, errors.New("no remaining UTxOs")
		}
		sortedUtxos := SortUtxos(b.getAvailableUtxos())
		if len(sortedUtxos) == 0 {
			return b, errors.New("no remaining UTxOs")
		}
		b.preselectedUtxos = append(b.preselectedUtxos, sortedUtxos[0])
		b.usedUtxos = append(b.usedUtxos, sortedUtxos[0].GetKey())
		return b.addChangeAndFee()
	}
	isOver, err := isOverUtxoLimit(change, b.inputAddresses[0], b.Context)
	if err != nil {
		return b, err
	}
	if isOver {
		adjustedPayments, err := splitPayments(
			change,
			b.inputAddresses[0],
			b.Context,
		)
		if err != nil {
			return b, err
		}
		pp := b.payments[:]
		for _, payment := range adjustedPayments {
			b.payments = append(b.payments, payment)
		}
		newestFee, err := b.estimateFee()
		if err != nil {
			return b, err
		}
		if newestFee > b.Fee {
			difference := newestFee - b.Fee
			adjustedPayments[len(adjustedPayments)-1].Lovelace -= int(
				difference,
			)
			b.Fee = newestFee
			b.payments = pp
			for _, payment := range adjustedPayments {
				b.payments = append(b.payments, payment)
			}
		}

	} else {
		payment := Payment{
			Receiver: b.inputAddresses[0],
			Lovelace: int(change.GetCoin()),
			Units:    make([]Unit, 0),
		}
		for policy, assets := range change.GetAssets() {
			for asset, amt := range assets {
				if amt > 0 {
					payment.Units = append(payment.Units, Unit{
						PolicyId: policy.String(),
						Name:     asset.String(),
						Quantity: int(amt),
					})
				}
			}
		}
		pp := b.payments[:]
		b.payments = append(b.payments, &payment)

		newestFee, err := b.estimateFee()
		if err != nil {
			return b, err
		}
		if newestFee > b.Fee {
			difference := newestFee - b.Fee
			payment.Lovelace -= int(difference)
			b.payments = append(pp, &payment)
			b.Fee = newestFee
		}
	}
	return b, nil
}

/*
*

	Collect a UTXO and its associated redeemer for inclusion in the transaction.

	Params:
		inputUtxo: The UTXO to collect.
		redeemer: The redeemer associated with the UTXO.

	Returns:


	*Apollo: A pointer to the Apollo object with the collected UTXO and redeemer.
*/
func (b *Apollo) CollectFrom(
	inputUtxo UTxO.UTxO,
	redeemer Redeemer.Redeemer,
) *Apollo {
	b.isEstimateRequired = true
	b.preselectedUtxos = append(b.preselectedUtxos, inputUtxo)
	b.usedUtxos = append(b.usedUtxos, inputUtxo.GetKey())
	b.redeemersToUTxO[hex.EncodeToString(inputUtxo.Input.TransactionId)+strconv.Itoa(inputUtxo.Input.Index)] = redeemer
	return b
}

/*
*

	Attach a Plutus V1 script to the Apollo transaction.

	Params:
		script: The Plutus V1 script to attach.

	Returns:
		*Apollo: A pointer to the Apollo objecy with the attached script.
*/
func (b *Apollo) AttachV1Script(script PlutusData.PlutusV1Script) *Apollo {
	hash := PlutusData.PlutusScriptHash(script)
	if slices.Contains(b.scriptHashes, hex.EncodeToString(hash.Bytes())) {
		return b
	}
	b.v1scripts = append(b.v1scripts, script)
	b.scriptHashes = append(b.scriptHashes, hex.EncodeToString(hash.Bytes()))

	return b
}

/*
*

	Attach a Plutus V2 script to the Apollo transaction.

	Params:
		script: The Plutus V2 script to attach.

	Returns:
		*Apollo: A pointer to the Apollo objecy with the attached script.
*/
func (b *Apollo) AttachV2Script(script PlutusData.PlutusV2Script) *Apollo {
	hash := PlutusData.PlutusScriptHash(script)
	if slices.Contains(b.scriptHashes, hex.EncodeToString(hash.Bytes())) {
		return b
	}
	b.v2scripts = append(b.v2scripts, script)
	b.scriptHashes = append(b.scriptHashes, hex.EncodeToString(hash.Bytes()))
	return b
}

func (b *Apollo) AttachV3Script(script PlutusData.PlutusV3Script) *Apollo {
	hash := PlutusData.PlutusScriptHash(script)
	if slices.Contains(b.scriptHashes, hex.EncodeToString(hash.Bytes())) {
		return b
	}
	b.v3scripts = append(b.v3scripts, script)
	b.scriptHashes = append(b.scriptHashes, hex.EncodeToString(hash.Bytes()))
	return b
}

/**
Set the wallet for the Apollo transaction using a mnemonic.

Params:
	menmonic: The menomic phrase used to generate the wallet.

Returns:
	*Apollo: A pointer to the Apollo object with the wallet set.
	error: an error if setWalletFromMnemonic fails.
*/

func (a *Apollo) SetWalletFromMnemonic(
	mnemonic string,
	network constants.Network,
) (*Apollo, error) {
	paymentPath := "m/1852'/1815'/0'/0/0"
	stakingPath := "m/1852'/1815'/0'/2/0"
	hdWall, err := HDWallet.NewHDWalletFromMnemonic(mnemonic, "")
	if err != nil {
		return a, err
	}
	paymentKeyPath, err := hdWall.DerivePath(paymentPath)
	if err != nil {
		return a, err
	}
	verificationKey_bytes := paymentKeyPath.XPrivKey.PublicKey()
	signingKey_bytes := paymentKeyPath.XPrivKey.Bytes()
	stakingKeyPath, err := hdWall.DerivePath(stakingPath)
	if err != nil {
		return a, err
	}
	stakeVerificationKey_bytes := stakingKeyPath.XPrivKey.PublicKey()
	stakeSigningKey_bytes := stakingKeyPath.XPrivKey.Bytes()
	//stake := stakingKeyPath.RootXprivKey.Bytes()
	signingKey := Key.SigningKey{Payload: signingKey_bytes}
	verificationKey := Key.VerificationKey{Payload: verificationKey_bytes}
	stakeSigningKey := Key.SigningKey{Payload: stakeSigningKey_bytes}
	stakeVerificationKey := Key.VerificationKey{
		Payload: stakeVerificationKey_bytes,
	}
	stakeVerKey := Key.VerificationKey{Payload: stakeVerificationKey_bytes}
	skh, _ := stakeVerKey.Hash()
	vkh, _ := verificationKey.Hash()

	var addr Address.Address
	if network == constants.MAINNET {
		addr = Address.Address{
			StakingPart: skh[:],
			PaymentPart: vkh[:],
			Network:     1,
			AddressType: Address.KEY_KEY,
			HeaderByte:  0b00000001,
			Hrp:         "addr",
		}
	} else {
		addr = Address.Address{StakingPart: skh[:], PaymentPart: vkh[:], Network: 0, AddressType: Address.KEY_KEY, HeaderByte: 0b00000000, Hrp: "addr_test"}
	}
	wallet := apollotypes.GenericWallet{
		SigningKey:           signingKey,
		VerificationKey:      verificationKey,
		Address:              addr,
		StakeSigningKey:      stakeSigningKey,
		StakeVerificationKey: stakeVerificationKey,
	}
	a.wallet = &wallet
	return a, nil
}

// For use with key pairs generated by cardano-cli
func (a *Apollo) SetWalletFromKeypair(
	vkey string,
	skey string,
	network constants.Network,
) *Apollo {
	verificationKey_bytes, err := hex.DecodeString(vkey)
	if err != nil {
		fmt.Println("SetWalletFromKeypair: Failed to decode vkey")
	}
	signingKey_bytes, err := hex.DecodeString(skey)
	if err != nil {
		fmt.Println("SetWalletFromKeypair: Failed to decode skey")
	}
	// There are two slightly different interpretations of ed25519,
	// depending on which thing you call the "private key".
	// cardano-cli and the golang library crypto/ed25519 take opposite
	// interpretations. NewKeyFromSeed performs the necessary conversion.
	signingKey := Key.SigningKey{
		Payload: ed25519.NewKeyFromSeed(signingKey_bytes),
	}
	verificationKey := Key.VerificationKey{Payload: verificationKey_bytes}
	vkh, _ := verificationKey.Hash()

	var addr Address.Address
	if network == constants.MAINNET {
		addr = Address.Address{
			StakingPart: nil,
			PaymentPart: vkh[:],
			Network:     1,
			AddressType: Address.KEY_NONE,
			HeaderByte:  0b01100001,
			Hrp:         "addr",
		}
	} else {
		addr = Address.Address{StakingPart: nil, PaymentPart: vkh[:], Network: 0, AddressType: Address.KEY_NONE, HeaderByte: 0b01100000, Hrp: "addr_test"}
	}
	wallet := apollotypes.GenericWallet{
		SigningKey:           signingKey,
		VerificationKey:      verificationKey,
		Address:              addr,
		StakeSigningKey:      Key.SigningKey{},
		StakeVerificationKey: Key.VerificationKey{},
	}
	a.wallet = &wallet
	return a
}

/*
*

	Set the wallet for the Apollo transaction using a Bech32 address.

	Params:
		address: The Bech32 address to use as the wallet.

	Returns:
		*Apollo: A pointer to the Apollo object with the wallet set.
*/
func (a *Apollo) SetWalletFromBech32(address string) *Apollo {
	addr, err := Address.DecodeAddress(address)
	if err != nil {
		return a
	}
	a.wallet = &apollotypes.ExternalWallet{Address: addr}
	return a
}

/*
*

	Set the wallet as the change address for the Apollo transaction.

	Returns:


	*Apollo: A pointer to the Apollo object with the wallet set as the change address.
*/
func (b *Apollo) SetWalletAsChangeAddress() (*Apollo, error) {
	if b.wallet == nil {
		return b, errors.New("WALLET COULD NOT BE SET")
	}
	b.inputAddresses = append(b.inputAddresses, *b.wallet.GetAddress())
	return b, nil
}

/*
*

	Sign the Apollo transaction using the wallet's keys.

	Returns:
		*Apollo: A pointer to the Apollo object with the transaction signed.
*/
func (b *Apollo) Sign() *Apollo {
	signatures := b.wallet.SignTx(
		*b.tx,
		append(b.preselectedUtxos, b.collaterals...),
	)
	b.tx.TransactionWitnessSet = signatures
	return b
}

/*
*

	Sign the Apollo transaction with the given verification key and signing key.

	Parameters:
		vkey: The verification key to sign with.
		skey: The signing key to sign with.

	Returns:
		*Apollo: A pointer to the Apollo object with the transaction signed.
		error: An error if the signing fails.
*/
func (b *Apollo) SignWithSkey(
	vkey Key.VerificationKey,
	skey Key.SigningKey,
) (*Apollo, error) {
	witness_set := b.GetTx().TransactionWitnessSet
	txHash, err := b.GetTx().TransactionBody.Hash()
	if err != nil {
		return b, err
	}
	signature, err := skey.Sign(txHash)
	if err != nil {
		return b, err
	}
	witness_set.VkeyWitnesses = append(
		witness_set.VkeyWitnesses,
		VerificationKeyWitness.VerificationKeyWitness{
			Vkey:      vkey,
			Signature: signature,
		},
	)
	b.GetTx().TransactionWitnessSet = witness_set
	return b, nil
}

/*
*

	Submit function submits the constructed transaction to the blockchain
	network using the associated chain context.

	Returns:
		serialization.TransactionId: The ID of the submitted transaction.
		error: An error, if any, encountered during transaction submission.
*/
func (b *Apollo) Submit() (serialization.TransactionId, error) {
	return b.Context.SubmitTx(*b.tx)
}

/*
*

	LoadTxCbor loads a transaction from its CBOR representation and updates
	the apollo instances.

	Params:
		txCbor (string): The CBOR-encoded representation of the transaction.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with the loaded transaction.
	error: An error, if any, encountered during loading.
*/
func (b *Apollo) LoadTxCbor(txCbor string) (*Apollo, error) {
	tx := Transaction.Transaction{}
	cborBytes, err := hex.DecodeString(txCbor)
	if err != nil {
		return nil, err
	}
	err = cbor.Unmarshal(cborBytes, &tx)
	if err != nil {
		return b, err
	}
	b.tx = &tx
	return b, nil
}

/*
*

	UtxoFromRef retrieves a UTxO (Unspent Transaction Output) given its transaction hash and index.

	Params:


	txHash (string): The hexadecimal representation of the transaction hash.


	  		txIndex (int): The index of the UTxO within the transaction's outputs.

		Returns:
	  		*UTxO.UTxO: A pointer to the retrieved UTxO, or nil if not found.
*/
func (b *Apollo) UtxoFromRef(txHash string, txIndex int) (*UTxO.UTxO, error) {
	utxo, err := b.Context.GetUtxoFromRef(txHash, txIndex)
	if err != nil {
		return nil, err
	}
	if utxo == nil {
		return nil, errors.New("UTXO Doesn't exist")
	}
	return utxo, nil

}

/*
*

	AddVerificationKeyWitness adds a verification key witness to the transaction.

	Params:


		vkw (VerificationKeyWitness.VerificationKeyWitness): The verification key witness to add.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with the added verification key witness.
*/
func (b *Apollo) AddVerificationKeyWitness(
	vkw VerificationKeyWitness.VerificationKeyWitness,
) *Apollo {
	b.tx.TransactionWitnessSet.VkeyWitnesses = append(
		b.tx.TransactionWitnessSet.VkeyWitnesses,
		vkw,
	)
	return b
}

/*
*

	SetChangeAddressBech32 sets the change address for the transaction using a Bech32-encoded address.

	Params:


	  		address (string): The Bech32-encoded address to set as the change address.

		Returns:


	*Apollo: A pointer to the modified Apollo instance with the change address set.
*/
func (b *Apollo) SetChangeAddressBech32(address string) *Apollo {
	addr, err := Address.DecodeAddress(address)
	if err != nil {
		return b
	}
	b.inputAddresses = append(b.inputAddresses, addr)
	return b
}

/*
*

		SetChangeAddress sets the change address for the transaction using an Address object.

	 	Params:


	   	address (Address.Address): The Address object to set as the change address.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with the change address set.
*/
func (b *Apollo) SetChangeAddress(address Address.Address) *Apollo {
	b.inputAddresses = append(b.inputAddresses, address)
	return b
}

/*
*

	SetTtl function sets the time-to-live (TTL) for the transaction.

	Params:
		ttl (int64): The TTL value to set fro the transaction.

	Returns:
		*Apollo: A pointer to the modified Apollo instance with the TTl set.
*/
func (b *Apollo) SetTtl(ttl int64) *Apollo {
	b.Ttl = ttl
	return b
}

/*
*

	SetValidityStart function sets the validity start for the transaction.

	Params:


		invalidBefore (int64): The validity start value to set for the transaction.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with the validity start set.
*/
func (b *Apollo) SetValidityStart(invalidBefore int64) *Apollo {
	b.ValidityStart = invalidBefore
	return b
}

/*
*

	SetShelleyMetadata function sets the Shelley Mary metadata for the transaction's
	auxiliary data.

	Params:


		metadata (Metadata.ShelleyMaryMetadata): The Shelley Mary metadat to set.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with the Shelley Mary metadata set.
*/
func (b *Apollo) SetShelleyMetadata(
	metadata Metadata.ShelleyMaryMetadata,
) *Apollo {
	if b.auxiliaryData == nil {
		b.auxiliaryData = &Metadata.AuxiliaryData{}
		b.auxiliaryData.SetShelleyMetadata(metadata)
	} else {
		b.auxiliaryData.SetShelleyMetadata(metadata)
	}
	return b
}

/*
*

	GetUsedUTxOs returns the list of used UTxOs in the transaction.

	Returns:
	   []string: The list of used UTxOs as strings.
*/
func (b *Apollo) GetUsedUTxOs() []string {
	return b.usedUtxos
}

/*
*

	SetEstimationExUnitsRequired enables the estimation of execution units
	for the transaction.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with execution units estimation enabled.
*/
func (b *Apollo) SetEstimationExUnitsRequired() *Apollo {
	b.isEstimateRequired = true
	return b
}

/*
*

	AddReferenceInput adds a reference input to the transaction.

	Params:


		txHash (string): The hexadecimal representation of the reference transaction hash.
		index (int): The index of the reference input within its transaction.

	Returns:


	*Apollo: A pointer to the modified Apollo instance with the added reference input.
*/
func (b *Apollo) AddReferenceInput(txHash string, index int) *Apollo {
	decodedHash, _ := hex.DecodeString(txHash)
	exists := false
	for _, input := range b.referenceInputs {
		if bytes.Equal(input.TransactionId, decodedHash) &&
			input.Index == index {
			exists = true
			break
		}
	}
	if exists {
		return b
	}

	input := TransactionInput.TransactionInput{
		TransactionId: decodedHash,
		Index:         index,
	}
	b.referenceInputs = append(b.referenceInputs, input)
	return b
}

func (b *Apollo) AddReferenceInputV3(txHash string, index int) *Apollo {
	decodedHash, _ := hex.DecodeString(txHash)
	exists := false
	for _, input := range b.referenceInputsV3 {
		if bytes.Equal(input.TransactionId, decodedHash) &&
			input.Index == index {
			exists = true
			break
		}
	}
	if exists {
		return b
	}

	input := TransactionInput.TransactionInput{
		TransactionId: decodedHash,
		Index:         index,
	}
	b.referenceInputsV3 = append(b.referenceInputsV3, input)
	return b
}

/*
*

		DisableExecutionUnitsEstimation disables the estimation of execution units for the transaction.

	 	Returns:


	*Apollo: A pointer to the modified Apollo instance with execution units estimation disabled.
*/
func (b *Apollo) DisableExecutionUnitsEstimation() *Apollo {
	b.isEstimateRequired = false
	return b
}

/*
*

		SetCollateralAmount sets the collateral amount for the transaction.

	 	Returns:


	*Apollo: A pointer to the modified Apollo instance with the collateral amount set.
*/
func (b *Apollo) SetCollateralAmount(amount int) *Apollo {
	b.collateralAmount = amount
	return b
}

func (b *Apollo) AddWithdrawal(
	address Address.Address,
	amount int,
	redeemerData PlutusData.PlutusData,
) *Apollo {
	if b.withdrawals == nil {
		newWithdrawal := Withdrawal.New()
		b.withdrawals = &newWithdrawal
	}
	var stakeAddr [29]byte
	stakeAddr[0] = address.HeaderByte
	if len(address.StakingPart) != 28 {
		fmt.Printf(
			"AddWithdrawal: address has invalid or missing staking part: %v\n",
			address.StakingPart,
		)
	}
	copy(stakeAddr[1:], address.StakingPart)
	err := b.withdrawals.Add(stakeAddr, amount)
	if err != nil {
		fmt.Printf("AddWithdrawal: %v\n", err)
		return b
	}
	newRedeemer := Redeemer.Redeemer{
		Tag:     Redeemer.REWARD,
		Index:   b.withdrawals.Size() - 1, // We just added a withdrawal
		Data:    redeemerData,
		ExUnits: Redeemer.ExecutionUnits{}, // This will be filled in when we eval later
	}
	b.stakeRedeemers[strconv.Itoa(b.withdrawals.Size()-1)] = newRedeemer
	return b
}

func (b *Apollo) AddCollateral(utxo UTxO.UTxO) *Apollo {
	b.collaterals = append(b.collaterals, utxo)
	return b
}

func (b *Apollo) CompleteExact(
	fee int,
) (*Apollo, []byte, error) {
	//SET REDEEMER INDEXES
	b = b.setRedeemerIndexes()
	//SET COLLATERAL
	b, err := b.setCollateral()
	if err != nil {
		return nil, nil, err
	}
	//UPDATE EXUNITS
	b, txCbor, err := b.updateExUnitsExact(fee)
	if err != nil {
		return b, txCbor, err
	}
	//ADDCHANGEANDFEE
	b.Fee = int64(fee)
	//FINALIZE TX
	body, err := b.buildTxBody()
	if err != nil {
		return nil, txCbor, err
	}
	witnessSet := b.buildWitnessSet()
	b.tx = &Transaction.Transaction{
		TransactionBody:       body,
		TransactionWitnessSet: witnessSet,
		AuxiliaryData:         b.auxiliaryData,
		Valid:                 true,
	}
	return b, nil, nil
}

func (b *Apollo) estimateExunitsExact(
	fee int,
) (
	map[string]Redeemer.ExecutionUnits,
	[]byte,
	error,
) {
	cloned_b := b.Clone()
	cloned_b.isEstimateRequired = false
	updated_b, _, err := cloned_b.CompleteExact(fee)
	if err != nil {
		return make(
			map[string]Redeemer.ExecutionUnits, 0,
		), nil, err
	}
	tx_cbor, err := cbor.Marshal(updated_b.tx)
	if err != nil {
		return make(
			map[string]Redeemer.ExecutionUnits, 0,
		), nil, err
	}
	result, err := b.Context.EvaluateTx(tx_cbor)
	if err != nil {
		return result, tx_cbor, err
	}
	return result, nil, nil
}

func (b *Apollo) updateExUnitsExact(
	fee int,
) (*Apollo, []byte, error) {
	if b.isEstimateRequired {
		estimated_execution_units, tx_cbor, err :=
			b.estimateExunitsExact(fee)
		if err != nil {
			return b, tx_cbor, fmt.Errorf(
				"could not estimate ExUnits: %w", err,
			)
		}
		for k, redeemer := range b.redeemersToUTxO {
			key := fmt.Sprintf(
				"%s:%d",
				Redeemer.RedeemerTagNames[redeemer.Tag],
				redeemer.Index,
			)
			if _, ok := estimated_execution_units[key]; ok {
				redeemer.ExUnits = estimated_execution_units[key]
				b.redeemersToUTxO[k] = redeemer
			}
		}
		for k, redeemer := range b.stakeRedeemers {
			key := fmt.Sprintf(
				"%s:%d",
				Redeemer.RedeemerTagNames[redeemer.Tag],
				redeemer.Index,
			)
			if _, ok := estimated_execution_units[key]; ok {
				redeemer.ExUnits = estimated_execution_units[key]
				b.stakeRedeemers[k] = redeemer
			}
		}
		for k, redeemer := range b.mintRedeemers {
			key := fmt.Sprintf(
				"%s:%d",
				Redeemer.RedeemerTagNames[redeemer.Tag],
				redeemer.Index,
			)
			if _, ok := estimated_execution_units[key]; ok {
				redeemer.ExUnits = estimated_execution_units[key]
				b.mintRedeemers[k] = redeemer
			}
		}
		for _, redeemer := range b.redeemersToUTxO {
			b.redeemers = append(b.redeemers, redeemer)
		}
		for _, redeemer := range b.stakeRedeemers {
			b.redeemers = append(b.redeemers, redeemer)
		}
		for _, redeemer := range b.mintRedeemers {
			b.redeemers = append(b.redeemers, redeemer)

		}
	} else {
		for _, redeemer := range b.redeemersToUTxO {
			b.redeemers = append(b.redeemers, redeemer)
		}
		for _, redeemer := range b.stakeRedeemers {
			b.redeemers = append(b.redeemers, redeemer)
		}
		for _, redeemer := range b.mintRedeemers {
			b.redeemers = append(b.redeemers, redeemer)
		}

	}
	// Sort redeemers by (Tag, Index) to ensure deterministic ordering.
	// Without sorting, Go's map iteration produces non-deterministic order,
	// causing different script_data_hash values on each run.
	slices.SortFunc(b.redeemers, func(a, b Redeemer.Redeemer) int {
		if a.Tag != b.Tag {
			return int(a.Tag) - int(b.Tag)
		}
		return a.Index - b.Index
	})
	return b, nil, nil
}

func (b *Apollo) GetPaymentsLength() int {
	return len(b.payments)
}

func (b *Apollo) GetRedeemers() map[string]Redeemer.Redeemer {
	return b.redeemersToUTxO
}

func (b *Apollo) UpdateRedeemers(
	newRedeemers map[string]Redeemer.Redeemer,
) *Apollo {
	b.redeemersToUTxO = newRedeemers
	return b
}

func (b *Apollo) GetSortedInputs() []UTxO.UTxO {
	return SortUtxos(b.preselectedUtxos)
}