TxSubmissionErrors: {
    AddressAttributesTooLargeError: (new (rawError: AddressAttributesTooLarge) => {});
    AlreadyDelegatingError: (new (rawError: AlreadyDelegating) => {});
    BadInputsError: (new (rawError: BadInputs) => {});
    CollateralHasNonAdaAssetsError: (new (rawError: CollateralHasNonAdaAssets) => {});
    CollateralIsScriptError: (new (rawError: CollateralIsScript) => {});
    CollateralTooSmallError: (new (rawError: CollateralTooSmall) => {});
    CollectErrorsError: (new (rawError: CollectErrors) => {});
    DelegateNotRegisteredError: (new (rawError: DelegateNotRegistered) => {});
    DuplicateGenesisVrfError: (new (rawError: DuplicateGenesisVrf) => {});
    EraMismatchError: (new (rawError: EraMismatch) => {});
    ExecutionUnitsTooLargeError: (new (rawError: ExecutionUnitsTooLarge) => {});
    ExpiredUtxoError: (new (rawError: ExpiredUtxo) => {});
    ExtraDataMismatchError: (new (rawError: ExtraDataMismatch) => {});
    ExtraRedeemersError: (new (rawError: ExtraRedeemers) => {});
    ExtraScriptWitnessesError: (new (rawError: ExtraScriptWitnesses) => {});
    FeeTooSmallError: (new (rawError: FeeTooSmall) => {});
    InsufficientFundsForMirError: (new (rawError: InsufficientFundsForMir) => {});
    InsufficientGenesisSignaturesError: (new (rawError: InsufficientGenesisSignatures) => {});
    InvalidMetadataError: (new (rawError: InvalidMetadata) => {});
    InvalidWitnessesError: (new (rawError: InvalidWitnesses) => {});
    MalformedReferenceScriptsError: (new (rawError: MalformedReferenceScripts) => {});
    MalformedScriptWitnessesError: (new (rawError: MalformedScriptWitnesses) => {});
    MirNegativeTransferError: (new (rawError: MirNegativeTransfer) => {});
    MirNegativeTransferNotCurrentlyAllowedError: (new (rawError: MirNegativeTransferNotCurrentlyAllowed) => {});
    MirProducesNegativeUpdateError: (new (rawError: MirProducesNegativeUpdate) => {});
    MirTransferNotCurrentlyAllowedError: (new (rawError: MirTransferNotCurrentlyAllowed) => {});
    MissingAtLeastOneInputUtxoError: (new (rawError: MissingAtLeastOneInputUtxo) => {});
    MissingCollateralInputsError: (new (rawError: MissingCollateralInputs) => {});
    MissingDatumHashesForInputsError: (new (rawError: MissingDatumHashesForInputs) => {});
    MissingRequiredDatumsError: (new (rawError: MissingRequiredDatums) => {});
    MissingRequiredRedeemersError: (new (rawError: MissingRequiredRedeemers) => {});
    MissingRequiredSignaturesError: (new (rawError: MissingRequiredSignatures) => {});
    MissingScriptWitnessesError: (new (rawError: MissingScriptWitnesses) => {});
    MissingTxMetadataError: (new (rawError: MissingTxMetadata) => {});
    MissingTxMetadataHashError: (new (rawError: MissingTxMetadataHash) => {});
    MissingVkWitnessesError: (new (rawError: MissingVkWitnesses) => {});
    NetworkMismatchError: (new (rawError: NetworkMismatch) => {});
    NonGenesisVotersError: (new (rawError: NonGenesisVoters) => {});
    OutputTooSmallError: (new (rawError: OutputTooSmall) => {});
    OutsideForecastError: (new (rawError: OutsideForecast) => {});
    OutsideOfValidityIntervalError: (new (rawError: OutsideOfValidityInterval) => {});
    PoolCostTooSmallError: (new (rawError: PoolCostTooSmall) => {});
    PoolMetadataHashTooBigError: (new (rawError: PoolMetadataHashTooBig) => {});
    ProtocolVersionCannotFollowError: (new (rawError: ProtocolVersionCannotFollow) => {});
    RewardAccountNotEmptyError: (new (rawError: RewardAccountNotEmpty) => {});
    RewardAccountNotExistingError: (new (rawError: RewardAccountNotExisting) => {});
    ScriptWitnessNotValidatingError: (new (rawError: ScriptWitnessNotValidating) => {});
    StakeKeyAlreadyRegisteredError: (new (rawError: StakeKeyAlreadyRegistered) => {});
    StakeKeyNotRegisteredError: (new (rawError: StakeKeyNotRegistered) => {});
    StakePoolNotRegisteredError: (new (rawError: StakePoolNotRegistered) => {});
    TooLateForMirError: (new (rawError: TooLateForMir) => {});
    TooManyAssetsInOutputError: (new (rawError: TooManyAssetsInOutput) => {});
    TooManyCollateralInputsError: (new (rawError: TooManyCollateralInputs) => {});
    TotalCollateralMismatchError: (new (rawError: TotalCollateralMismatch) => {});
    TriesToForgeAdaError: (new (rawError: TriesToForgeAda) => {});
    TxMetadataHashMismatchError: (new (rawError: TxMetadataHashMismatch) => {});
    TxTooLargeError: (new (rawError: TxTooLarge) => {});
    UnknownGenesisKeyError: (new (rawError: UnknownGenesisKey) => {});
    UnknownOrIncompleteWithdrawalsError: (new (rawError: UnknownOrIncompleteWithdrawals) => {});
    UnspendableDatumsError: (new (rawError: UnspendableDatums) => {});
    UnspendableScriptInputsError: (new (rawError: UnspendableScriptInputs) => {});
    UpdateWrongEpochError: (new (rawError: UpdateWrongEpoch) => {});
    ValidationTagMismatchError: (new (rawError: ValidationTagMismatch) => {});
    ValueNotConservedError: (new (rawError: ValueNotConserved) => {});
    WrongCertificateTypeError: (new (rawError: WrongCertificateType) => {});
    WrongPoolCertificateError: (new (rawError: WrongPoolCertificate) => {});
    WrongRetirementEpochError: (new (rawError: WrongRetirementEpoch) => {});
} = ...

