@meshsdk/core 1.6.0-alpha.2 → 1.6.0-alpha.4

package/dist/common/constants.d.ts

@@ -0,0 +1,58 @@
+import { csl } from '@mesh/core';
+import type { Costmdls } from '@mesh/core';
+import type { Budget, Era, Network, Protocol } from '../types';
+export declare const DEFAULT_REDEEMER_BUDGET: Budget;
+export declare const DEFAULT_PROTOCOL_PARAMETERS: Protocol;
+export declare const HARDENED_KEY_START = 2147483648;
+export declare const LANGUAGE_VERSIONS: {
+    V1: csl.Language;
+    V2: csl.Language;
+};
+export declare const POLICY_ID_LENGTH = 56;
+export declare const REDEEMER_TAGS: {
+    CERT: csl.RedeemerTag;
+    MINT: csl.RedeemerTag;
+    REWARD: csl.RedeemerTag;
+    SPEND: csl.RedeemerTag;
+};
+export declare const SUPPORTED_CLOCKS: Record<Network, [
+    epoch: string,
+    slot: string,
+    systemStart: string,
+    epochLength: string
+]>;
+export declare const SUPPORTED_COST_MODELS: Record<Era, Costmdls>;
+export declare const SUPPORTED_LANGUAGE_VIEWS: Record<Era, Partial<Record<keyof typeof LANGUAGE_VERSIONS, string>>>;
+export declare const SUPPORTED_HANDLES: Record<number, string>;
+export declare const SUPPORTED_OGMIOS_LINKS: Record<Network, string>;
+export declare const SUPPORTED_TOKENS: {
+    LQ: string;
+    MIN: string;
+    NTX: string;
+    iBTC: string;
+    iETH: string;
+    iUSD: string;
+    MILK: string;
+    AGIX: string;
+    MELD: string;
+    INDY: string;
+    CLAY: string;
+    MCOS: string;
+    DING: string;
+    GERO: string;
+    NMKR: string;
+    PAVIA: string;
+    HOSKY: string;
+    YUMMI: string;
+    C3: string;
+    GIMBAL: string;
+    SUNDAE: string;
+    GREENS: string;
+    GENS: string;
+    SOCIETY: string;
+    DJED: string;
+    SHEN: string;
+    WMT: string;
+    COPI: string;
+};
+export declare const SUPPORTED_WALLETS: string[];

package/dist/common/contracts/evaluator.d.ts

@@ -0,0 +1,4 @@
+import { Action } from '@mesh/types';
+export interface IEvaluator {
+    evaluateTx(tx: string): Promise<Omit<Action, 'data'>[]>;
+}

package/dist/common/contracts/fetcher.d.ts

@@ -0,0 +1,22 @@
+import type { AccountInfo, Asset, AssetMetadata, BlockInfo, Protocol, TransactionInfo, UTxO } from '@mesh/types';
+/**
+ * Fetcher interface defines end points to query blockchain data.
+ */
+export interface IFetcher {
+    fetchAccountInfo(address: string): Promise<AccountInfo>;
+    fetchAddressUTxOs(address: string, asset?: string): Promise<UTxO[]>;
+    fetchAssetAddresses(asset: string): Promise<{
+        address: string;
+        quantity: string;
+    }[]>;
+    fetchAssetMetadata(asset: string): Promise<AssetMetadata>;
+    fetchBlockInfo(hash: string): Promise<BlockInfo>;
+    fetchCollectionAssets(policyId: string, cursor?: number | string): Promise<{
+        assets: Asset[];
+        next: string | number | null;
+    }>;
+    fetchHandleAddress(handle: string): Promise<string>;
+    fetchProtocolParameters(epoch: number): Promise<Protocol>;
+    fetchTxInfo(hash: string): Promise<TransactionInfo>;
+    fetchUTxOs(hash: string): Promise<UTxO[]>;
+}

