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

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

@@ -0,0 +1,320 @@
+import { Action, Asset, LanguageVersion, Protocol, UTxO, PoolParams } from '@mesh/types';
+import { csl } from '@mesh/core';
+import { MintItem, TxIn, PubKeyTxIn, MeshTxBuilderBody, RefTxIn, BuilderData, Certificate } from './type';
+export declare class MeshTxBuilderCore {
+    txHex: string;
+    txBuilder: csl.TransactionBuilder;
+    txEvaluationMultiplier: number;
+    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;
+    /**
+     * Reset everything in the MeshTxBuilder instance
+     * @returns The MeshTxBuilder instance
+     */
+    reset: () => this;
+    /**
+     * Make an empty transaction body for building transaction in object
+     * @returns An empty transaction body
+     */
+    emptyTxBuilderBody: () => MeshTxBuilderBody;
+    constructor();
+    /**
+     * 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;
+    private serializeTxBody;
+    /**
+     * 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
+     * @param version Optional - The Plutus script version
+     * @returns The MeshTxBuilder instance
+     */
+    txInScript: (scriptCbor: string, version?: LanguageVersion) => this;
+    /**
+     * Set the input datum for transaction input
+     * @param datum The datum in Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @param type The datum type, either Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @returns The MeshTxBuilder instance
+     */
+    txInDatumValue: (datum: BuilderData['content'], type?: BuilderData['type']) => 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 Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @param exUnits The execution units budget for the redeemer
+     * @param type The redeemer data type, either Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @returns The MeshTxBuilder instance
+     */
+    txInRedeemerValue: (redeemer: BuilderData['content'], exUnits?: {
+        mem: number;
+        steps: number;
+    }, type?: BuilderData['type']) => 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 datum The datum in Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @param type The datum type, either Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @returns The MeshTxBuilder instance
+     */
+    txOutDatumHashValue: (datum: BuilderData['content'], type?: BuilderData['type']) => this;
+    /**
+     * Set the output inline datum for transaction
+     * @param datum The datum in Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @param type The datum type, either Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @returns The MeshTxBuilder instance
+     */
+    txOutInlineDatumValue: (datum: BuilderData['content'], type?: BuilderData['type']) => 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
+     * @param version Optional - The Plutus script version
+     * @returns The MeshTxBuilder instance
+     */
+    txOutReferenceScript: (scriptCbor: string, version?: LanguageVersion) => 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, version?: LanguageVersion) => 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 Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @param exUnits The execution units budget for the redeemer
+     * @param type The redeemer data type, either Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @returns The MeshTxBuilder instance
+     */
+    spendingReferenceTxInRedeemerValue: (redeemer: BuilderData['content'], exUnits?: {
+        mem: number;
+        steps: number;
+    }, type?: BuilderData['type']) => 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: string, policy: string, name: string) => this;
+    /**
+     * Set the minting script of current mint
+     * @param scriptCBOR The CBOR hex of the minting policy script
+     * @param version Optional - The Plutus script version
+     * @returns The MeshTxBuilder instance
+     */
+    mintingScript: (scriptCBOR: string, version?: LanguageVersion) => 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, version?: LanguageVersion) => this;
+    /**
+     * Set the redeemer for minting
+     * @param redeemer The redeemer in Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @param exUnits The execution units budget for the redeemer
+     * @param type The redeemer data type, either Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @returns The MeshTxBuilder instance
+     */
+    mintReferenceTxInRedeemerValue: (redeemer: BuilderData['content'], exUnits?: {
+        mem: number;
+        steps: number;
+    }, type?: BuilderData['type']) => this;
+    /**
+     * Set the redeemer for the reference input to be spent in same transaction
+     * @param redeemer The redeemer in Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @param exUnits The execution units budget for the redeemer
+     * @param type The redeemer data type, either Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @returns The MeshTxBuilder instance
+     */
+    mintRedeemerValue: (redeemer: BuilderData['content'], exUnits?: {
+        mem: number;
+        steps: number;
+    }, type?: BuilderData['type']) => 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;
+    /**
+     * Creates a pool registration certificate, and adds it to the transaction
+     * @param poolParams Parameters for pool registration
+     * @returns The MeshTxBuilder instance
+     */
+    registerPoolCertificate: (poolParams: PoolParams) => this;
+    /**
+     * Creates a stake registration certificate, and adds it to the transaction
+     * @param stakeKeyHash The keyHash of the stake key
+     * @returns The MeshTxBuilder instance
+     */
+    registerStakeCertificate: (stakeKeyHash: string) => this;
+    /**
+     * Creates a stake delegation certificate, and adds it to the transaction
+     * This will delegate stake from the corresponding stake address to the pool
+     * @param stakeKeyHash The keyHash of the stake key
+     * @param poolId poolId can be in either bech32 or hex form
+     * @returns The MeshTxBuilder instance
+     */
+    delegateStakeCertificate: (stakeKeyHash: string, poolId: string) => this;
+    /**
+     * Creates a stake deregister certificate, and adds it to the transaction
+     * @param stakeKeyHash The keyHash of the stake key
+     * @returns The MeshTxBuilder instance
+     */
+    deregisterStakeCertificate: (stakeKeyHash: string) => this;
+    /**
+     * Creates a pool retire certificate, and adds it to the transaction
+     * @param poolId poolId can be in either bech32 or hex form
+     * @param epoch The intended epoch to retire the pool
+     * @returns The MeshTxBuilder instance
+     */
+    retirePoolCertificate: (poolId: string, epoch: number) => 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;
+    /**
+     * EXPERIMENTAL - Selects utxos to fill output value and puts them into inputs
+     * @param extraInputs The inputs already placed into the object will remain, these extra inputs will be used to fill the remaining  value needed
+     * @param threshold Extra value needed to be selected for, usually for paying fees and min UTxO value of change output
+     */
+    selectUtxosFrom: (extraInputs: UTxO[], threshold?: number) => this;
+    private addUtxosFrom;
+    private addAllSigningKeys;
+    private buildTx;
+    private queueInput;
+    private queueMint;
+    private makePlutusScriptSource;
+    protected removeDuplicateInputs: () => void;
+    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;
+    private decimalToFraction;
+    private toPoolParams;
+    private addCertificate;
+    protected queueAllLastItem: () => void;
+    protected addAllCertificates: (allCertificates: Certificate[]) => void;
+    protected addCostModels: () => void;
+    private addChange;
+    private addValidityRange;
+    private addAllRequiredSignatures;
+    private addAllMetadata;
+    protected updateRedeemer: (meshTxBuilderBody: MeshTxBuilderBody, txEvaluation: Omit<Action, 'data'>[]) => void;
+    protected castRawDataToJsonString: (rawData: object | string) => any;
+    protected castDataToPlutusData: ({ type, content }: BuilderData) => csl.PlutusData;
+}

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