Type declaration

  • AddressAttributesTooLargeError: (new (rawError: AddressAttributesTooLarge) => {})
      • new (rawError: AddressAttributesTooLarge): {}
      • Parameters

        • rawError: AddressAttributesTooLarge

        Returns {}

    • AlreadyDelegatingError: (new (rawError: AlreadyDelegating) => {})
        • new (rawError: AlreadyDelegating): {}
        • Parameters

          • rawError: AlreadyDelegating

          Returns {}

      • BadInputsError: (new (rawError: BadInputs) => {})
          • new (rawError: BadInputs): {}
          • Parameters

            • rawError: BadInputs

            Returns {}

        • CollateralHasNonAdaAssetsError: (new (rawError: CollateralHasNonAdaAssets) => {})
            • new (rawError: CollateralHasNonAdaAssets): {}
            • Parameters

              • rawError: CollateralHasNonAdaAssets

              Returns {}

          • CollateralIsScriptError: (new (rawError: CollateralIsScript) => {})
              • new (rawError: CollateralIsScript): {}
              • Parameters

                • rawError: CollateralIsScript

                Returns {}

            • CollateralTooSmallError: (new (rawError: CollateralTooSmall) => {})
                • new (rawError: CollateralTooSmall): {}
                • Parameters

                  • rawError: CollateralTooSmall

                  Returns {}

              • CollectErrorsError: (new (rawError: CollectErrors) => {})
                  • new (rawError: CollectErrors): {}
                  • Parameters

                    • rawError: CollectErrors

                    Returns {}

                • DelegateNotRegisteredError: (new (rawError: DelegateNotRegistered) => {})
                    • new (rawError: DelegateNotRegistered): {}
                    • Parameters

                      • rawError: DelegateNotRegistered

                      Returns {}

                  • DuplicateGenesisVrfError: (new (rawError: DuplicateGenesisVrf) => {})
                      • new (rawError: DuplicateGenesisVrf): {}
                      • Parameters

                        • rawError: DuplicateGenesisVrf

                        Returns {}

                    • EraMismatchError: (new (rawError: EraMismatch) => {})
                        • new (rawError: EraMismatch): {}
                        • Parameters

                          • rawError: EraMismatch

                          Returns {}

                      • ExecutionUnitsTooLargeError: (new (rawError: ExecutionUnitsTooLarge) => {})
                          • new (rawError: ExecutionUnitsTooLarge): {}
                          • Parameters

                            • rawError: ExecutionUnitsTooLarge

                            Returns {}

                        • ExpiredUtxoError: (new (rawError: ExpiredUtxo) => {})
                            • new (rawError: ExpiredUtxo): {}
                            • Parameters

                              • rawError: ExpiredUtxo

                              Returns {}

                          • ExtraDataMismatchError: (new (rawError: ExtraDataMismatch) => {})
                              • new (rawError: ExtraDataMismatch): {}
                              • Parameters

                                • rawError: ExtraDataMismatch

                                Returns {}

                            • ExtraRedeemersError: (new (rawError: ExtraRedeemers) => {})
                                • new (rawError: ExtraRedeemers): {}
                                • Parameters

                                  • rawError: ExtraRedeemers

                                  Returns {}

                              • ExtraScriptWitnessesError: (new (rawError: ExtraScriptWitnesses) => {})
                                  • new (rawError: ExtraScriptWitnesses): {}
                                  • Parameters

                                    • rawError: ExtraScriptWitnesses

                                    Returns {}

                                • FeeTooSmallError: (new (rawError: FeeTooSmall) => {})
                                    • new (rawError: FeeTooSmall): {}
                                    • Parameters

                                      • rawError: FeeTooSmall

                                      Returns {}

                                  • InsufficientFundsForMirError: (new (rawError: InsufficientFundsForMir) => {})
                                      • new (rawError: InsufficientFundsForMir): {}
                                      • Parameters

                                        • rawError: InsufficientFundsForMir

                                        Returns {}

                                    • InsufficientGenesisSignaturesError: (new (rawError: InsufficientGenesisSignatures) => {})
                                        • new (rawError: InsufficientGenesisSignatures): {}
                                        • Parameters

                                          • rawError: InsufficientGenesisSignatures

                                          Returns {}

                                      • InvalidMetadataError: (new (rawError: InvalidMetadata) => {})
                                          • new (rawError: InvalidMetadata): {}
                                          • Parameters

                                            • rawError: InvalidMetadata

                                            Returns {}

                                        • InvalidWitnessesError: (new (rawError: InvalidWitnesses) => {})
                                            • new (rawError: InvalidWitnesses): {}
                                            • Parameters

                                              • rawError: InvalidWitnesses

                                              Returns {}

                                          • MalformedReferenceScriptsError: (new (rawError: MalformedReferenceScripts) => {})
                                              • new (rawError: MalformedReferenceScripts): {}
                                              • Parameters

                                                • rawError: MalformedReferenceScripts

                                                Returns {}

                                            • MalformedScriptWitnessesError: (new (rawError: MalformedScriptWitnesses) => {})
                                                • new (rawError: MalformedScriptWitnesses): {}
                                                • Parameters

                                                  • rawError: MalformedScriptWitnesses

                                                  Returns {}

                                              • MirNegativeTransferError: (new (rawError: MirNegativeTransfer) => {})
                                                  • new (rawError: MirNegativeTransfer): {}
                                                  • Parameters

                                                    • rawError: MirNegativeTransfer

                                                    Returns {}

                                                • MirNegativeTransferNotCurrentlyAllowedError: (new (rawError: MirNegativeTransferNotCurrentlyAllowed) => {})
                                                    • new (rawError: MirNegativeTransferNotCurrentlyAllowed): {}
                                                    • Parameters

                                                      • rawError: MirNegativeTransferNotCurrentlyAllowed

                                                      Returns {}

                                                  • MirProducesNegativeUpdateError: (new (rawError: MirProducesNegativeUpdate) => {})
                                                      • new (rawError: MirProducesNegativeUpdate): {}
                                                      • Parameters

                                                        • rawError: MirProducesNegativeUpdate

                                                        Returns {}

                                                    • MirTransferNotCurrentlyAllowedError: (new (rawError: MirTransferNotCurrentlyAllowed) => {})
                                                        • new (rawError: MirTransferNotCurrentlyAllowed): {}
                                                        • Parameters

                                                          • rawError: MirTransferNotCurrentlyAllowed

                                                          Returns {}

                                                      • MissingAtLeastOneInputUtxoError: (new (rawError: MissingAtLeastOneInputUtxo) => {})
                                                          • new (rawError: MissingAtLeastOneInputUtxo): {}
                                                          • Parameters

                                                            • rawError: MissingAtLeastOneInputUtxo

                                                            Returns {}

                                                        • MissingCollateralInputsError: (new (rawError: MissingCollateralInputs) => {})
                                                            • new (rawError: MissingCollateralInputs): {}
                                                            • Parameters

                                                              • rawError: MissingCollateralInputs

                                                              Returns {}

                                                          • MissingDatumHashesForInputsError: (new (rawError: MissingDatumHashesForInputs) => {})
                                                              • new (rawError: MissingDatumHashesForInputs): {}
                                                              • Parameters

                                                                • rawError: MissingDatumHashesForInputs

                                                                Returns {}

                                                            • MissingRequiredDatumsError: (new (rawError: MissingRequiredDatums) => {})
                                                                • new (rawError: MissingRequiredDatums): {}
                                                                • Parameters

                                                                  • rawError: MissingRequiredDatums

                                                                  Returns {}

                                                              • MissingRequiredRedeemersError: (new (rawError: MissingRequiredRedeemers) => {})
                                                                  • new (rawError: MissingRequiredRedeemers): {}
                                                                  • Parameters

                                                                    • rawError: MissingRequiredRedeemers

                                                                    Returns {}

                                                                • MissingRequiredSignaturesError: (new (rawError: MissingRequiredSignatures) => {})
                                                                    • new (rawError: MissingRequiredSignatures): {}
                                                                    • Parameters

                                                                      • rawError: MissingRequiredSignatures

                                                                      Returns {}

                                                                  • MissingScriptWitnessesError: (new (rawError: MissingScriptWitnesses) => {})
                                                                      • new (rawError: MissingScriptWitnesses): {}
                                                                      • Parameters

                                                                        • rawError: MissingScriptWitnesses

                                                                        Returns {}

                                                                    • MissingTxMetadataError: (new (rawError: MissingTxMetadata) => {})
                                                                        • new (rawError: MissingTxMetadata): {}
                                                                        • Parameters

                                                                          • rawError: MissingTxMetadata

                                                                          Returns {}

                                                                      • MissingTxMetadataHashError: (new (rawError: MissingTxMetadataHash) => {})
                                                                          • new (rawError: MissingTxMetadataHash): {}
                                                                          • Parameters

                                                                            • rawError: MissingTxMetadataHash

                                                                            Returns {}

                                                                        • MissingVkWitnessesError: (new (rawError: MissingVkWitnesses) => {})
                                                                            • new (rawError: MissingVkWitnesses): {}
                                                                            • Parameters

                                                                              • rawError: MissingVkWitnesses

                                                                              Returns {}

                                                                          • NetworkMismatchError: (new (rawError: NetworkMismatch) => {})
                                                                              • new (rawError: NetworkMismatch): {}
                                                                              • Parameters

                                                                                • rawError: NetworkMismatch

                                                                                Returns {}

                                                                            • NonGenesisVotersError: (new (rawError: NonGenesisVoters) => {})
                                                                                • new (rawError: NonGenesisVoters): {}
                                                                                • Parameters

                                                                                  • rawError: NonGenesisVoters

                                                                                  Returns {}

                                                                              • OutputTooSmallError: (new (rawError: OutputTooSmall) => {})
                                                                                  • new (rawError: OutputTooSmall): {}
                                                                                  • Parameters

                                                                                    • rawError: OutputTooSmall

                                                                                    Returns {}

                                                                                • OutsideForecastError: (new (rawError: OutsideForecast) => {})
                                                                                    • new (rawError: OutsideForecast): {}
                                                                                    • Parameters

                                                                                      • rawError: OutsideForecast

                                                                                      Returns {}

                                                                                  • OutsideOfValidityIntervalError: (new (rawError: OutsideOfValidityInterval) => {})
                                                                                      • new (rawError: OutsideOfValidityInterval): {}
                                                                                      • Parameters

                                                                                        • rawError: OutsideOfValidityInterval

                                                                                        Returns {}

                                                                                    • PoolCostTooSmallError: (new (rawError: PoolCostTooSmall) => {})
                                                                                        • new (rawError: PoolCostTooSmall): {}
                                                                                        • Parameters

                                                                                          • rawError: PoolCostTooSmall

                                                                                          Returns {}

                                                                                      • PoolMetadataHashTooBigError: (new (rawError: PoolMetadataHashTooBig) => {})
                                                                                          • new (rawError: PoolMetadataHashTooBig): {}
                                                                                          • Parameters

                                                                                            • rawError: PoolMetadataHashTooBig

                                                                                            Returns {}

                                                                                        • ProtocolVersionCannotFollowError: (new (rawError: ProtocolVersionCannotFollow) => {})
                                                                                            • new (rawError: ProtocolVersionCannotFollow): {}
                                                                                            • Parameters

                                                                                              • rawError: ProtocolVersionCannotFollow

                                                                                              Returns {}

                                                                                          • RewardAccountNotEmptyError: (new (rawError: RewardAccountNotEmpty) => {})
                                                                                              • new (rawError: RewardAccountNotEmpty): {}
                                                                                              • Parameters

                                                                                                • rawError: RewardAccountNotEmpty

                                                                                                Returns {}

                                                                                            • RewardAccountNotExistingError: (new (rawError: RewardAccountNotExisting) => {})
                                                                                                • new (rawError: RewardAccountNotExisting): {}
                                                                                                • Parameters

                                                                                                  • rawError: RewardAccountNotExisting

                                                                                                  Returns {}

                                                                                              • ScriptWitnessNotValidatingError: (new (rawError: ScriptWitnessNotValidating) => {})
                                                                                                  • new (rawError: ScriptWitnessNotValidating): {}
                                                                                                  • Parameters

                                                                                                    • rawError: ScriptWitnessNotValidating

                                                                                                    Returns {}

                                                                                                • StakeKeyAlreadyRegisteredError: (new (rawError: StakeKeyAlreadyRegistered) => {})
                                                                                                    • new (rawError: StakeKeyAlreadyRegistered): {}
                                                                                                    • Parameters

                                                                                                      • rawError: StakeKeyAlreadyRegistered

                                                                                                      Returns {}

                                                                                                  • StakeKeyNotRegisteredError: (new (rawError: StakeKeyNotRegistered) => {})
                                                                                                      • new (rawError: StakeKeyNotRegistered): {}
                                                                                                      • Parameters

                                                                                                        • rawError: StakeKeyNotRegistered

                                                                                                        Returns {}

                                                                                                    • StakePoolNotRegisteredError: (new (rawError: StakePoolNotRegistered) => {})
                                                                                                        • new (rawError: StakePoolNotRegistered): {}
                                                                                                        • Parameters

                                                                                                          • rawError: StakePoolNotRegistered

                                                                                                          Returns {}

                                                                                                      • TooLateForMirError: (new (rawError: TooLateForMir) => {})
                                                                                                          • new (rawError: TooLateForMir): {}
                                                                                                          • Parameters

                                                                                                            • rawError: TooLateForMir

                                                                                                            Returns {}

                                                                                                        • TooManyAssetsInOutputError: (new (rawError: TooManyAssetsInOutput) => {})
                                                                                                            • new (rawError: TooManyAssetsInOutput): {}
                                                                                                            • Parameters

                                                                                                              • rawError: TooManyAssetsInOutput

                                                                                                              Returns {}

                                                                                                          • TooManyCollateralInputsError: (new (rawError: TooManyCollateralInputs) => {})
                                                                                                              • new (rawError: TooManyCollateralInputs): {}
                                                                                                              • Parameters

                                                                                                                • rawError: TooManyCollateralInputs

                                                                                                                Returns {}

                                                                                                            • TotalCollateralMismatchError: (new (rawError: TotalCollateralMismatch) => {})
                                                                                                                • new (rawError: TotalCollateralMismatch): {}
                                                                                                                • Parameters

                                                                                                                  • rawError: TotalCollateralMismatch

                                                                                                                  Returns {}

                                                                                                              • TriesToForgeAdaError: (new (rawError: TriesToForgeAda) => {})
                                                                                                                  • new (rawError: TriesToForgeAda): {}
                                                                                                                  • Parameters

                                                                                                                    • rawError: TriesToForgeAda

                                                                                                                    Returns {}

                                                                                                                • TxMetadataHashMismatchError: (new (rawError: TxMetadataHashMismatch) => {})
                                                                                                                    • new (rawError: TxMetadataHashMismatch): {}
                                                                                                                    • Parameters

                                                                                                                      • rawError: TxMetadataHashMismatch

                                                                                                                      Returns {}

                                                                                                                  • TxTooLargeError: (new (rawError: TxTooLarge) => {})
                                                                                                                      • new (rawError: TxTooLarge): {}
                                                                                                                      • Parameters

                                                                                                                        • rawError: TxTooLarge

                                                                                                                        Returns {}

                                                                                                                    • UnknownGenesisKeyError: (new (rawError: UnknownGenesisKey) => {})
                                                                                                                        • new (rawError: UnknownGenesisKey): {}
                                                                                                                        • Parameters

                                                                                                                          • rawError: UnknownGenesisKey

                                                                                                                          Returns {}

                                                                                                                      • UnknownOrIncompleteWithdrawalsError: (new (rawError: UnknownOrIncompleteWithdrawals) => {})
                                                                                                                          • new (rawError: UnknownOrIncompleteWithdrawals): {}
                                                                                                                          • Parameters

                                                                                                                            • rawError: UnknownOrIncompleteWithdrawals

                                                                                                                            Returns {}

                                                                                                                        • UnspendableDatumsError: (new (rawError: UnspendableDatums) => {})
                                                                                                                            • new (rawError: UnspendableDatums): {}
                                                                                                                            • Parameters

                                                                                                                              • rawError: UnspendableDatums

                                                                                                                              Returns {}

                                                                                                                          • UnspendableScriptInputsError: (new (rawError: UnspendableScriptInputs) => {})
                                                                                                                              • new (rawError: UnspendableScriptInputs): {}
                                                                                                                              • Parameters

                                                                                                                                • rawError: UnspendableScriptInputs

                                                                                                                                Returns {}

                                                                                                                            • UpdateWrongEpochError: (new (rawError: UpdateWrongEpoch) => {})
                                                                                                                                • new (rawError: UpdateWrongEpoch): {}
                                                                                                                                • Parameters

                                                                                                                                  • rawError: UpdateWrongEpoch

                                                                                                                                  Returns {}

                                                                                                                              • ValidationTagMismatchError: (new (rawError: ValidationTagMismatch) => {})
                                                                                                                                  • new (rawError: ValidationTagMismatch): {}
                                                                                                                                  • Parameters

                                                                                                                                    • rawError: ValidationTagMismatch

                                                                                                                                    Returns {}

                                                                                                                                • ValueNotConservedError: (new (rawError: ValueNotConserved) => {})
                                                                                                                                    • new (rawError: ValueNotConserved): {}
                                                                                                                                    • Parameters

                                                                                                                                      • rawError: ValueNotConserved

                                                                                                                                      Returns {}

                                                                                                                                  • WrongCertificateTypeError: (new (rawError: WrongCertificateType) => {})
                                                                                                                                      • new (rawError: WrongCertificateType): {}
                                                                                                                                      • Parameters

                                                                                                                                        • rawError: WrongCertificateType

                                                                                                                                        Returns {}

                                                                                                                                    • WrongPoolCertificateError: (new (rawError: WrongPoolCertificate) => {})
                                                                                                                                        • new (rawError: WrongPoolCertificate): {}
                                                                                                                                        • Parameters

                                                                                                                                          • rawError: WrongPoolCertificate

                                                                                                                                          Returns {}

                                                                                                                                      • WrongRetirementEpochError: (new (rawError: WrongRetirementEpoch) => {})
                                                                                                                                          • new (rawError: WrongRetirementEpoch): {}
                                                                                                                                          • Parameters

                                                                                                                                            • rawError: WrongRetirementEpoch

                                                                                                                                            Returns {}

                                                                                                                                        Generated using TypeDoc