package/dist/common/contracts/index.d.ts

@@ -0,0 +1,7 @@
+export * from './evaluator';
+export * from './fetcher';
+export * from './initiator';
+export * from './listener';
+export * from './signer';
+export * from './submitter';
+export * from './uploader';

package/dist/common/contracts/initiator.d.ts

@@ -0,0 +1,8 @@
+import type { Address, TransactionUnspentOutput } from '@mesh/core';
+export interface IInitiator {
+    getUsedAddress(): SometimesPromise<Address>;
+    getUsedCollateral(limit?: number): SometimesPromise<TransactionUnspentOutput[]>;
+    getUsedUTxOs(): SometimesPromise<TransactionUnspentOutput[]>;
+}
+declare type SometimesPromise<T> = Promise<T> | T;
+export {};

package/dist/common/contracts/listener.d.ts

@@ -0,0 +1,3 @@
+export interface IListener {
+    onTxConfirmed(txHash: string, callback: () => void, limit?: number): void;
+}

package/dist/common/contracts/signer.d.ts

@@ -0,0 +1,8 @@
+import { DataSignature } from '@mesh/types';
+export interface ISigner {
+    signData(address: string, payload: string): SometimesPromise<DataSignature>;
+    signTx(unsignedTx: string, partialSign: boolean): SometimesPromise<string>;
+    signTxs(unsignedTxs: string[], partialSign: boolean): SometimesPromise<string[]>;
+}
+declare type SometimesPromise<T> = Promise<T> | T;
+export {};

package/dist/common/contracts/submitter.d.ts

@@ -0,0 +1,3 @@
+export interface ISubmitter {
+    submitTx(tx: string): Promise<string>;
+}

package/dist/common/contracts/uploader.d.ts

@@ -0,0 +1,3 @@
+export interface IUploader {
+    uploadContent(content: FormData, recursive: boolean): Promise<string>;
+}

package/dist/common/data/index.d.ts

@@ -0,0 +1,2 @@
+export * from './mesh';
+export * from './plutus';

package/dist/common/data/mesh.d.ts

@@ -0,0 +1,8 @@
+import { Data } from '@mesh/types';
+export declare const mConStr: <T extends Data[]>(alternative: number, fields: T) => Data;
+export declare const mConStr0: <T extends Data[]>(fields: T) => Data;
+export declare const mConStr1: <T extends Data[]>(fields: T) => Data;
+export declare const mConStr2: <T extends Data[]>(fields: T) => Data;
+export declare const mMaybeStakingHash: (stakeCredential: string) => Data;
+export declare const mPubKeyAddress: (bytes: string, stakeCredential?: string) => Data;
+export declare const mScriptAddress: (bytes: string, stakeCredential?: string) => Data;

package/dist/common/data/plutus.d.ts

