@meshsdk/core 1.6.0-alpha.14 → 1.6.0-alpha.16

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/decorators.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="chai" />
+/// <reference types="chai-subset" />
+export declare const Trackable: <T extends new (...args: any[]) => Object>(constructor: T) => {
+    new (...args: any[]): {
+        __visits: never[];
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+        should: Chai.Assertion;
+    };
+} & T;
+export declare const Checkpoint: () => (_target: Object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => void;
+export interface TrackableObject {
+    __visits: unknown[];
+}

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/builder.d.ts

@@ -0,0 +1,18 @@
+import { csl } from '@mesh/core';
+import type { BaseAddress, Bip32PrivateKey, DataCost, DatumSource, Ed25519KeyHash, EnterpriseAddress, MintWitness, PlutusScriptSource, RewardAddress, TransactionBuilder, TransactionOutputBuilder, TxInputsBuilder } from '@mesh/core';
+import type { Action, Data, PlutusScript, Recipient, UTxO } from '@mesh/types';
+export declare const buildBaseAddress: (networkId: number, paymentKeyHash: Ed25519KeyHash, stakeKeyHash: Ed25519KeyHash) => BaseAddress;
+export declare const buildBip32PrivateKey: (entropy: string, password?: string) => Bip32PrivateKey;
+export declare const buildDataCost: (coinsPerByte: string) => DataCost;
+export declare const buildDatumSource: (datum: Data | UTxO) => DatumSource;
+export declare const buildEnterpriseAddress: (networkId: number, paymentKeyHash: Ed25519KeyHash) => EnterpriseAddress;
+export declare const buildGeneralTxMetadata: (metadata: Record<string, unknown>) => csl.GeneralTransactionMetadata;
+export declare const buildMintWitness: (script: string | PlutusScript | UTxO, redeemer?: Partial<Action>) => MintWitness;
+export declare const buildRewardAddress: (networkId: number, stakeKeyHash: Ed25519KeyHash) => RewardAddress;
+export declare const buildPlutusScriptSource: (script: PlutusScript | UTxO) => PlutusScriptSource;
+export declare const buildScriptPubkey: (keyHash: Ed25519KeyHash) => csl.NativeScript;
+export declare const buildTimelockExpiry: (slot: string) => csl.NativeScript;
+export declare const buildTimelockStart: (slot: string) => csl.NativeScript;
+export declare const buildTxBuilder: (parameters?: import("@mesh/types").Protocol) => TransactionBuilder;
+export declare const buildTxInputsBuilder: (utxos: unknown[]) => TxInputsBuilder;
+export declare const buildTxOutputBuilder: (recipient: Recipient) => TransactionOutputBuilder;

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

@@ -0,0 +1,27 @@
+import { csl } from '@mesh/core';
+import type { PlutusData, ScriptRef, TransactionUnspentOutput, Value } from '@mesh/core';
+import type { Action, Asset, Data, NativeScript, PlutusScript, PoolParams, Relay, UTxO } from '@mesh/types';
+export declare const toAddress: (bech32: string) => csl.Address;
+export declare const toBaseAddress: (bech32: string) => csl.BaseAddress | undefined;
+export declare const toEnterpriseAddress: (bech32: string) => csl.EnterpriseAddress | undefined;
+export declare const toRewardAddress: (bech32: string) => csl.RewardAddress | undefined;
+export declare const fromBytes: (bytes: Uint8Array) => string;
+export declare const toBytes: (hex: string) => Uint8Array;
+export declare const fromLovelace: (lovelace: number) => number;
+export declare const toLovelace: (ada: number) => number;
+export declare const fromNativeScript: (script: csl.NativeScript) => NativeScript;
+export declare const toNativeScript: (script: NativeScript) => csl.NativeScript;
+export declare const fromPlutusData: (plutusData: PlutusData) => Data;
+export declare const toPlutusData: (data: Data) => csl.PlutusData;
+export declare const toPoolParams: (params: PoolParams) => never;
+export declare const toRedeemer: (action: Action) => csl.Redeemer;
+export declare const toRelay: (relay: Relay) => csl.Relay;
+export declare const fromScriptRef: (scriptRef: ScriptRef) => NativeScript | PlutusScript;
+export declare const toScriptRef: (script: PlutusScript | NativeScript) => csl.ScriptRef;
+export declare const fromTxUnspentOutput: (txUnspentOutput: TransactionUnspentOutput) => UTxO;
+export declare const toTxUnspentOutput: (utxo: UTxO) => csl.TransactionUnspentOutput;
+export declare const toUnitInterval: (float: string) => csl.UnitInterval;
+export declare const fromUTF8: (utf8: string) => string;
+export declare const toUTF8: (hex: string) => string;
+export declare const fromValue: (value: Value) => Asset[];
+export declare const toValue: (assets: Asset[]) => csl.Value;

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

@@ -0,0 +1,19 @@
+import { csl } from '@mesh/core';
+import type { LanguageVersion } from '@mesh/types';
+export declare const deserializeAddress: (address: string) => csl.Address;
+export declare const deserializeBip32PrivateKey: (bip32PrivateKey: string) => csl.Bip32PrivateKey;
+export declare const deserializeDataHash: (dataHash: string) => csl.DataHash;
+export declare const deserializeEd25519KeyHash: (ed25519KeyHash: string) => csl.Ed25519KeyHash;
+export declare const deserializeEd25519Signature: (ed25519Signature: string) => csl.Ed25519Signature;
+export declare const deserializeNativeScript: (nativeScript: string) => csl.NativeScript;
+export declare const deserializePublicKey: (publicKey: string) => csl.PublicKey;
+export declare const deserializePlutusData: (plutusData: string) => csl.PlutusData;
+export declare const deserializePlutusScript: (plutusScript: string, version: LanguageVersion) => csl.PlutusScript;
+export declare const deserializeScriptRef: (scriptRef: string) => csl.ScriptRef;
+export declare const deserializeScriptHash: (scriptHash: string) => csl.ScriptHash;
+export declare const deserializeTx: (tx: string) => csl.Transaction;
+export declare const deserializeTxBody: (txBody: string) => csl.TransactionBody;
+export declare const deserializeTxHash: (txHash: string) => csl.TransactionHash;
+export declare const deserializeTxUnspentOutput: (txUnspentOutput: string) => csl.TransactionUnspentOutput;
+export declare const deserializeTxWitnessSet: (txWitnessSet: string) => csl.TransactionWitnessSet;
+export declare const deserializeValue: (value: string) => csl.Value;

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

@@ -0,0 +1,5 @@
+export * from './builder';
+export * from './converter';
+export * from './deserializer';
+export * from './parser';
+export * from './resolver';

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/CIP14.d.ts

@@ -0,0 +1,2 @@
+import CIP14 from '@emurgo/cip14-js';
+export declare const AssetFingerprint: typeof CIP14;

package/dist/core/CIP1852.d.ts

@@ -0,0 +1,4 @@
+export declare const deriveAccountKeys: (rootKey: string, accountIndex: number) => {
+    paymentKey: import("@sidan-lab/sidan-csl-rs-nodejs").PrivateKey;
+    stakeKey: import("@sidan-lab/sidan-csl-rs-nodejs").PrivateKey;
+};

package/dist/core/CIP1853.d.ts

@@ -0,0 +1 @@
+export declare const deriveStakePoolColdKey: (rootKey: string, coldIndex: number) => import("@sidan-lab/sidan-csl-rs-nodejs").PrivateKey;

package/dist/core/CIP1855.d.ts

@@ -0,0 +1 @@
+export declare const deriveForgingPolicyKey: (rootKey: string, policyIndex: number) => import("@sidan-lab/sidan-csl-rs-nodejs").PrivateKey;

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/CIP25.d.ts

@@ -0,0 +1,19 @@
+export declare type MetadataStandard = {
+    name: string;
+    image: `${string}://${string}`;
+    mediaType?: `image/${string}`;
+    description?: string | string[];
+    instagram?: `https://instagram.com/${string}`;
+    twitter?: `https://twitter.com/${string}`;
+    discord?: `https://discord.gg/${string}`;
+    website?: `https://${string}`;
+};
+export declare type Files = {
+    files?: [
+        {
+            name: string;
+            src: `${string}://${string}`;
+            mediaType: `${string}/${string}`;
+        }
+    ];
+};

package/dist/core/CIP27.d.ts

@@ -0,0 +1,4 @@
+export declare type RoyaltiesStandard = {
+    rate: string;
+    address: string;
+};

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/core/CPS0009.d.ts

@@ -0,0 +1,2 @@
+import type { Quantity, UTxO, Unit } from '@mesh/types';
+export declare const selectUtxos: (inputs: UTxO[], requiredAssets: Map<Unit, Quantity>, threshold: Quantity) => UTxO[];

package/dist/core/CSL.d.ts

@@ -0,0 +1,147 @@
+import { csl } from '@meshsdk/mesh-csl';
+export { csl, applyParamsToScript } from '@meshsdk/mesh-csl';
+export declare type Address = InstanceType<typeof csl.Address>;
+export declare type AssetName = InstanceType<typeof csl.AssetName>;
+export declare type AssetNames = InstanceType<typeof csl.AssetNames>;
+export declare type Assets = InstanceType<typeof csl.Assets>;
+export declare type AuxiliaryData = InstanceType<typeof csl.AuxiliaryData>;
+export declare type AuxiliaryDataHash = InstanceType<typeof csl.AuxiliaryDataHash>;
+export declare type AuxiliaryDataSet = InstanceType<typeof csl.AuxiliaryDataSet>;
+export declare type BaseAddress = InstanceType<typeof csl.BaseAddress>;
+export declare type BigInt = InstanceType<typeof csl.BigInt>;
+export declare type BigNum = InstanceType<typeof csl.BigNum>;
+export declare type Bip32PrivateKey = InstanceType<typeof csl.Bip32PrivateKey>;
+export declare type Bip32PublicKey = InstanceType<typeof csl.Bip32PublicKey>;
+export declare type Block = InstanceType<typeof csl.Block>;
+export declare type BlockHash = InstanceType<typeof csl.BlockHash>;
+export declare type BootstrapWitness = InstanceType<typeof csl.BootstrapWitness>;
+export declare type BootstrapWitnesses = InstanceType<typeof csl.BootstrapWitnesses>;
+export declare type ByronAddress = InstanceType<typeof csl.ByronAddress>;
+export declare type Certificate = InstanceType<typeof csl.Certificate>;
+export declare type Certificates = InstanceType<typeof csl.Certificates>;
+export declare type ConstrPlutusData = InstanceType<typeof csl.ConstrPlutusData>;
+export declare type CostModel = InstanceType<typeof csl.CostModel>;
+export declare type Costmdls = InstanceType<typeof csl.Costmdls>;
+export declare type DNSRecordAorAAAA = InstanceType<typeof csl.DNSRecordAorAAAA>;
+export declare type DNSRecordSRV = InstanceType<typeof csl.DNSRecordSRV>;
+export declare type DataCost = InstanceType<typeof csl.DataCost>;
+export declare type DataHash = InstanceType<typeof csl.DataHash>;
+export declare type DatumSource = InstanceType<typeof csl.DatumSource>;
+export declare type Ed25519KeyHash = InstanceType<typeof csl.Ed25519KeyHash>;
+export declare type Ed25519KeyHashes = InstanceType<typeof csl.Ed25519KeyHashes>;
+export declare type Ed25519Signature = InstanceType<typeof csl.Ed25519Signature>;
+export declare type EnterpriseAddress = InstanceType<typeof csl.EnterpriseAddress>;
+export declare type ExUnitPrices = InstanceType<typeof csl.ExUnitPrices>;
+export declare type ExUnits = InstanceType<typeof csl.ExUnits>;
+export declare type GeneralTransactionMetadata = InstanceType<typeof csl.GeneralTransactionMetadata>;
+export declare type GenesisDelegateHash = InstanceType<typeof csl.GenesisDelegateHash>;
+export declare type GenesisHash = InstanceType<typeof csl.GenesisHash>;
+export declare type GenesisHashes = InstanceType<typeof csl.GenesisHashes>;
+export declare type GenesisKeyDelegation = InstanceType<typeof csl.GenesisKeyDelegation>;
+export declare type Header = InstanceType<typeof csl.Header>;
+export declare type HeaderBody = InstanceType<typeof csl.HeaderBody>;
+export declare type Int = InstanceType<typeof csl.Int>;
+export declare type Ipv4 = InstanceType<typeof csl.Ipv4>;
+export declare type Ipv6 = InstanceType<typeof csl.Ipv6>;
+export declare type KESSignature = InstanceType<typeof csl.KESSignature>;
+export declare type KESVKey = InstanceType<typeof csl.KESVKey>;
+export declare type Language = InstanceType<typeof csl.Language>;
+export declare type Languages = InstanceType<typeof csl.Languages>;
+export declare type LegacyDaedalusPrivateKey = InstanceType<typeof csl.LegacyDaedalusPrivateKey>;
+export declare type LinearFee = InstanceType<typeof csl.LinearFee>;
+export declare type MIRToStakeCredentials = InstanceType<typeof csl.MIRToStakeCredentials>;
+export declare type MetadataList = InstanceType<typeof csl.MetadataList>;
+export declare type MetadataMap = InstanceType<typeof csl.MetadataMap>;
+export declare type Mint = InstanceType<typeof csl.Mint>;
+export declare type MintAssets = InstanceType<typeof csl.MintAssets>;
+export declare type MintBuilder = InstanceType<typeof csl.MintBuilder>;
+export declare type MintWitness = InstanceType<typeof csl.MintWitness>;
+export declare type MintsAssets = InstanceType<typeof csl.MintsAssets>;
+export declare type MoveInstantaneousReward = InstanceType<typeof csl.MoveInstantaneousReward>;
+export declare type MoveInstantaneousRewardsCert = InstanceType<typeof csl.MoveInstantaneousRewardsCert>;
+export declare type MultiAsset = InstanceType<typeof csl.MultiAsset>;
+export declare type MultiHostName = InstanceType<typeof csl.MultiHostName>;
+export declare type NativeScript = InstanceType<typeof csl.NativeScript>;
+export declare type NativeScripts = InstanceType<typeof csl.NativeScripts>;
+export declare type NetworkId = InstanceType<typeof csl.NetworkId>;
+export declare type NetworkInfo = InstanceType<typeof csl.NetworkInfo>;
+export declare type Nonce = InstanceType<typeof csl.Nonce>;
+export declare type OperationalCert = InstanceType<typeof csl.OperationalCert>;
+export declare type PlutusData = InstanceType<typeof csl.PlutusData>;
+export declare type PlutusList = InstanceType<typeof csl.PlutusList>;
+export declare type PlutusMap = InstanceType<typeof csl.PlutusMap>;
+export declare type PlutusScript = InstanceType<typeof csl.PlutusScript>;
+export declare type PlutusScripts = InstanceType<typeof csl.PlutusScripts>;
+export declare type PlutusScriptSource = InstanceType<typeof csl.PlutusScriptSource>;
+export declare type PlutusWitness = InstanceType<typeof csl.PlutusWitness>;
+export declare type PlutusWitnesses = InstanceType<typeof csl.PlutusWitnesses>;
+export declare type Pointer = InstanceType<typeof csl.Pointer>;
+export declare type PointerAddress = InstanceType<typeof csl.PointerAddress>;
+export declare type PoolMetadata = InstanceType<typeof csl.PoolMetadata>;
+export declare type PoolMetadataHash = InstanceType<typeof csl.PoolMetadataHash>;
+export declare type PoolParams = InstanceType<typeof csl.PoolParams>;
+export declare type PoolRegistration = InstanceType<typeof csl.PoolRegistration>;
+export declare type PoolRetirement = InstanceType<typeof csl.PoolRetirement>;
+export declare type PrivateKey = InstanceType<typeof csl.PrivateKey>;
+export declare type ProposedProtocolParameterUpdates = InstanceType<typeof csl.ProposedProtocolParameterUpdates>;
+export declare type ProtocolParamUpdate = InstanceType<typeof csl.ProtocolParamUpdate>;
+export declare type ProtocolVersion = InstanceType<typeof csl.ProtocolVersion>;
+export declare type PublicKey = InstanceType<typeof csl.PublicKey>;
+export declare type PublicKeys = InstanceType<typeof csl.PublicKeys>;
+export declare type Redeemer = InstanceType<typeof csl.Redeemer>;
+export declare type RedeemerTag = InstanceType<typeof csl.RedeemerTag>;
+export declare type Redeemers = InstanceType<typeof csl.Redeemers>;
+export declare type Relay = InstanceType<typeof csl.Relay>;
+export declare type Relays = InstanceType<typeof csl.Relays>;
+export declare type RewardAddress = InstanceType<typeof csl.RewardAddress>;
+export declare type RewardAddresses = InstanceType<typeof csl.RewardAddresses>;
+export declare type ScriptAll = InstanceType<typeof csl.ScriptAll>;
+export declare type ScriptAny = InstanceType<typeof csl.ScriptAny>;
+export declare type ScriptDataHash = InstanceType<typeof csl.ScriptDataHash>;
+export declare type ScriptHash = InstanceType<typeof csl.ScriptHash>;
+export declare type ScriptHashes = InstanceType<typeof csl.ScriptHashes>;
+export declare type ScriptNOfK = InstanceType<typeof csl.ScriptNOfK>;
+export declare type ScriptPubkey = InstanceType<typeof csl.ScriptPubkey>;
+export declare type ScriptRef = InstanceType<typeof csl.ScriptRef>;
+export declare type SingleHostAddr = InstanceType<typeof csl.SingleHostAddr>;
+export declare type SingleHostName = InstanceType<typeof csl.SingleHostName>;
+export declare type StakeCredential = InstanceType<typeof csl.StakeCredential>;
+export declare type StakeCredentials = InstanceType<typeof csl.StakeCredentials>;
+export declare type StakeDelegation = InstanceType<typeof csl.StakeDelegation>;
+export declare type StakeRegistration = InstanceType<typeof csl.StakeRegistration>;
+export declare type Strings = InstanceType<typeof csl.Strings>;
+export declare type TimelockExpiry = InstanceType<typeof csl.TimelockExpiry>;
+export declare type TimelockStart = InstanceType<typeof csl.TimelockStart>;
+export declare type Transaction = InstanceType<typeof csl.Transaction>;
+export declare type TransactionBodies = InstanceType<typeof csl.TransactionBodies>;
+export declare type TransactionBody = InstanceType<typeof csl.TransactionBody>;
+export declare type TransactionBuilder = InstanceType<typeof csl.TransactionBuilder>;
+export declare type TransactionBuilderConfig = InstanceType<typeof csl.TransactionBuilderConfig>;
+export declare type TransactionBuilderConfigBuilder = InstanceType<typeof csl.TransactionBuilderConfigBuilder>;
+export declare type TransactionHash = InstanceType<typeof csl.TransactionHash>;
+export declare type TransactionInput = InstanceType<typeof csl.TransactionInput>;
+export declare type TransactionInputs = InstanceType<typeof csl.TransactionInputs>;
+export declare type TransactionMetadatum = InstanceType<typeof csl.TransactionMetadatum>;
+export declare type TransactionMetadatumLabels = InstanceType<typeof csl.TransactionMetadatumLabels>;
+export declare type TransactionOutput = InstanceType<typeof csl.TransactionOutput>;
+export declare type TransactionOutputAmountBuilder = InstanceType<typeof csl.TransactionOutputAmountBuilder>;
+export declare type TransactionOutputBuilder = InstanceType<typeof csl.TransactionOutputBuilder>;
+export declare type TransactionOutputs = InstanceType<typeof csl.TransactionOutputs>;
+export declare type TransactionUnspentOutput = InstanceType<typeof csl.TransactionUnspentOutput>;
+export declare type TransactionUnspentOutputs = InstanceType<typeof csl.TransactionUnspentOutputs>;
+export declare type TransactionWitnessSet = InstanceType<typeof csl.TransactionWitnessSet>;
+export declare type TransactionWitnessSets = InstanceType<typeof csl.TransactionWitnessSets>;
+export declare type TxBuilderConstants = InstanceType<typeof csl.TxBuilderConstants>;
+export declare type TxInputsBuilder = InstanceType<typeof csl.TxInputsBuilder>;
+export declare type URL = InstanceType<typeof csl.URL>;
+export declare type UnitInterval = InstanceType<typeof csl.UnitInterval>;
+export declare type Update = InstanceType<typeof csl.Update>;
+export declare type VRFCert = InstanceType<typeof csl.VRFCert>;
+export declare type VRFKeyHash = InstanceType<typeof csl.VRFKeyHash>;
+export declare type VRFVKey = InstanceType<typeof csl.VRFVKey>;
+export declare type Value = InstanceType<typeof csl.Value>;
+export declare type Vkey = InstanceType<typeof csl.Vkey>;
+export declare type Vkeys = InstanceType<typeof csl.Vkeys>;
+export declare type Vkeywitness = InstanceType<typeof csl.Vkeywitness>;
+export declare type Vkeywitnesses = InstanceType<typeof csl.Vkeywitnesses>;
+export declare type Withdrawals = InstanceType<typeof csl.Withdrawals>;

package/dist/core/index.d.ts

@@ -0,0 +1,10 @@
+export * from './CIP2';
+export * from './CIP8';
+export * from './CIP14';
+export * from './CIP25';
+export * from './CIP27';
+export * from './CIP1852';
+export * from './CIP1853';
+export * from './CIP1855';
+export * from './CPS0009';
+export * from './CSL';