@@ -0,0 +1,128 @@
+import { Asset, Budget, Data, LanguageVersion, PlutusScript, UTxO, PoolParams } from '@mesh/types';
+export declare type MeshTxBuilderBody = {
+    inputs: TxIn[];
+    outputs: Output[];
+    extraInputs: UTxO[];
+    selectionThreshold: number;
+    collaterals: PubKeyTxIn[];
+    requiredSignatures: string[];
+    referenceInputs: RefTxIn[];
+    mints: MintItem[];
+    changeAddress: string;
+    metadata: Metadata[];
+    validityRange: ValidityRange;
+    certificates: Certificate[];
+    signingKey: string[];
+};
+export declare type TxIn = PubKeyTxIn | ScriptTxIn;
+export declare type PubKeyTxIn = {
+    type: 'PubKey';
+    txIn: TxInParameter;
+};
+export declare type TxInParameter = {
+    txHash: string;
+    txIndex: number;
+    amount?: Asset[];
+    address?: string;
+};
+export declare type ScriptTxIn = {
+    type: 'Script';
+    txIn: TxInParameter;
+    scriptTxIn: ScriptTxInParameter;
+};
+export declare type ScriptTxInParameter = {
+    scriptSource?: {
+        type: 'Provided';
+        script: PlutusScript;
+    } | {
+        type: 'Inline';
+        txInInfo: ScriptSourceInfo;
+    };
+    datumSource?: {
+        type: 'Provided';
+        data: BuilderData;
+    } | {
+        type: 'Inline';
+        txHash: string;
+        txIndex: number;
+    };
+    redeemer?: Redeemer;
+};
+export declare type ScriptSourceInfo = {
+    txHash: string;
+    txIndex: number;
+    spendingScriptHash?: string;
+    version: LanguageVersion;
+};
+export declare type RefTxIn = {
+    txHash: string;
+    txIndex: number;
+};
+export declare type Output = {
+    address: string;
+    amount: Asset[];
+    datum?: {
+        type: 'Hash' | 'Inline';
+        data: BuilderData;
+    };
+    referenceScript?: PlutusScript;
+};
+export declare type MintItem = {
+    type: 'Plutus' | 'Native';
+    policyId: string;
+    assetName: string;
+    amount: string;
+    redeemer?: Redeemer;
+    scriptSource?: {
+        type: 'Provided';
+        script: PlutusScript;
+    } | {
+        type: 'Reference Script';
+        txHash: string;
+        txIndex: number;
+        version: LanguageVersion;
+    };
+};
+export declare type ValidityRange = {
+    invalidBefore?: number;
+    invalidHereafter?: number;
+};
+export declare type BuilderData = {
+    type: 'Mesh';
+    content: Data;
+} | {
+    type: 'JSON';
+    content: string;
+} | {
+    type: 'CBOR';
+    content: string;
+};
+export declare type Redeemer = {
+    data: BuilderData;
+    exUnits: Budget;
+};
+export declare type Metadata = {
+    tag: string;
+    metadata: object;
+};
+export declare type Certificate = {
+    type: 'RegisterPool';
+    poolParams: PoolParams;
+} | {
+    type: 'RegisterStake';
+    stakeKeyHash: string;
+} | {
+    type: 'DelegateStake';
+    stakeKeyHash: string;
+    poolId: string;
+} | {
+    type: 'DeregisterStake';
+    stakeKeyHash: string;
+} | {
+    type: 'RetirePool';
+    poolId: string;
+    epoch: number;
+};
+export declare type RequiredWith<T, K extends keyof T> = Required<T> & {
+    [P in K]: Required<T[P]>;
+};

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