@@ -0,0 +1,72 @@
+import { Asset } from '@mesh/types';
+export declare type ConStr<N = any, T = any> = {
+    constructor: N;
+    fields: T;
+};
+export declare type ConStr0<T = any> = ConStr<0, T>;
+export declare type ConStr1<T = any> = ConStr<1, T>;
+export declare type ConStr2<T = any> = ConStr<2, T>;
+export declare type Bool = ConStr0<[]> | ConStr1<[]>;
+export declare type BuiltinByteString = {
+    bytes: string;
+};
+export declare type Integer = {
+    int: number;
+};
+export declare type List = {
+    list: PlutusData[];
+};
+export declare type ValidatorHash = BuiltinByteString;
+export declare type PaymentPubKeyHash = BuiltinByteString;
+export declare type PubKeyHash = PaymentPubKeyHash;
+export declare type POSIXTime = Integer;
+export declare type CurrencySymbol = BuiltinByteString;
+export declare type TokenName = BuiltinByteString;
+export declare type MaybeStakingHash = ConStr1<[]> | ConStr0<[ConStr0<[ConStr0<[BuiltinByteString]>]>]>;
+export declare type PubKeyAddress = ConStr0<[ConStr0<[PubKeyHash]>, MaybeStakingHash]>;
+export declare type ScriptAddress = ConStr0<[
+    ConStr1<[ValidatorHash]>,
+    MaybeStakingHash
+]>;
+export declare type AssetClass = ConStr0<[CurrencySymbol, TokenName]>;
+export declare type TxOutRef = ConStr0<[ConStr0<[BuiltinByteString]>, Integer]>;
+export declare type AssocMapItem<K, V> = {
+    k: K;
+    v: V;
+};
+export declare type DictItem<K, V> = {
+    k: K;
+    v: V;
+};
+export declare type AssocMap<K, V> = {
+    map: AssocMapItem<K, V>[];
+};
+export declare type Dict<K, V> = {
+    map: DictItem<K, V>[];
+};
+export declare type Tuple<K, V> = ConStr0<[K, V]>;
+export declare type Value = AssocMap<CurrencySymbol, AssocMap<TokenName, Integer>>;
+export declare type PlutusData = BuiltinByteString | Integer | MaybeStakingHash | PubKeyAddress | ScriptAddress | AssetClass | PaymentPubKeyHash | PubKeyHash | POSIXTime | TxOutRef;
+export declare const conStr: <N, T>(constructor: N, fields: T) => ConStr<N, T>;
+export declare const conStr0: <T>(fields: T) => ConStr0<T>;
+export declare const conStr1: <T>(fields: T) => ConStr1<T>;
+export declare const conStr2: <T>(fields: T) => ConStr2<T>;
+export declare const bool: (b: boolean) => Bool;
+export declare const builtinByteString: (bytes: string) => BuiltinByteString;
+export declare const integer: (int: number) => Integer;
+export declare const list: (pList: PlutusData[]) => List;
+export declare const currencySymbol: (bytes: string) => CurrencySymbol;
+export declare const tokenName: (bytes: string) => TokenName;
+export declare const maybeStakingHash: (stakeCredential: string) => MaybeStakingHash;
+export declare const pubKeyAddress: (bytes: string, stakeCredential?: string) => PubKeyAddress;
+export declare const scriptAddress: (bytes: string, stakeCredential?: string) => ScriptAddress;
+export declare const assetClass: (policyId: string, assetName: string) => AssetClass;
+export declare const txOutRef: (txHash: string, index: number) => TxOutRef;
+export declare const paymentPubKeyHash: (bytes: string) => PaymentPubKeyHash;
+export declare const pubKeyHash: (bytes: string) => PubKeyHash;
+export declare const posixTime: (int: number) => POSIXTime;
+export declare const assocMap: <K, V>(itemsMap: [K, V][]) => AssocMap<K, V>;
+export declare const dict: <K, V>(itemsMap: [K, V][]) => AssocMap<K, V>;
+export declare const tuple: <K, V>(key: K, value: V) => Tuple<K, V>;
+export declare const value: (assets: Asset[]) => Value;
+export declare const parsePlutusValueToAssets: (plutusValue: Value) => Asset[];

package/dist/common/helpers/generateNonce.d.ts

@@ -0,0 +1 @@
+export declare const generateNonce: (label?: string, length?: number) => string;

package/dist/common/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './generateNonce';
+export * from './readPlutusData';

package/dist/common/helpers/readPlutusData.d.ts

@@ -0,0 +1,2 @@
+import type { Data } from '@mesh/types';
+export declare const readPlutusData: (plutusData: string) => Data;

package/dist/common/index.d.ts

@@ -0,0 +1 @@
+export * from './data';

package/dist/common/utils/parser.d.ts

@@ -0,0 +1,5 @@
+export declare const parseAssetUnit: (unit: string) => {
+    policyId: string;
+    assetName: string;
+};
+export declare const parseHttpError: (error: unknown) => string;

