@meshsdk/core 1.6.0-alpha.3 → 1.6.0-alpha.5

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/data/plutus.spec.d.ts

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

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/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;
+};