@meshsdk/core 1.5.8 → 1.5.10

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

@@ -5,6 +5,8 @@ export declare class BlockfrostProvider implements IFetcher, IListener, ISubmitt
     constructor(baseUrl: string);
     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;
@@ -19,6 +21,7 @@ export declare class BlockfrostProvider implements IFetcher, IListener, ISubmitt
     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;

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

@@ -3,7 +3,7 @@ import type { AccountInfo, Asset, AssetMetadata, BlockInfo, Protocol, Transactio
 export declare class KoiosProvider implements IFetcher, IListener, ISubmitter {
     private readonly _axiosInstance;
     constructor(baseUrl: string);
-    constructor(network: 'api' | 'preview' | 'preprod' | 'guild', version?: number);
+    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<{
@@ -19,6 +19,9 @@ export declare class KoiosProvider implements IFetcher, IListener, ISubmitter {
     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

@@ -1,15 +1,17 @@
-import { IFetcher, ISubmitter } from '@mesh/common/contracts';
-import type { AccountInfo, Asset, AssetMetadata, BlockInfo, Protocol, TransactionInfo, UTxO } from '@mesh/common/types';
+import { IEvaluator, IFetcher, ISubmitter } from '@mesh/common/contracts';
+import type { AccountInfo, Action, Asset, AssetMetadata, BlockInfo, Protocol, TransactionInfo, UTxO } from '@mesh/common/types';
 export declare type MaestroSupportedNetworks = 'Mainnet' | 'Preprod' | 'Preview';
 export interface MaestroConfig {
     network: MaestroSupportedNetworks;
     apiKey: string;
     turboSubmit?: boolean;
 }
-export declare class MaestroProvider implements IFetcher, ISubmitter {
+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<{
@@ -25,6 +27,9 @@ export declare class MaestroProvider implements IFetcher, ISubmitter {
     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/tango.provider.d.ts

@@ -19,6 +19,7 @@ export declare class TangoProvider implements IEvaluator, IFetcher, IListener, I
     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/transaction/index.d.ts

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

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

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

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

@@ -0,0 +1,44 @@
+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;
+}
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,239 @@
+import { Action, Asset, Budget, Data, Protocol } from '@mesh/common/types';
+import { csl } from '@mesh/core';
+import { MintItem, TxIn, PubKeyTxIn, MeshTxBuilderBody, RefTxIn } from './type';
+export declare class MeshTxBuilderCore {
+    txHex: string;
+    txBuilder: csl.TransactionBuilder;
+    private _protocolParams;
+    private txOutput?;
+    private addingScriptInput;
+    private addingPlutusMint;
+    protected isHydra: boolean;
+    meshTxBuilderBody: MeshTxBuilderBody;
+    protected mintItem?: MintItem;
+    protected txInQueueItem?: TxIn;
+    protected collateralQueueItem?: PubKeyTxIn;
+    protected refScriptTxInQueueItem?: RefTxIn;
+    /**
+     * Synchronous functions here
+     */
+    /**
+     * It builds the transaction without dependencies
+     * @param customizedTx The optional customized transaction body
+     * @returns The signed transaction in hex ready to submit / signed by client
+     */
+    completeSync: (customizedTx?: MeshTxBuilderBody) => this;
+    /**
+     * Complete the signing process
+     * @returns The signed transaction in hex
+     */
+    completeSigning: () => string;
+    serializeTxBody: (txBody: MeshTxBuilderBody) => this;
+    /**
+     * Set the input for transaction
+     * @param txHash The transaction hash of the input UTxO
+     * @param txIndex The transaction index of the input UTxO
+     * @param amount The asset amount of index of the input UTxO
+     * @param address The address of the input UTxO
+     * @returns The MeshTxBuilder instance
+     */
+    txIn: (txHash: string, txIndex: number, amount?: Asset[], address?: string) => this;
+    /**
+     * Set the script for transaction input
+     * @param {string} scriptCbor The CborHex of the script
+     * @returns The MeshTxBuilder instance
+     */
+    txInScript: (scriptCbor: string) => void;
+    /**
+     * Set the input datum for transaction input
+     * @param {Data} datum The datum in object format
+     * @returns The MeshTxBuilder instance
+     */
+    txInDatumValue: (datum: Data) => this;
+    /**
+     * Tell the transaction builder that the input UTxO has inlined datum
+     * @returns The MeshTxBuilder instance
+     */
+    txInInlineDatumPresent: () => this;
+    /**
+     * Set the redeemer for the reference input to be spent in same transaction
+     * @param redeemer The redeemer in object format
+     * @param exUnits The execution units budget for the redeemer
+     * @returns The MeshTxBuilder instance
+     */
+    txInRedeemerValue: (redeemer: Data, exUnits?: Budget) => this;
+    /**
+     * Set the output for transaction
+     * @param {string} address The recipient of the output
+     * @param {Asset[]} amount The amount of other native assets attached with UTxO
+     * @returns The MeshTxBuilder instance
+     */
+    txOut: (address: string, amount: Asset[]) => this;
+    /**
+     * Set the output datum hash for transaction
+     * @param {Data} datum The datum in object format
+     * @returns The MeshTxBuilder instance
+     */
+    txOutDatumHashValue: (datum: Data) => this;
+    /**
+     * Set the output inline datum for transaction
+     * @param {Data} datum The datum in object format
+     * @returns The MeshTxBuilder instance
+     */
+    txOutInlineDatumValue: (datum: Data) => this;
+    /**
+     * Set the reference script to be attached with the output
+     * @param scriptCbor The CBOR hex of the script to be attached to UTxO as reference script
+     * @returns The MeshTxBuilder instance
+     */
+    txOutReferenceScript: (scriptCbor: string) => this;
+    /**
+     * Set the instruction that it is currently using V2 Plutus spending scripts
+     * @returns The MeshTxBuilder instance
+     */
+    spendingPlutusScriptV2: () => this;
+    /**
+     * Set the reference input where it would also be spent in the transaction
+     * @param txHash The transaction hash of the reference UTxO
+     * @param txIndex The transaction index of the reference UTxO
+     * @param spendingScriptHash The script hash of the spending script
+     * @returns The MeshTxBuilder instance
+     */
+    spendingTxInReference: (txHash: string, txIndex: number, spendingScriptHash?: string) => this;
+    /**
+     * [Alias of txInInlineDatumPresent] Set the instruction that the reference input has inline datum
+     * @returns The MeshTxBuilder instance
+     */
+    spendingReferenceTxInInlineDatumPresent: () => this;
+    /**
+     * [Alias of txInRedeemerValue] Set the redeemer for the reference input to be spent in same transaction
+     * @param redeemer The redeemer in object format
+     * @param exUnits The execution units budget for the redeemer
+     * @returns The MeshTxBuilder instance
+     */
+    spendingReferenceTxInRedeemerValue: (redeemer: Data, exUnits?: Budget) => this;
+    /**
+     * Specify a read only reference input. This reference input is not witnessing anything it is simply provided in the plutus script context.
+     * @param txHash The transaction hash of the reference UTxO
+     * @param txIndex The transaction index of the reference UTxO
+     * @returns The MeshTxBuilder instance
+     */
+    readOnlyTxInReference: (txHash: string, txIndex: number) => this;
+    /**
+     * Set the instruction that it is currently using V2 Plutus minting scripts
+     * @returns The MeshTxBuilder instance
+     */
+    mintPlutusScriptV2: () => this;
+    /**
+     * Set the minting value of transaction
+     * @param quantity The quantity of asset to be minted
+     * @param policy The policy id of the asset to be minted
+     * @param name The hex of token name of the asset to be minted
+     * @returns The MeshTxBuilder instance
+     */
+    mint: (quantity: number, policy: string, name: string) => this;
+    /**
+     * Set the minting script of current mint
+     * @param scriptCBOR The CBOR hex of the minting policy script
+     * @returns The MeshTxBuilder instance
+     */
+    mintingScript: (scriptCBOR: string) => this;
+    /**
+     * Use reference script for minting
+     * @param txHash The transaction hash of the UTxO
+     * @param txIndex The transaction index of the UTxO
+     * @returns The MeshTxBuilder instance
+     */
+    mintTxInReference: (txHash: string, txIndex: number) => this;
+    /**
+     * Set the redeemer for minting
+     * @param redeemer The redeemer in object format
+     * @param exUnits The execution units budget for the redeemer
+     * @returns The MeshTxBuilder instance
+     */
+    mintReferenceTxInRedeemerValue: (redeemer: Data, exUnits?: Budget) => this;
+    /**
+     * Set the redeemer for the reference input to be spent in same transaction
+     * @param redeemer The redeemer in object format
+     * @param exUnits The execution units budget for the redeemer
+     * @returns The MeshTxBuilder instance
+     */
+    mintRedeemerValue: (redeemer: Data, exUnits?: Budget) => this;
+    /**
+     * Set the required signer of the transaction
+     * @param pubKeyHash The PubKeyHash of the required signer
+     * @returns The MeshTxBuilder instance
+     */
+    requiredSignerHash: (pubKeyHash: string) => this;
+    /**
+     * Set the collateral UTxO for the transaction
+     * @param txHash The transaction hash of the collateral UTxO
+     * @param txIndex The transaction index of the collateral UTxO
+     * @param amount The asset amount of index of the collateral UTxO
+     * @param address The address of the collateral UTxO
+     * @returns The MeshTxBuilder instance
+     */
+    txInCollateral: (txHash: string, txIndex: number, amount?: Asset[], address?: string) => this;
+    /**
+     * Configure the address to accept change UTxO
+     * @param addr The address to accept change UTxO
+     * @returns The MeshTxBuilder instance
+     */
+    changeAddress: (addr: string) => this;
+    /**
+     * Set the transaction valid interval to be valid only after the slot
+     * @param slot The transaction is valid only after this slot
+     * @returns The MeshTxBuilder instance
+     */
+    invalidBefore: (slot: number) => this;
+    /**
+     * Set the transaction valid interval to be valid only before the slot
+     * @param slot The transaction is valid only before this slot
+     * @returns The MeshTxBuilder instance
+     */
+    invalidHereafter: (slot: number) => this;
+    /**
+     * Add metadata to the transaction
+     * @param tag The tag of the metadata
+     * @param metadata The metadata in object format
+     * @returns The MeshTxBuilder instance
+     */
+    metadataValue: <T extends object>(tag: string, metadata: T) => this;
+    /**
+     * Set the protocol parameters to be used for the transaction other than the default one
+     * @param params (Part of) the protocol parameters to be used for the transaction
+     * @returns The MeshTxBuilder instance
+     */
+    protocolParams: (params: Partial<Protocol>) => this;
+    /**
+     * Sign the transaction with the private key
+     * @param skeyHex The private key in cborHex (with or without 5820 prefix, i.e. the format when generated from cardano-cli)
+     * @returns
+     */
+    signingKey: (skeyHex: string) => this;
+    private addAllSigningKeys;
+    private buildTx;
+    private queueInput;
+    private queueMint;
+    private makePlutusScriptSource;
+    private addAllInputs;
+    private addTxIn;
+    private addScriptTxIn;
+    private addAllOutputs;
+    private addOutput;
+    private addAllCollaterals;
+    private addCollateral;
+    private addCollateralReturn;
+    private addAllReferenceInputs;
+    private addReferenceInput;
+    protected addAllMints: (mints: MintItem[]) => void;
+    private addPlutusMint;
+    private addNativeMint;
+    protected queueAllLastItem: () => void;
+    protected addCostModels: () => void;
+    private addChange;
+    private addValidityRange;
+    private addAllRequiredSignatures;
+    private addAllMetadata;
+    protected updateRedeemer: (meshTxBuilderBody: MeshTxBuilderBody, txEvaluation: Omit<Action, 'data'>[]) => void;
+}

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

@@ -0,0 +1,95 @@
+import { Asset, Budget, Data } from '@mesh/common/types';
+export declare type MeshTxBuilderBody = {
+    inputs: TxIn[];
+    outputs: Output[];
+    collaterals: PubKeyTxIn[];
+    requiredSignatures: string[];
+    referenceInputs: RefTxIn[];
+    mints: MintItem[];
+    changeAddress: string;
+    metadata: Metadata[];
+    validityRange: ValidityRange;
+    signingKey: string[];
+};
+export declare type Output = {
+    address: string;
+    amount: Asset[];
+    datum?: {
+        type: 'Hash' | 'Inline';
+        data: Data;
+    };
+    referenceScript?: string;
+};
+export declare type ValidityRange = {
+    invalidBefore?: number;
+    invalidHereafter?: number;
+};
+export declare type RequiredWith<T, K extends keyof T> = Required<T> & {
+    [P in K]: Required<T[P]>;
+};
+export declare type RefTxIn = {
+    txHash: string;
+    txIndex: number;
+};
+export declare type TxIn = PubKeyTxIn | ScriptTxIn;
+export declare type PubKeyTxIn = {
+    type: 'PubKey';
+    txIn: TxInParameter;
+};
+export declare type ScriptTxIn = {
+    type: 'Script';
+    txIn: TxInParameter;
+    scriptTxIn: ScriptTxInParameter;
+};
+export declare type TxInParameter = {
+    txHash: string;
+    txIndex: number;
+    amount?: Asset[];
+    address?: string;
+};
+export declare type ScriptTxInParameter = {
+    scriptSource?: {
+        type: 'Provided';
+        scriptCbor: string;
+    } | {
+        type: 'Inline';
+        txInInfo: ScriptSourceInfo;
+    };
+    datumSource?: {
+        type: 'Provided';
+        data: Data;
+    } | {
+        type: 'Inline';
+        txHash: string;
+        txIndex: number;
+    };
+    redeemer?: Redeemer;
+};
+export declare type ScriptSourceInfo = {
+    txHash: string;
+    txIndex: number;
+    spendingScriptHash?: string;
+};
+export declare type MintItem = {
+    type: 'Plutus' | 'Native';
+    policyId: string;
+    assetName: string;
+    amount: number;
+    redeemer?: Redeemer;
+    scriptSource?: {
+        type: 'Provided';
+        cbor: string;
+    } | {
+        type: 'Reference Script';
+        txHash: string;
+        txIndex: number;
+    };
+};
+export declare type Redeemer = {
+    data: Data;
+    exUnits: Budget;
+};
+export declare type Metadata = {
+    tag: string;
+    metadata: object;
+};

package/package.json

@@ -3,7 +3,7 @@
   "description": "Rapidly build Web3 apps on the Cardano Blockchain.",
   "homepage": "https://meshjs.dev",
   "author": "MeshJS",
-  "version": "1.5.8",
+  "version": "1.5.10",
   "license": "Apache-2.0",
   "type": "module",
   "repository": {
@@ -67,8 +67,8 @@
   "dependencies": {
     "@emurgo/cardano-message-signing-browser": "1.0.1",
     "@emurgo/cardano-message-signing-nodejs": "1.0.1",
-    "@emurgo/cardano-serialization-lib-browser": "11.3.0",
-    "@emurgo/cardano-serialization-lib-nodejs": "11.3.0",
+    "@emurgo/cardano-serialization-lib-browser": "11.5.0",
+    "@emurgo/cardano-serialization-lib-nodejs": "11.5.0",
     "@emurgo/cip14-js": "3.0.1",
     "axios": "0.27.2",
     "bip39": "3.0.4",