package/dist/common/utils/resolver.d.ts

@@ -0,0 +1,17 @@
+import type { Data, Era, LanguageVersion, NativeScript, Network, PlutusScript } from '@mesh/types';
+export declare const resolveDataHash: (data: Data) => string;
+export declare const resolveEpochNo: (network: Network, milliseconds?: number) => number;
+export declare const resolveFingerprint: (policyId: string, assetName: string) => string;
+export declare const resolveLanguageView: (era: Era, version: LanguageVersion) => string | undefined;
+export declare const resolveNativeScriptHash: (script: NativeScript) => string;
+export declare const resolvePaymentKeyHash: (bech32: string) => string;
+export declare const resolvePlutusScriptAddress: (script: PlutusScript, networkId?: number) => string;
+export declare const resolvePlutusScriptHash: (bech32: string) => string;
+export declare const resolvePoolId: (hash: string) => string;
+export declare const resolvePrivateKey: (words: string[]) => string;
+export declare const resolveScriptRef: (script: PlutusScript | NativeScript) => string;
+export declare const resolveSlotNo: (network: Network, milliseconds?: number) => string;
+export declare const resolveRewardAddress: (bech32: string) => string;
+export declare const resolveStakeKeyHash: (bech32: string) => string;
+export declare const resolveTxFees: (txSize: number, minFeeA?: number, minFeeB?: number) => string;
+export declare const resolveTxHash: (txHex: string) => string;

package/dist/core/CIP2.d.ts

@@ -0,0 +1,4 @@
+import type { Protocol, Quantity, Unit, UTxO } from '@mesh/types';
+export declare const keepRelevant: (requestedOutputSet: Map<Unit, Quantity>, initialUTxOSet: UTxO[], minimumLovelaceRequired?: string) => UTxO[];
+export declare const largestFirst: (lovelace: Quantity, initialUTxOSet: UTxO[], includeTxFees?: boolean, { maxTxSize, minFeeA, minFeeB }?: Protocol) => UTxO[];
+export declare const largestFirstMultiAsset: (requestedOutputSet: Map<Unit, Quantity>, initialUTxOSet: UTxO[], includeTxFees?: boolean, parameters?: Protocol) => UTxO[];

package/dist/core/CIP8.d.ts

@@ -0,0 +1,15 @@
+import type { DataSignature } from '@mesh/types';
+import type { Address, PrivateKey } from '@mesh/core';
+export declare const signMessage: (message: Message, signer: Signer) => {
+    coseKey: string;
+    coseSign1: string;
+};
+export declare const checkSignature: (message: string, signer: string, { key, signature }: DataSignature) => boolean;
+export declare type Message = {
+    payload: string;
+    externalAAD?: string;
+};
+export declare type Signer = {
+    address: Address;
+    key: PrivateKey;
+};

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export * from './common/contracts';
+export * from './common/data';
+export { generateNonce, readPlutusData } from './common/helpers';
+export * from './common/utils/resolver';
+export * from './common/utils/parser';
+export * from './core/CIP2';
+export { checkSignature } from './core/CIP8';
+export * from './providers';
+export * from './scripts';
+export * from './transaction';
+export * from './wallet';
+export * from './types';

package/dist/providers/blockfrost.provider.d.ts

