@cardananium/cquisitor-lib 0.1.0-beta.12 → 0.1.0-beta.15

package/browser/cquisitor_lib.d.ts

@@ -1,32 +1,44 @@
+/**
+* @param {string} tx_hex
+* @returns {string}
+*/
+declare function get_necessary_data_list_js(tx_hex: string): string;
+/**
+* @param {string} tx_hex
+* @param {ValidationInputContext} validation_context
+* @returns {string}
+*/
+declare function validate_transaction_js(tx_hex: string, validation_context: ValidationInputContext): string;
+
 /**
  * @returns {(string)[]}
  */
-export function get_decodable_types(): (string)[];
+declare function get_decodable_types(): (string)[];
 /**
  * @param {string} input
  * @param {string} type_name
  * @param {any} params_json
  * @returns {any}
  */
-export function decode_specific_type(input: string, type_name: string, params_json: DecodingParams): any;
+declare function decode_specific_type(input: string, type_name: string, params_json: DecodingParams): any;
 /**
  * @param {string} input
  * @returns {(string)[]}
  */
-export function get_possible_types_for_input(input: string): (string)[];
+declare function get_possible_types_for_input(input: string): (string)[];
 /**
  * @param {string} cbor_hex
  * @returns {any}
  */
-export function cbor_to_json(cbor_hex: string): CborValue;
+declare function cbor_to_json(cbor_hex: string): CborValue;
 
-export function check_block_or_tx_signatures(hex_str: string): CheckSignaturesResult;
+declare function check_block_or_tx_signatures(hex_str: string): CheckSignaturesResult;
 
 /**
  * @param {string} tx_hex
  * @returns {(string)[]}
  */
-export function get_utxo_list_from_tx(tx_hex: string): string[];
+declare function get_utxo_list_from_tx(tx_hex: string): string[];
 
 /**
  * @param {string} tx_hex
@@ -34,24 +46,24 @@ export function get_utxo_list_from_tx(tx_hex: string): string[];
  * @param {CostModels} cost_models_json
  * @returns {ExecuteTxScriptsResult}
  */
-export function execute_tx_scripts(tx_hex: string, utxo_json: UTxO[], cost_models_json: CostModels): ExecuteTxScriptsResult;
+declare function execute_tx_scripts(tx_hex: string, utxo_json: UTxO[], cost_models_json: CostModels): ExecuteTxScriptsResult;
 /**
  * @param {string} hex
  * @returns {ProgramJson}
  */
-export function decode_plutus_program_uplc_json(hex: string): ProgramJson;
+declare function decode_plutus_program_uplc_json(hex: string): ProgramJson;
 /**
  * @param {string} hex
  * @returns {string}
  */
-export function decode_plutus_program_pretty_uplc(hex: string): string;
+declare function decode_plutus_program_pretty_uplc(hex: string): string;
 