@@ -0,0 +1,150 @@
+import { IInitiator } from '@mesh/common/contracts';
+import type { Action, Asset, Data, Era, Mint, Protocol, PlutusScript, PoolParams, Recipient, Token, UTxO } from '@mesh/types';
+export declare class Transaction {
+    private _changeAddress?;
+    private _txOutputs;
+    private _recipients;
+    private _totalBurns;
+    private _totalMints;
+    private readonly _era?;
+    private readonly _initiator?;
+    private readonly _mintBuilder;
+    private readonly _protocolParameters;
+    private readonly _txBuilder;
+    private readonly _txCertificates;
+    private readonly _txInputsBuilder;
+    private readonly _txWithdrawals;
+    constructor(options?: Partial<CreateTxOptions>);
+    static attachMetadata(cborTx: string, cborTxMetadata: string, era?: Era): string;
+    static deattachMetadata(cborTx: string): string;
+    static maskMetadata(cborTx: string, era?: Era): string;
+    static readMetadata(cborTx: string): string;
+    static writeMetadata(cborTx: string, cborTxMetadata: string, era?: Era): string;
+    get size(): number;
+    build(): Promise<string>;
+    burnAsset(forgeScript: string | PlutusScript | UTxO, asset: Asset, redeemer?: Partial<Action>): Transaction;
+    delegateStake(rewardAddress: string, poolId: string): Transaction;
+    deregisterStake(rewardAddress: string): Transaction;
+    mintAsset(forgeScript: string | PlutusScript | UTxO, mint: Mint, redeemer?: Partial<Action>): Transaction;
+    redeemValue(options: {
+        value: UTxO;
+        script: PlutusScript | UTxO;
+        datum?: Data | UTxO;
+        redeemer?: Action;
+    }): Transaction;
+    registerStake(rewardAddress: string): Transaction;
+    registerPool(params: PoolParams): Transaction;
+    retirePool(poolId: string, epochNo: number): Transaction;
+    /**
+     * Adds an output to the transaction.
+     *
+     * @param recipient The recipient of the output.
+     * @param assets The assets to send.
+     * @returns The transaction builder.
+     * @see {@link https://meshjs.dev/apis/transaction#sendAssets}
+     */
+    sendAssets(recipient: Recipient, assets: Asset[]): Transaction;
+    /**
+     * Adds a transaction output to the transaction.
+     *
+     * @param {Recipient} recipient The recipient of the transaction.
+     * @param {string} lovelace The amount of lovelace to send.
+     * @returns {Transaction} The Transaction object.
+     * @see {@link https://meshjs.dev/apis/transaction#sendAda}
+     */
+    sendLovelace(recipient: Recipient, lovelace: string): Transaction;
+    /**
+     * Adds stable coins transaction output to the transaction.
+     * @param {Recipient} recipient The recipient of the transaction.
+     * @param {Token} ticker The ticker of the token to send.
+     * @param {string} amount The amount of the token to send.
+     * @returns {Transaction} The Transaction object.
+     * @see {@link https://meshjs.dev/apis/transaction#sendToken}
+     */
+    sendToken(recipient: Recipient, ticker: Token, amount: string): Transaction;
+    /**
+     * Adds an output to the transaction.
+     *
+     * @param {Recipient} recipient The recipient of the output.
+     * @param {UTxO} value The UTxO value of the output.
+     * @returns {Transaction} The Transaction object.
+     */
+    sendValue(recipient: Recipient, value: UTxO): Transaction;
+    /**
+     * Sets the change address for the transaction.
+     *
+     * @param {string} changeAddress The change address.
+     * @returns {Transaction} The Transaction object.
+     */
+    setChangeAddress(changeAddress: string): Transaction;
+    /**
+     * Sets the collateral for the transaction.
+     *
+     * @param {UTxO[]} collateral - Set the UTxO for collateral.
+     * @returns {Transaction} The Transaction object.
+     */
+    setCollateral(collateral: UTxO[]): Transaction;
+    /**
+     * Add a JSON metadata entry to the transaction.
+     *
+     * @param {number} key The key to use for the metadata entry.
+     * @param {unknown} value The value to use for the metadata entry.
+     * @returns {Transaction} The Transaction object.
+     * @see {@link https://meshjs.dev/apis/transaction#setMetadata}
+     */
+    setMetadata(key: number, value: unknown): Transaction;
+    /**
+     * Sets the required signers for the transaction.
+     *
+     * @param {string[]} addresses The addresses of the required signers.
+     * @returns {Transaction} The Transaction object.
+     */
+    setRequiredSigners(addresses: string[]): Transaction;
+    /**
+     * Sets the start slot for the transaction.
+     *
+     * @param {string} slot The start slot for the transaction.
+     * @returns {Transaction} The Transaction object.
+     * @see {@link https://meshjs.dev/apis/transaction#setTimeLimit}
+     */
+    setTimeToStart(slot: string): Transaction;
+    /**
+     * Set the time to live for the transaction.
+     *
+     * @param {string} slot The slot number to expire the transaction at.
+     * @returns {Transaction} The Transaction object.
+     * @see {@link https://meshjs.dev/apis/transaction#setTimeLimit}
+     */
+    setTimeToExpire(slot: string): Transaction;
+    /**
+     * Sets the inputs for the transaction.
+     *
+     * @param {UTxO[]} inputs The inputs to set.
+     * @returns {Transaction} The transaction.
+     */
+    setTxInputs(inputs: UTxO[]): Transaction;
+    /**
+     * Sets the reference inputs for the transaction.
+     *
+     * @param {UTxO[]} inputs The reference inputs to set.
+     * @returns {Transaction} The transaction.
+     */
+    setTxRefInputs(inputs: UTxO[]): Transaction;
+    withdrawRewards(rewardAddress: string, lovelace: string): Transaction;
+    private addBurnInputsIfNeeded;
+    private addChangeAddress;
+    private addCollateralIfNeeded;
+    private addRequiredSignersIfNeeded;
+    private addTxInputsAsNeeded;
+    private forgeAssetsIfNeeded;
+    private filterAvailableUTxOs;
+    private addMintOutputs;
+    private notVisited;
+    private setTxOutput;
+}
+declare type CreateTxOptions = {
+    initiator: IInitiator;
+    parameters: Protocol;
+    era: Era;
+};
+export {};