@@ -0,0 +1,46 @@
+import { IFetcher, IListener, ISubmitter } from '@mesh/common/contracts';
+import type { AccountInfo, Asset, AssetMetadata, BlockInfo, Protocol, TransactionInfo, UTxO } from '@mesh/types';
+/**
+ * [Blockfrost](https://blockfrost.io/) provides restful APIs which allows your app to access information stored on the blockchain.
+ *
+ * Get started:
+ * ```ts
+ * const blockfrostProvider = new BlockfrostProvider('<BLOCKFROST_API_KEY>');
+ * ```
+ */
+export declare class BlockfrostProvider implements IFetcher, IListener, ISubmitter {
+    private readonly _axiosInstance;
+    /**
+     * If you are using a privately hosted Blockfrost instance, you can set the URL in the parameter.
+     * @param baseUrl The base URL of the instance.
+     */
+    constructor(baseUrl: string);
+    /**
+     * If you are using [Blockfrost](https://blockfrost.io/) hosted instance, you can set the project ID in the parameter.
+     * @param projectId The project ID of the instance.
+     * @param version The version of the API. Default is 0.
+     */
+    constructor(projectId: string, version?: number);
+    fetchAccountInfo(address: string): Promise<AccountInfo>;
+    private resolveScriptRef;
+    private toUTxO;
+    fetchAddressUTxOs(address: string, asset?: string): Promise<UTxO[]>;
+    fetchAssetAddresses(asset: string): Promise<{
+        address: string;
+        quantity: string;
+    }[]>;
+    fetchAssetMetadata(asset: string): Promise<AssetMetadata>;
+    fetchBlockInfo(hash: string): Promise<BlockInfo>;
+    fetchCollectionAssets(policyId: string, cursor?: number): Promise<{
+        assets: Asset[];
+        next: string | number | null;
+    }>;
+    fetchHandleAddress(handle: string): Promise<string>;
+    fetchProtocolParameters(epoch?: number): Promise<Protocol>;
+    fetchTxInfo(hash: string): Promise<TransactionInfo>;
+    fetchUTxOs(hash: string): Promise<UTxO[]>;
+    onTxConfirmed(txHash: string, callback: () => void, limit?: number): void;
+    submitTx(tx: string): Promise<string>;
+    private fetchPlutusScriptCBOR;
+    private fetchNativeScriptJSON;
+}

package/dist/providers/index.d.ts

@@ -0,0 +1,6 @@
+export * from './blockfrost.provider';
+export * from './infura.provider';
+export * from './koios.provider';
+export * from './ogmios.provider';
+export * from './tango.provider';
+export * from './maestro.provider';

package/dist/providers/infura.provider.d.ts

@@ -0,0 +1,12 @@
+import { IUploader } from '@mesh/common/contracts';
+export declare class InfuraProvider implements IUploader {
+    private _axiosInstance;
+    constructor(projectId: string, projectSecret: string, options: Partial<CreateInfuraProviderOptions>);
+    uploadContent(content: FormData, recursive?: boolean): Promise<string>;
+}
+declare type CreateInfuraProviderOptions = {
+    host: string;
+    port: number;
+    version: number;
+};
+export {};

package/dist/providers/koios.provider.d.ts

@@ -0,0 +1,27 @@
+import { IFetcher, IListener, ISubmitter } from '@mesh/common/contracts';
+import type { AccountInfo, Asset, AssetMetadata, BlockInfo, Protocol, TransactionInfo, UTxO } from '@mesh/types';
+export declare class KoiosProvider implements IFetcher, IListener, ISubmitter {
+    private readonly _axiosInstance;
+    constructor(baseUrl: string);
+    constructor(network: 'api' | 'preview' | 'preprod' | 'guild', token: string, version?: number);
+    fetchAccountInfo(address: string): Promise<AccountInfo>;
+    fetchAddressUTxOs(address: string, asset?: string): Promise<UTxO[]>;
+    fetchAssetAddresses(asset: string): Promise<{
+        address: string;
+        quantity: string;
+    }[]>;
+    fetchAssetMetadata(asset: string): Promise<AssetMetadata>;
+    fetchBlockInfo(hash: string): Promise<BlockInfo>;
+    fetchCollectionAssets(policyId: string, cursor?: number): Promise<{
+        assets: Asset[];
+        next: string | number | null;
+    }>;
+    fetchHandleAddress(handle: string): Promise<string>;
+    fetchProtocolParameters(epoch: number): Promise<Protocol>;
+    fetchTxInfo(hash: string): Promise<TransactionInfo>;
+    fetchUTxOs(hash: string): Promise<UTxO[]>;
+    onTxConfirmed(txHash: string, callback: () => void, limit?: number): void;
+    submitTx(tx: string): Promise<string>;
+    private toUTxO;
+    private resolveScriptRef;
+}