-export interface CborPosition {
+declare interface CborPosition {
     offset: number;
     length: number;
 }
 
-export type CborSimpleType =
+declare type CborSimpleType =
     | "Null"
     | "Bool"
     | "U8"
@@ -72,13 +84,13 @@ export type CborSimpleType =
     | "Undefined"
     | "Break";
 
-export interface CborSimple {
+declare interface CborSimple {
     position_info: CborPosition;
     struct_position_info?: CborPosition;
     value: any;
 }
 
-export interface CborArray {
+declare interface CborArray {
     type: "Array";
     position_info: CborPosition;
     struct_position_info: CborPosition;
@@ -86,7 +98,7 @@ export interface CborArray {
     values: CborValue[]; // nested
 }
 
-export interface CborMap {
+declare interface CborMap {
     type: "Map";
     position_info: CborPosition;
     struct_position_info: CborPosition;
@@ -97,7 +109,7 @@ export interface CborMap {
     }[];
 }
 
-export interface CborTag {
+declare interface CborTag {
     type: "Tag";
     position_info: CborPosition;
     struct_position_info: CborPosition;
@@ -105,21 +117,21 @@ export interface CborTag {
     value: CborValue;
 }
 
-export interface CborIndefiniteString {
+declare interface CborIndefiniteString {
     type: "IndefiniteLengthString";
     position_info: CborPosition;
     struct_position_info: CborPosition;
     chunks: CborValue[];
 }
 
-export interface CborIndefiniteBytes {
+declare interface CborIndefiniteBytes {
     type: "IndefiniteLengthBytes";
     position_info: CborPosition;
     struct_position_info: CborPosition;
     chunks: CborValue[];
 }
 
-export type CborValue =
+declare type CborValue =
     | CborSimple
     | CborArray
     | CborMap
@@ -127,14 +139,14 @@ export type CborValue =
     | CborIndefiniteString
     | CborIndefiniteBytes;
 
-export interface DecodingParams {
+declare interface DecodingParams {
     plutus_script_version?: number;
     plutus_data_schema?: PlutusDataSchema;
 }
 
-export type PlutusDataSchema = "BasicConversions" | "DetailedSchema";
+declare type PlutusDataSchema = "BasicConversions" | "DetailedSchema";
 
-export interface CheckSignaturesResult {
+declare interface CheckSignaturesResult {
     /** Indicates whether the transaction or block is valid. */
     valid: boolean;
     /** The transaction hash as a hexadecimal string (if available). */
@@ -147,17 +159,17 @@ export interface CheckSignaturesResult {
 
 
 // The execution units object contains two numeric fields.
-export type ExUnits = {
+declare type ExUnits = {
     steps: number;
     mem: number;
 };
 
 // The redeemer tag is one of the following literal strings.
-export type RedeemerTag = "Spend" | "Mint" | "Cert" | "Reward" | "Propose" | "Vote";
+declare type RedeemerTag = "Spend" | "Mint" | "Cert" | "Reward" | "Propose" | "Vote";
 
 // A successful redeemer evaluation contains the original execution units,
 // the calculated execution units, and additional redeemer info.
-export interface RedeemerSuccess {
+declare interface RedeemerSuccess {
     original_ex_units: ExUnits;
     calculated_ex_units: ExUnits;
     redeemer_index: number;
@@ -166,7 +178,7 @@ export interface RedeemerSuccess {
 
 // A failed redeemer evaluation contains the original execution units,
 // an error message, and additional redeemer info.
-export interface RedeemerError {
+declare interface RedeemerError {
     original_ex_units: ExUnits;
     error: string;
     redeemer_index: number;
@@ -175,14 +187,14 @@ export interface RedeemerError {
 
 // The result from executing the transaction scripts is an array of redeemer results.
 // Each result can be either a success or an error.
-export type RedeemerResult = RedeemerSuccess | RedeemerError;
+declare type RedeemerResult = RedeemerSuccess | RedeemerError;
 
 // Type for the `execute_tx_scripts` response after JSON-parsing.
-export type ExecuteTxScriptsResult = RedeemerResult[];
+declare type ExecuteTxScriptsResult = RedeemerResult[];
 
 
 // The overall JSON produced by `to_json_program`:
-export interface ProgramJson {
+declare interface ProgramJson {
     program: {
         version: string;
         term: Term;
@@ -190,7 +202,7 @@ export interface ProgramJson {
 }
 
 // A UPLC term can be one of several forms.
-export type Term =
+declare type Term =
     | VarTerm
     | DelayTerm
     | LambdaTerm
@@ -202,52 +214,52 @@ export type Term =
     | ConstrTerm
     | CaseTerm;
 
-export interface VarTerm {
+declare interface VarTerm {
     var: string;
 }
 
-export interface DelayTerm {
+declare interface DelayTerm {
     delay: Term;
 }
 
-export interface LambdaTerm {
+declare interface LambdaTerm {
     lambda: {
         parameter_name: string;
         body: Term;
     };
 }
 
-export interface ApplyTerm {
+declare interface ApplyTerm {
     apply: {
         function: Term;
         argument: Term;
     };
 }
 
-export interface ConstantTerm {
+declare interface ConstantTerm {
     constant: Constant;
 }
 
-export interface ForceTerm {
+declare interface ForceTerm {
     force: Term;
 }
 
-export interface ErrorTerm {
+declare interface ErrorTerm {
     error: "error";
 }
 
-export interface BuiltinTerm {
+declare interface BuiltinTerm {
     builtin: string;
 }
 
-export interface ConstrTerm {
+declare interface ConstrTerm {
     constr: {
         tag: number;
         fields: Term[];
     };
 }
 
-export interface CaseTerm {
+declare interface CaseTerm {
     case: {
         constr: Term;
         branches: Term[];
@@ -255,7 +267,7 @@ export interface CaseTerm {
 }
 
 // The UPLC constant is one of several union types.
-export type Constant =
+declare type Constant =
     | IntegerConstant
     | ByteStringConstant
     | StringConstant
@@ -267,34 +279,34 @@ export type Constant =
     | Bls12_381G1ElementConstant
     | Bls12_381G2ElementConstant;
 
-export interface IntegerConstant {
+declare interface IntegerConstant {
     integer: string; // represented as a string
 }
 
-export interface ByteStringConstant {
+declare interface ByteStringConstant {
     bytestring: string; // hex-encoded string
 }
 
-export interface StringConstant {
+declare interface StringConstant {
     string: string;
 }
 
-export interface UnitConstant {
+declare interface UnitConstant {
     unit: "()";
 }
 
-export interface BoolConstant {
+declare interface BoolConstant {
     bool: boolean;
 }
 
-export interface ListConstant {
+declare interface ListConstant {
     list: {
         type: Type;
         items: Constant[];
     };
 }
 
-export interface PairConstant {
+declare interface PairConstant {
     pair: {
         type_left: Type;
         type_right: Type;
@@ -303,11 +315,11 @@ export interface PairConstant {
     };
 }
 
-export interface DataConstant {
+declare interface DataConstant {
     data: PlutusData;
 }
 
-export interface Bls12_381G1ElementConstant {
+declare interface Bls12_381G1ElementConstant {
     bls12_381_G1_element: {
         x: number;
         y: number;
@@ -315,12 +327,12 @@ export interface Bls12_381G1ElementConstant {
     };
 }
 
-export interface Bls12_381G2ElementConstant {
+declare interface Bls12_381G2ElementConstant {
     bls12_381_G2_element: BlstP2;
 }
 
 // The UPLC type is represented either as a string literal or an object.
-export type Type =
+declare type Type =
     | "bool"
     | "integer"
     | "string"
@@ -333,11 +345,11 @@ export type Type =
     | ListType
     | PairType;
 
-export interface ListType {
+declare interface ListType {
     list: Type;
 }
 
-export interface PairType {
+declare interface PairType {
     pair: {
         left: Type;
         right: Type;
@@ -345,21 +357,21 @@ export interface PairType {
 }
 
 // The JSON representation for a blst_p2 element: each coordinate is an array of numbers.
-export interface BlstP2 {
+declare interface BlstP2 {
     x: number[];
     y: number[];
     z: number[];
 }
 
 // Plutus data is also a tagged union.
-export type PlutusData =
+declare type PlutusData =
     | ConstrData
     | MapData
     | BigIntData
     | BoundedBytesData
     | ArrayData;
 
-export interface ConstrData {
+declare interface ConstrData {
     constr: {
         tag: number;
         any_constructor: boolean;
@@ -367,36 +379,36 @@ export interface ConstrData {
     };
 }
 
-export interface MapData {
+declare interface MapData {
     map: Array<{
         key: PlutusData;
         value: PlutusData;
     }>;
 }
 
-export interface BigIntData {
+declare interface BigIntData {
     integer: string; // big integers are represented as strings
 }
 
-export interface BoundedBytesData {
+declare interface BoundedBytesData {
     bytestring: string; // hex-encoded
 }
 
-export interface ArrayData {
+declare interface ArrayData {
     list: PlutusData[];
 }
 
-export interface Asset {
+declare interface Asset {
     unit: string;
     quantity: string;
 }
 
-export interface TxInput {
+declare interface TxInput {
     outputIndex: number;
     txHash: string;
 }
 
-export interface TxOutput {
+declare interface TxOutput {
     address: string;
     amount: Asset[];
     dataHash?: string;
@@ -405,13 +417,572 @@ export interface TxOutput {
     scriptHash?: string;
 }
 
-export interface UTxO {
+declare interface UTxO {
     input: TxInput;
     output: TxOutput;
 }
 
-export interface CostModels {
+declare interface CostModels {
     plutusV1?: number[];
     plutusV2?: number[];
     plutusV3?: number[];
-}
+}
+
+
+///AUTOGENERATED
+
+declare interface GovernanceActionId {
+    index: number;
+    txHash: number[];
+  }
+  
+  declare type GovernanceActionType = "parameterChangeAction" | "hardForkInitiationAction" | "treasuryWithdrawalsAction" | "noConfidenceAction" | "updateCommitteeAction" | "newConstitutionAction" | "infoAction";
+  
+  declare type LocalCredential = {
+    keyHash: number[];
+  } | {
+    scriptHash: number[];
+  };
+  
+  declare interface TxInput {
+    outputIndex: number;
+    txHash: string;
+  }
+  
+  declare interface FeeDecomposition {
+    executionUnitsFee: number;
+    referenceScriptsFee: number;
+    txSizeFee: number;
+  }
+  
+  declare interface MultiAsset {
+    assets: ValidatorAsset[];
+  }
+  
+  declare type Phase1Error = "GenesisKeyDelegationCertificateIsNotSupported" | "MoveInstantaneousRewardsCertificateIsNotSupported" | {
+    BadInputsUTxO: {
+    invalid_input: TxInput;
+  };
+  } | {
+    OutsideValidityIntervalUTxO: {
+    current_slot: number;
+    interval_end: number;
+    interval_start: number;
+  };
+  } | {
+    MaxTxSizeUTxO: {
+    actual_size: number;
+    max_size: number;
+  };
+  } | string | {
+    FeeTooSmallUTxO: {
+    actual_fee: number;
+    fee_decomposition: FeeDecomposition;
+    min_fee: number;
+  };
+  } | {
+    ValueNotConservedUTxO: {
+    difference: Value;
+    input_sum: Value;
+    output_sum: Value;
+  };
+  } | {
+    WrongNetwork: {
+    wrong_addresses: string[];
+  };
+  } | {
+    WrongNetworkWithdrawal: {
+    wrong_addresses: string[];
+  };
+  } | {
+    WrongNetworkInTxBody: {
+    actual_network: number;
+    expected_network: number;
+  };
+  } | {
+    OutputTooSmallUTxO: {
+    min_amount: number;
+    output_amount: number;
+  };
+  } | {
+    CollateralReturnTooSmall: {
+    min_amount: number;
+    output_amount: number;
+  };
+  } | {
+    OutputBootAddrAttrsTooBig: {
+    actual_size: number;
+    max_size: number;
+    output: any;
+  };
+  } | {
+    OutputTooBigUTxO: {
+    max_size: number;
+    oversized_outputs: string[];
+  };
+  } | {
+    InsufficientCollateral: {
+    required_collateral: number;
+    total_collateral: number;
+  };
+  } | {
+    ScriptsNotPaidUTxO: {
+    missing_witness: string[];
+  };
+  } | {
+    ExUnitsTooBigUTxO: {
+    actual_units: number;
+    max_units: number;
+  };
+  } | string | {
+    CollateralInputContainsNonAdaAssets: {
+    collateral_input: string;
+  };
+  } | {
+    CollateralIsLockedByScript: {
+    invalid_collateral: string;
+  };
+  } | {
+    OutsideForecast: {
+    current_slot: number;
+    max_forecast_slot: number;
+  };
+  } | {
+    TooManyCollateralInputs: {
+    actual_count: number;
+    max_count: number;
+  };
+  } | string | {
+    IncorrectTotalCollateralField: {
+    actual_sum: number;
+    declared_total: number;
+  };
+  } | {
+    InvalidSignature: {
+    invalid_signature: string;
+  };
+  } | {
+    ExtraneousSignature: {
+    extraneous_signature: string;
+  };
+  } | {
+    NativeScriptIsUnsuccessful: {
+    native_script_hash: string;
+  };
+  } | {
+    PlutusScriptIsUnsuccessful: {
+    plutus_script_hash: string;
+  };
+  } | {
+    MissingVKeyWitnesses: {
+    missing_key_hash: string;
+  };
+  } | {
+    MissingScriptWitnesses: {
+    missing_script_hash: string;
+  };
+  } | {
+    MissingRedeemer: {
+    index: number;
+    tag: string;
+  };
+  } | string | string | {
+    ConflictingMetadataHash: {
+    actual_hash: string;
+    expected_hash: string;
+  };
+  } | {
+    InvalidMetadata: {
+    message: string;
+  };
+  } | {
+    ExtraneousScriptWitnesses: {
+    extraneous_scripts: string[];
+  };
+  } | {
+    StakeAlreadyRegistered: {
+    reward_address: string;
+  };
+  } | {
+    StakeNotRegistered: {
+    reward_address: string;
+  };
+  } | {
+    StakeNonZeroAccountBalance: {
+    remaining_balance: number;
+    reward_address: string;
+  };
+  } | {
+    RewardAccountNotExisting: {
+    reward_address: string;
+  };
+  } | {
+    WrongRequestedWithdrawalAmount: {
+    expected_amount: number;
+    requested_amount: number;
+    reward_address: string;
+  };
+  } | {
+    StakePoolNotRegistered: {
+    pool_id: string;
+  };
+  } | {
+    WrongRetirementEpoch: {
+    current_epoch: number;
+    max_epoch: number;
+    min_epoch: number;
+    specified_epoch: number;
+  };
+  } | {
+    StakePoolCostTooLow: {
+    min_cost: number;
+    specified_cost: number;
+  };
+  } | {
+    InsufficientFundsForMir: {
+    available_amount: number;
+    requested_amount: number;
+  };
+  } | {
+    InvalidCommitteeVote: {
+    message: string;
+    voter: any;
+  };
+  } | {
+    DRepIncorrectDeposit: {
+    cert_index: number;
+    required_deposit: number;
+    supplied_deposit: number;
+  };
+  } | {
+    DRepDeregistrationWrongRefund: {
+    cert_index: number;
+    required_refund: number;
+    supplied_refund: number;
+  };
+  } | {
+    StakeRegistrationWrongDeposit: {
+    cert_index: number;
+    required_deposit: number;
+    supplied_deposit: number;
+  };
+  } | {
+    StakeDeregistrationWrongRefund: {
+    cert_index: number;
+    required_refund: number;
+    supplied_refund: number;
+  };
+  } | {
+    PoolRegistrationWrongDeposit: {
+    cert_index: number;
+    required_deposit: number;
+    supplied_deposit: number;
+  };
+  } | {
+    CommitteeHasPreviouslyResigned: {
+    committee_credential: LocalCredential;
+  };
+  } | {
+    TreasuryValueMismatch: {
+    actual_value: number;
+    declared_value: number;
+  };
+  } | {
+    RefScriptsSizeTooBig: {
+    actual_size: number;
+    max_size: number;
+  };
+  } | {
+    WdrlNotDelegatedToDRep: {
+    stake_credential: LocalCredential;
+  };
+  } | {
+    CommitteeIsUnknown: {
+    committee_key_hash: LocalCredential;
+  };
+  } | {
+    GovActionsDoNotExist: {
+    invalid_action_ids: GovernanceActionId[];
+  };
+  } | {
+    MalformedProposal: {
+    gov_action: GovernanceActionId;
+  };
+  } | {
+    ProposalProcedureNetworkIdMismatch: {
+    expected_network: number;
+    reward_account: string;
+  };
+  } | {
+    TreasuryWithdrawalsNetworkIdMismatch: {
+    expected_network: number;
+    mismatched_account: string;
+  };
+  } | {
+    VotingProposalIncorrectDeposit: {
+    proposal_index: number;
+    required_deposit: number;
+    supplied_deposit: number;
+  };
+  } | {
+    DisallowedVoters: {
+    disallowed_pairs: any[][];
+  };
+  } | {
+    ConflictingCommitteeUpdate: {
+    conflicting_credentials: LocalCredential;
+  };
+  } | {
+    ExpirationEpochTooSmall: {
+    invalid_expirations: Record<string, any>;
+  };
+  } | {
+    InvalidPrevGovActionId: {
+    proposal: any;
+  };
+  } | {
+    VotingOnExpiredGovAction: {
+    expired_gov_action: GovernanceActionId;
+  };
+  } | {
+    ProposalCantFollow: {
+    expected_versions: ProtocolVersion[];
+    prev_gov_action_id?: GovernanceActionId | null;
+    supplied_version: ProtocolVersion;
+  };
+  } | {
+    InvalidConstitutionPolicyHash: {
+    expected_hash?: any;
+    supplied_hash?: any;
+  };
+  } | {
+    VotersDoNotExist: {
+    missing_voter: any;
+  };
+  } | {
+    ZeroTreasuryWithdrawals: {
+    gov_action: GovernanceActionId;
+  };
+  } | {
+    ProposalReturnAccountDoesNotExist: {
+    return_account: string;
+  };
+  } | {
+    TreasuryWithdrawalReturnAccountsDoNotExist: {
+    missing_account: string;
+  };
+  } | {
+    AuxiliaryDataHashMismatch: {
+    actual_hash?: any;
+    expected_hash: string;
+  };
+  } | string | string;
+  
+  declare type Phase1Warning = "InputsAreNotSorted" | "CollateralIsUnnecessary" | "TotalCollateralIsNotDeclared" | {
+    FeeIsBiggerThanMinFee: {
+    actual_fee: number;
+    fee_decomposition: FeeDecomposition;
+    min_fee: number;
+  };
+  } | {
+    InputUsesRewardAddress: {
+    invalid_input: string;
+  };
+  } | {
+    CollateralInputUsesRewardAddress: {
+    invalid_collateral: string;
+  };
+  } | {
+    CannotCheckStakeDeregistrationRefund: {
+    cert_index: number;
+  };
+  } | {
+    CannotCheckDRepDeregistrationRefund: {
+    cert_index: number;
+  };
+  } | {
+    PoolAlreadyRegistered: {
+    pool_id: string;
+  };
+  } | {
+    DRepAlreadyRegistered: {
+    drep_id: string;
+  };
+  } | {
+    CommitteeAlreadyAuthorized: {
+    committee_key: string;
+  };
+  } | {
+    DRepNotRegistered: {
+    cert_index: number;
+  };
+  } | {
+    DuplicateRegistrationInTx: {
+    cert_index: number;
+    entity_id: string;
+    entity_type: string;
+  };
+  } | {
+    DuplicateCommitteeColdResignationInTx: {
+    cert_index: number;
+    committee_credential: LocalCredential;
+  };
+  } | {
+    DuplicateCommitteeHotRegistrationInTx: {
+    cert_index: number;
+    committee_credential: LocalCredential;
+  };
+  };
+  
+  declare interface ProtocolVersion {
+    major: number;
+    minor: number;
+  }
+  
+  declare interface ValidationError {
+    error: Phase1Error;
+    error_message: string;
+    hint?: any;
+    locations: string[];
+  }
+  
+  declare interface ValidationWarning {
+    hint?: any;
+    locations: string[];
+    warning: Phase1Warning;
+  }
+  
+  declare interface ValidatorAsset {
+    asset_name: string;
+    policy_id: string;
+    quantity: number;
+  }
+  
+  declare interface Value {
+    assets: MultiAsset;
+    coins: number;
+  }
+  
+  declare type Voter = {
+    constitutionalCommitteeHotScriptHash: number[];
+  } | {
+    constitutionalCommitteeHotKeyHash: number[];
+  } | {
+    dRepScriptHash: number[];
+  } | {
+    dRepKeyHash: number[];
+  } | {
+    stakingPoolKeyHash: number[];
+  };
+  
+  declare interface AccountInputContext {
+    balance?: any;
+    bech32Address: string;
+    isRegistered: boolean;
+    payedDeposit?: any;
+  }
+  
+  declare interface Asset {
+    quantity: string;
+    unit: string;
+  }
+  
+  declare interface CommitteeInputContext {
+    activeCommitteeMembers: LocalCredential[];
+    potentialCommitteeMembers: LocalCredential[];
+    resignedCommitteeMembers: LocalCredential[];
+  }
+  
+  declare interface DrepInputContext {
+    bech32Drep: string;
+    isRegistered: boolean;
+    payedDeposit?: any;
+  }
+  
+  declare interface ExUnitPrices {
+    memPrice: SubCoin;
+    stepPrice: SubCoin;
+  }
+  
+  declare interface GovActionInputContext {
+    actionId: GovernanceActionId;
+    actionType: GovernanceActionType;
+    isActive: boolean;
+  }
+  
+  declare type NetworkType = "mainnet" | "testnet";
+  
+  declare interface PoolInputContext {
+    isRegistered: boolean;
+    poolId: string;
+    retirementEpoch?: any;
+  }
+  
+  declare interface ProtocolParameters {
+    adaPerUtxoByte: number;
+    collateralPercentage: number;
+    costModels: CostModels;
+    drepDeposit: number;
+    executionPrices: ExUnitPrices;
+    governanceActionDeposit: number;
+    maxBlockBodySize: number;
+    maxBlockExecutionUnits: ExUnits;
+    maxBlockHeaderSize: number;
+    maxCollateralInputs: number;
+    maxEpochForPoolRetirement: number;
+    maxTransactionSize: number;
+    maxTxExecutionUnits: ExUnits;
+    maxValueSize: number;
+    minFeeCoefficientA: number;
+    minFeeConstantB: number;
+    minPoolCost: number;
+    protocolVersion: any[];
+    referenceScriptCostPerByte: SubCoin;
+    stakeKeyDeposit: number;
+    stakePoolDeposit: number;
+  }
+  
+  declare interface SubCoin {
+    denominator: number;
+    numerator: number;
+  }
+  
+  declare interface UTxO {
+    input: TxInput;
+    output: TxOutput;
+  }
+  
+  declare interface UtxoInputContext {
+    isSpent: boolean;
+    utxo: UTxO;
+  }
+  
+  declare interface NecessaryInputData {
+    accounts: string[];
+    committeeMembers: LocalCredential[];
+    dReps: string[];
+    govActions: GovernanceActionId[];
+    lastEnactedGovAction: GovernanceActionType[];
+    pools: string[];
+    utxos: TxInput[];
+  }
+  
+  declare interface ValidationResult {
+    errors: ValidationError[];
+    warnings: ValidationWarning[];
+  }
+  
+  declare interface ValidationInputContext {
+    accountContexts: AccountInputContext[];
+    committeeContext: CommitteeInputContext;
+    drepContexts: DrepInputContext[];
+    govActionContexts: GovActionInputContext[];
+    lastEnactedGovAction: GovActionInputContext[];
+    networkType: NetworkType;
+    poolContexts: PoolInputContext[];
+    protocolParameters: ProtocolParameters;
+    slot: number;
+    treasuryValue: number;
+    utxoSet: UtxoInputContext[];
+  }
+