package/dist/types/Account.d.ts

@@ -0,0 +1,5 @@
+export declare type Account = {
+    baseAddress: string;
+    enterpriseAddress: string;
+    rewardAddress: string;
+};

package/dist/types/AccountInfo.d.ts

@@ -0,0 +1,7 @@
+export declare type AccountInfo = {
+    active: boolean;
+    poolId?: string;
+    balance: string;
+    rewards: string;
+    withdrawals: string;
+};

package/dist/types/Action.d.ts

@@ -0,0 +1,12 @@
+import { REDEEMER_TAGS } from '@mesh/common/constants';
+import { Data } from './Data';
+export declare type Action = {
+    data: Data;
+    index: number;
+    budget: Budget;
+    tag: keyof typeof REDEEMER_TAGS;
+};
+export declare type Budget = {
+    mem: number;
+    steps: number;
+};

package/dist/types/Asset.d.ts

@@ -0,0 +1,6 @@
+export declare type Asset = {
+    unit: Unit;
+    quantity: Quantity;
+};
+export declare type Unit = string;
+export declare type Quantity = string;

package/dist/types/AssetExtended.d.ts

@@ -0,0 +1,8 @@
+import { Quantity, Unit } from './Asset';
+export declare type AssetExtended = {
+    unit: Unit;
+    policyId: string;
+    assetName: string;
+    fingerprint: string;
+    quantity: Quantity;
+};