package/dist/providers/maestro.provider.d.ts

@@ -0,0 +1,35 @@
+import { IEvaluator, IFetcher, ISubmitter } from '@mesh/common/contracts';
+import type { AccountInfo, Action, Asset, AssetMetadata, BlockInfo, Protocol, TransactionInfo, UTxO } from '@mesh/types';
+export declare type MaestroSupportedNetworks = 'Mainnet' | 'Preprod' | 'Preview';
+export interface MaestroConfig {
+    network: MaestroSupportedNetworks;
+    apiKey: string;
+    turboSubmit?: boolean;
+}
+export declare class MaestroProvider implements IFetcher, ISubmitter, IEvaluator {
+    private readonly _axiosInstance;
+    private readonly _amountsAsStrings;
+    submitUrl: string;
+    constructor({ network, apiKey, turboSubmit }: MaestroConfig);
+    evaluateTx(cbor: string): Promise<Omit<Action, 'data'>[]>;
+    fetchAccountInfo(address: string): Promise<AccountInfo>;
+    fetchAddressUTxOs(address: string, asset?: string): Promise<UTxO[]>;
+    fetchAssetAddresses(asset: string): Promise<{
+        address: string;
+        quantity: string;
+    }[]>;
+    fetchAssetMetadata(asset: string): Promise<AssetMetadata>;
+    fetchBlockInfo(hash: string): Promise<BlockInfo>;
+    fetchCollectionAssets(policyId: string, cursor?: string): Promise<{
+        assets: Asset[];
+        next: string | number | null;
+    }>;
+    fetchHandleAddress(handle: string): Promise<string>;
+    fetchProtocolParameters(epoch?: number): Promise<Protocol>;
+    fetchTxInfo(hash: string): Promise<TransactionInfo>;
+    fetchUTxOs(hash: string): Promise<UTxO[]>;
+    onTxConfirmed(txHash: string, callback: () => void, limit?: number): void;
+    submitTx(tx: string): Promise<string>;
+    private toUTxO;
+    private resolveScript;
+}

package/dist/providers/ogmios.provider.d.ts

@@ -0,0 +1,12 @@
+import { IEvaluator, ISubmitter } from '@mesh/common/contracts';
+import { Action, Network } from '@mesh/types';
+export declare class OgmiosProvider implements IEvaluator, ISubmitter {
+    private readonly _baseUrl;
+    constructor(baseUrl: string);
+    constructor(network: Network);
+    evaluateTx(tx: string): Promise<Omit<Action, 'data'>[]>;
+    onNextTx(callback: (tx: unknown) => void): Promise<() => void>;
+    submitTx(tx: string): Promise<string>;
+    private open;
+    private send;
+}

package/dist/providers/tango.provider.d.ts

@@ -0,0 +1,25 @@
+import { IEvaluator, IFetcher, IListener, ISubmitter } from '@mesh/common/contracts';
+import type { AccountInfo, Action, Asset, AssetMetadata, BlockInfo, Protocol, TransactionInfo, UTxO } from '@mesh/types';
+export declare class TangoProvider implements IEvaluator, IFetcher, IListener, ISubmitter {
+    private readonly _axiosInstance;
+    constructor(network: 'mainnet' | 'testnet', appId: string, appKey: string, version?: number);
+    evaluateTx(tx: string): Promise<Omit<Action, 'data'>[]>;
+    fetchAccountInfo(address: string): Promise<AccountInfo>;
+    fetchAddressUTxOs(address: string, asset?: string): Promise<UTxO[]>;
+    fetchAssetAddresses(asset: string): Promise<{
+        address: string;
+        quantity: string;
+    }[]>;
+    fetchAssetMetadata(asset: string): Promise<AssetMetadata>;
+    fetchBlockInfo(hash: string): Promise<BlockInfo>;
+    fetchCollectionAssets(policyId: string, cursor?: string): Promise<{
+        assets: Asset[];
+        next: string | number | null;
+    }>;
+    fetchHandleAddress(handle: string): Promise<string>;
+    fetchProtocolParameters(epoch: number): Promise<Protocol>;
+    fetchTxInfo(hash: string): Promise<TransactionInfo>;
+    fetchUTxOs(hash: string): Promise<UTxO[]>;
+    onTxConfirmed(txHash: string, callback: () => void, limit?: number): void;
+    submitTx(tx: string): Promise<string>;
+}

package/dist/scripts/forge.script.d.ts

@@ -0,0 +1,8 @@
+import type { NativeScript } from '@mesh/types';
+export declare class ForgeScript {
+    static withOneSignature(address: string): string;
+    static withAtLeastNSignatures(addresses: string[], minimumRequired: number): string;
+    static withAnySignature(addresses: string[]): string;
+    static withAllSignatures(addresses: string[]): string;
+    static fromNativeScript(script: NativeScript): string;
+}

package/dist/scripts/index.d.ts

@@ -0,0 +1 @@
+export * from './forge.script';

package/dist/transaction/index.d.ts

@@ -0,0 +1,2 @@
+export * from './transaction.service';
+export * from './meshTxBuilder';

package/dist/transaction/meshTxBuilder/index.d.ts

@@ -0,0 +1,2 @@
+export * from './meshTxBuilder.service';
+export * from './type';

package/dist/transaction/meshTxBuilder/meshTxBuilder.service.d.ts

@@ -0,0 +1,47 @@
+import { IEvaluator, IFetcher, ISubmitter } from '@mesh/common/contracts';
+import { MeshTxBuilderCore } from './meshTxBuilderCore';
+import { MeshTxBuilderBody } from './type';
+declare type MeshTxBuilderOptions = {
+    fetcher?: IFetcher;
+    submitter?: ISubmitter;
+    evaluator?: IEvaluator;
+    isHydra?: boolean;
+};
+/**
+ * MeshTxBuilder is a lower level api for building transaction
+ * @param {IFetcher} [fetcher] an optional parameter for fetching utxo
+ * @param {ISubmitter} [submitter] an optional parameter for submitting transaction
+ * @param {IEvaluator} [evaluator] an optional parameter for evaluating transaction
+ * @param {boolean} [isHydra] an optional parameter for using hydra transaction building for configuring 0 fee in protocol parameters
+ */
+export declare class MeshTxBuilder extends MeshTxBuilderCore {
+    private _fetcher?;
+    private _submitter?;
+    private _evaluator?;
+    private queriedTxHashes;
+    private queriedUTxOs;
+    constructor({ fetcher, submitter, evaluator, isHydra, }: MeshTxBuilderOptions);
+    /**
+     * It builds the transaction and query the blockchain for missing information
+     * @param customizedTx The optional customized transaction body
+     * @returns The signed transaction in hex ready to submit / signed by client
+     */
+    complete: (customizedTx?: MeshTxBuilderBody) => Promise<this>;
+    /**
+     * Submit transactions to the blockchain using the fetcher instance
+     * @param txHex The signed transaction in hex
+     * @returns
+     */
+    submitTx: (txHex: string) => Promise<string | undefined>;
+    /**
+     * Get the UTxO information from the blockchain
+     * @param TxHash The TxIn object that contains the txHash and txIndex, while missing amount and address information
+     */
+    private getUTxOInfo;
+    private queryAllTxInfo;
+    private completeTxInformation;
+    private isInputComplete;
+    private isInputInfoComplete;
+    private isRefScriptInfoComplete;
+}
+export {};