package/dist/types/AssetMetadata.d.ts

@@ -0,0 +1,24 @@
+import type { MetadataStandard, Files, RoyaltiesStandard } from '@mesh/core';
+export declare type AssetMetadata = FungibleAssetMetadata | NonFungibleAssetMetadata | RoyaltiesStandard;
+export declare type FungibleAssetMetadata = MetadataStandard & {
+    ticker: string;
+    decimals: number;
+    version: `${number}.${number}`;
+};
+export declare type NonFungibleAssetMetadata = AudioAssetMetadata | ImageAssetMetadata | SmartAssetMetadata | VideoAssetMetadata;
+declare type AudioAssetMetadata = MetadataStandard & Files;
+export declare type ImageAssetMetadata = MetadataStandard & Files & {
+    artists?: [
+        {
+            name: string;
+            twitter?: `https://twitter.com/${string}`;
+        }
+    ];
+    attributes?: {
+        [key: string]: string;
+    };
+    traits?: string[];
+};
+declare type SmartAssetMetadata = MetadataStandard & Files;
+declare type VideoAssetMetadata = MetadataStandard & Files;
+export {};

package/dist/types/BlockInfo.d.ts

@@ -0,0 +1,17 @@
+export declare type BlockInfo = {
+    time: number;
+    hash: string;
+    slot: string;
+    epoch: number;
+    epochSlot: string;
+    slotLeader: string;
+    size: number;
+    txCount: number;
+    output: string;
+    fees: string;
+    previousBlock: string;
+    nextBlock: string;
+    confirmations: number;
+    operationalCertificate: string;
+    VRFKey: string;
+};