@meshsdk/common 1.0.0-alpha.1 → 1.0.0-alpha.12

package/dist/cjs/builder/data/index.d.ts

@@ -0,0 +1,4 @@
+export * from './mesh';
+export * from './plutus';
+export * from './parser';
+export * from './time';

package/dist/cjs/builder/data/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./mesh"), exports);
+__exportStar(require("./plutus"), exports);
+__exportStar(require("./parser"), exports);
+__exportStar(require("./time"), exports);

package/dist/cjs/builder/data/mesh.d.ts

@@ -0,0 +1,8 @@
+import { Data } from '../../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/cjs/builder/data/mesh.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mScriptAddress = exports.mPubKeyAddress = exports.mMaybeStakingHash = exports.mConStr2 = exports.mConStr1 = exports.mConStr0 = exports.mConStr = void 0;
+const mConStr = (alternative, fields) => ({
+    alternative,
+    fields,
+});
+exports.mConStr = mConStr;
+const mConStr0 = (fields) => ({
+    alternative: 0,
+    fields,
+});
+exports.mConStr0 = mConStr0;
+const mConStr1 = (fields) => ({
+    alternative: 1,
+    fields,
+});
+exports.mConStr1 = mConStr1;
+const mConStr2 = (fields) => ({
+    alternative: 2,
+    fields,
+});
+exports.mConStr2 = mConStr2;
+const mMaybeStakingHash = (stakeCredential) => {
+    if (stakeCredential === '') {
+        return (0, exports.mConStr1)([]);
+    }
+    return (0, exports.mConStr0)([(0, exports.mConStr0)([(0, exports.mConStr0)([stakeCredential])])]);
+};
+exports.mMaybeStakingHash = mMaybeStakingHash;
+const mPubKeyAddress = (bytes, stakeCredential) => (0, exports.mConStr0)([{ alternative: 0, fields: [bytes] }, (0, exports.mMaybeStakingHash)(stakeCredential || '')]);
+exports.mPubKeyAddress = mPubKeyAddress;
+const mScriptAddress = (bytes, stakeCredential) => (0, exports.mConStr0)([{ alternative: 1, fields: [bytes] }, (0, exports.mMaybeStakingHash)(stakeCredential || '')]);
+exports.mScriptAddress = mScriptAddress;

package/dist/cjs/builder/data/parser.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+export declare const bytesToHex: (bytes: ArrayBuffer) => string;
+export declare const hexToBytes: (hex: string) => Buffer;
+export declare const stringToHex: (str: string) => string;
+export declare const hexToString: (hex: string) => string;

package/dist/cjs/builder/data/parser.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexToString = exports.stringToHex = exports.hexToBytes = exports.bytesToHex = void 0;
+const bytesToHex = (bytes) => Buffer.from(bytes).toString('hex');
+exports.bytesToHex = bytesToHex;
+const hexToBytes = (hex) => Buffer.from(hex, 'hex');
+exports.hexToBytes = hexToBytes;
+const stringToHex = (str) => Buffer.from(str, 'utf8').toString('hex');
+exports.stringToHex = stringToHex;
+const hexToString = (hex) => Buffer.from(hex, 'hex').toString('utf8');
+exports.hexToString = hexToString;

package/dist/cjs/builder/data/plutus.d.ts

@@ -0,0 +1,69 @@
+import { Asset } from '../../types';
+export type ConStr<N = any, T = any> = {
+    constructor: N;
+    fields: T;
+};
+export type ConStr0<T = any> = ConStr<0, T>;
+export type ConStr1<T = any> = ConStr<1, T>;
+export type ConStr2<T = any> = ConStr<2, T>;
+export type Bool = ConStr0<[]> | ConStr1<[]>;
+export type BuiltinByteString = {
+    bytes: string;
+};
+export type Integer = {
+    int: number;
+};
+export type List = {
+    list: PlutusData[];
+};
+export type ValidatorHash = BuiltinByteString;
+export type PaymentPubKeyHash = BuiltinByteString;
+export type PubKeyHash = PaymentPubKeyHash;
+export type POSIXTime = Integer;
+export type CurrencySymbol = BuiltinByteString;
+export type TokenName = BuiltinByteString;
+export type MaybeStakingHash = ConStr1<[]> | ConStr0<[ConStr0<[ConStr0<[BuiltinByteString]>]>]> | ConStr0<[ConStr0<[ConStr1<[BuiltinByteString]>]>]>;
+export type PubKeyAddress = ConStr0<[ConStr0<[PubKeyHash]>, MaybeStakingHash]>;
+export type ScriptAddress = ConStr0<[ConStr1<[ValidatorHash]>, MaybeStakingHash]>;
+export type AssetClass = ConStr0<[CurrencySymbol, TokenName]>;
+export type TxOutRef = ConStr0<[ConStr0<[BuiltinByteString]>, Integer]>;
+export type AssocMapItem<K, V> = {
+    k: K;
+    v: V;
+};
+export type DictItem<K, V> = {
+    k: K;
+    v: V;
+};
+export type AssocMap<K, V> = {
+    map: AssocMapItem<K, V>[];
+};
+export type Dict<K, V> = {
+    map: DictItem<K, V>[];
+};
+export type Tuple<K, V> = ConStr0<[K, V]>;
+export type Value = AssocMap<CurrencySymbol, AssocMap<TokenName, Integer>>;
+export type PlutusData = BuiltinByteString | Integer | MaybeStakingHash | PubKeyAddress | ScriptAddress | AssetClass | PaymentPubKeyHash | PubKeyHash | POSIXTime | TxOutRef | AssocMap<any, any> | Dict<any, any> | Tuple<any, any> | Value;
+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, isScriptCredential?: boolean) => MaybeStakingHash;
+export declare const pubKeyAddress: (bytes: string, stakeCredential?: string, isScriptCredential?: boolean) => PubKeyAddress;
+export declare const scriptAddress: (bytes: string, stakeCredential?: string, isScriptCredential?: boolean) => 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/cjs/builder/data/plutus.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePlutusValueToAssets = exports.value = exports.tuple = exports.dict = exports.assocMap = exports.posixTime = exports.pubKeyHash = exports.paymentPubKeyHash = exports.txOutRef = exports.assetClass = exports.scriptAddress = exports.pubKeyAddress = exports.maybeStakingHash = exports.tokenName = exports.currencySymbol = exports.list = exports.integer = exports.builtinByteString = exports.bool = exports.conStr2 = exports.conStr1 = exports.conStr0 = exports.conStr = void 0;
+const conStr = (constructor, fields) => ({
+    constructor,
+    fields,
+});
+exports.conStr = conStr;
+const conStr0 = (fields) => (0, exports.conStr)(0, fields);
+exports.conStr0 = conStr0;
+const conStr1 = (fields) => (0, exports.conStr)(1, fields);
+exports.conStr1 = conStr1;
+const conStr2 = (fields) => (0, exports.conStr)(2, fields);
+exports.conStr2 = conStr2;
+const bool = (b) => (b ? (0, exports.conStr1)([]) : (0, exports.conStr0)([]));
+exports.bool = bool;
+const builtinByteString = (bytes) => ({
+    bytes,
+});
+exports.builtinByteString = builtinByteString;
+const integer = (int) => ({ int });
+exports.integer = integer;
+const list = (pList) => ({ list: pList });
+exports.list = list;
+const currencySymbol = (bytes) => (0, exports.builtinByteString)(bytes);
+exports.currencySymbol = currencySymbol;
+const tokenName = (bytes) => (0, exports.builtinByteString)(bytes);
+exports.tokenName = tokenName;
+const maybeStakingHash = (stakeCredential, isScriptCredential = false) => {
+    if (stakeCredential === '') {
+        return (0, exports.conStr1)([]);
+    }
+    if (isScriptCredential) {
+        return (0, exports.conStr0)([
+            (0, exports.conStr0)([(0, exports.conStr1)([(0, exports.builtinByteString)(stakeCredential)])]),
+        ]);
+    }
+    return (0, exports.conStr0)([
+        (0, exports.conStr0)([(0, exports.conStr0)([(0, exports.builtinByteString)(stakeCredential)])]),
+    ]);
+};
+exports.maybeStakingHash = maybeStakingHash;
+const pubKeyAddress = (bytes, stakeCredential, isScriptCredential = false) => (0, exports.conStr0)([
+    (0, exports.conStr0)([(0, exports.builtinByteString)(bytes)]),
+    (0, exports.maybeStakingHash)(stakeCredential || '', isScriptCredential),
+]);
+exports.pubKeyAddress = pubKeyAddress;
+const scriptAddress = (bytes, stakeCredential, isScriptCredential = false) => (0, exports.conStr0)([
+    (0, exports.conStr1)([(0, exports.builtinByteString)(bytes)]),
+    (0, exports.maybeStakingHash)(stakeCredential || '', isScriptCredential),
+]);
+exports.scriptAddress = scriptAddress;
+const assetClass = (policyId, assetName) => (0, exports.conStr0)([(0, exports.currencySymbol)(policyId), (0, exports.tokenName)(assetName)]);
+exports.assetClass = assetClass;
+const txOutRef = (txHash, index) => (0, exports.conStr0)([(0, exports.conStr0)([(0, exports.builtinByteString)(txHash)]), (0, exports.integer)(index)]);
+exports.txOutRef = txOutRef;
+const paymentPubKeyHash = (bytes) => (0, exports.builtinByteString)(bytes);
+exports.paymentPubKeyHash = paymentPubKeyHash;
+const pubKeyHash = (bytes) => (0, exports.builtinByteString)(bytes);
+exports.pubKeyHash = pubKeyHash;
+const posixTime = (int) => ({ int });
+exports.posixTime = posixTime;
+const assocMap = (itemsMap) => ({
+    map: itemsMap.map(([k, v]) => ({ k, v })),
+});
+exports.assocMap = assocMap;
+const dict = (itemsMap) => ({
+    map: itemsMap.map(([k, v]) => ({ k, v })),
+});
+exports.dict = dict;
+const tuple = (key, value) => (0, exports.conStr0)([key, value]);
+exports.tuple = tuple;
+const value = (assets) => {
+    const valueMapToParse = [];
+    const valueMap = {};
+    assets.forEach((asset) => {
+        const sanitizedName = asset.unit.replace('lovelace', '');
+        const policy = sanitizedName.slice(0, 56) || '';
+        const token = sanitizedName.slice(56) || '';
+        if (!valueMap[policy]) {
+            valueMap[policy] = {};
+        }
+        if (!valueMap[policy][token]) {
+            valueMap[policy][token] = Number(asset.quantity);
+        }
+        else {
+            valueMap[policy][token] += Number(asset.quantity);
+        }
+    });
+    Object.keys(valueMap).forEach((policy) => {
+        const policyByte = (0, exports.currencySymbol)(policy);
+        const tokens = Object.keys(valueMap[policy]).map((name) => [
+            (0, exports.tokenName)(name),
+            (0, exports.integer)(valueMap[policy][name]),
+        ]);
+        const policyMap = (0, exports.assocMap)(tokens);
+        valueMapToParse.push([policyByte, policyMap]);
+    });
+    return (0, exports.assocMap)(valueMapToParse);
+};
+exports.value = value;
+const parsePlutusValueToAssets = (plutusValue) => {
+    const assets = [];
+    plutusValue.map.forEach((policyMap) => {
+        const policy = policyMap.k.bytes;
+        policyMap.v.map.forEach((tokenMap) => {
+            const token = tokenMap.k.bytes;
+            const quantity = tokenMap.v.int.toString();
+            const unsanitizedUnit = policy + token;
+            const unit = unsanitizedUnit === '' ? 'lovelace' : unsanitizedUnit;
+            assets.push({ unit, quantity });
+        });
+    });
+    return assets;
+};
+exports.parsePlutusValueToAssets = parsePlutusValueToAssets;

package/dist/cjs/builder/data/plutus.spec.d.ts

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

package/dist/cjs/builder/data/plutus.spec.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+describe('Plutus data type', () => {
+    describe('Value', () => {
+        test('Simple ADA Value', () => {
+            const val = [{ unit: 'lovelace', quantity: '1000000' }];
+            const datum = (0, _1.value)(val);
+            const nameMap = (0, _1.dict)([
+                [(0, _1.builtinByteString)(''), (0, _1.integer)(1000000)],
+            ]);
+            const valMap = (0, _1.dict)([
+                [(0, _1.builtinByteString)(''), nameMap],
+            ]);
+            expect(JSON.stringify(datum)).toBe(JSON.stringify(valMap));
+        });
+        test('Simple token Value', () => {
+            const val = [
+                {
+                    unit: 'baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc8170074657374696e676e657777616c2e616461',
+                    quantity: '345',
+                },
+            ];
+            const datum = (0, _1.value)(val);
+            const nameMap = (0, _1.dict)([
+                [(0, _1.builtinByteString)('74657374696e676e657777616c2e616461'), (0, _1.integer)(345)],
+            ]);
+            const valMap = (0, _1.dict)([
+                [
+                    (0, _1.builtinByteString)('baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc81700'),
+                    nameMap,
+                ],
+            ]);
+            expect(JSON.stringify(datum)).toBe(JSON.stringify(valMap));
+        });
+        test('Complex Value', () => {
+            const val = [
+                { unit: 'lovelace', quantity: '1000000' },
+                {
+                    unit: 'baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc8170074657374696e676e657777616c2e616461',
+                    quantity: '345',
+                },
+                {
+                    unit: 'baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc817001234',
+                    quantity: '567',
+                },
+            ];
+            const datum = (0, _1.value)(val);
+            const nameMap = (0, _1.dict)([
+                [(0, _1.builtinByteString)('1234'), (0, _1.integer)(567)],
+                [(0, _1.builtinByteString)('74657374696e676e657777616c2e616461'), (0, _1.integer)(345)],
+            ]);
+            const valMap = (0, _1.dict)([
+                [(0, _1.builtinByteString)(''), (0, _1.dict)([[(0, _1.builtinByteString)(''), (0, _1.integer)(1000000)]])],
+                [
+                    (0, _1.builtinByteString)('baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc81700'),
+                    nameMap,
+                ],
+            ]);
+            expect(JSON.stringify(datum)).toBe(JSON.stringify(valMap));
+        });
+    });
+});
+describe('Value', () => {
+    test('Simple ADA Value', () => {
+        const val = [{ unit: 'lovelace', quantity: '1000000' }];
+        const plutusValue = (0, _1.value)(val);
+        const assets = (0, _1.parsePlutusValueToAssets)(plutusValue);
+        expect(JSON.stringify(val)).toBe(JSON.stringify(assets));
+    });
+    test('Simple token Value', () => {
+        const val = [
+            {
+                unit: 'baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc8170074657374696e676e657777616c2e616461',
+                quantity: '345',
+            },
+        ];
+        const plutusValue = (0, _1.value)(val);
+        const assets = (0, _1.parsePlutusValueToAssets)(plutusValue);
+        expect(JSON.stringify(val)).toBe(JSON.stringify(assets));
+    });
+    test('Complex Value', () => {
+        const val = [
+            { unit: 'lovelace', quantity: '1000000' },
+            {
+                unit: 'baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc817001234',
+                quantity: '567',
+            },
+            {
+                unit: 'baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc8170074657374696e676e657777616c2e616461',
+                quantity: '345',
+            },
+        ];
+        const plutusValue = (0, _1.value)(val);
+        const assets = (0, _1.parsePlutusValueToAssets)(plutusValue);
+        expect(JSON.stringify(val)).toBe(JSON.stringify(assets));
+    });
+});

package/dist/cjs/builder/data/time.d.ts

@@ -0,0 +1,11 @@
+import { Network } from '../../types';
+export type Slot = number;
+export type UnixTime = number;
+export type SlotConfig = {
+    zeroTime: UnixTime;
+    zeroSlot: Slot;
+    slotLength: number;
+};
+export declare const SLOT_CONFIG_NETWORK: Record<Network, SlotConfig>;
+export declare const slotToBeginUnixTime: (slot: Slot, slotConfig: SlotConfig) => UnixTime;
+export declare const unixTimeToEnclosingSlot: (unixTime: UnixTime, slotConfig: SlotConfig) => Slot;

package/dist/cjs/builder/data/time.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unixTimeToEnclosingSlot = exports.slotToBeginUnixTime = exports.SLOT_CONFIG_NETWORK = void 0;
+exports.SLOT_CONFIG_NETWORK = {
+    mainnet: { zeroTime: 1596059091000, zeroSlot: 4492800, slotLength: 1000 }, // Starting at Shelley era
+    preview: { zeroTime: 1666656000000, zeroSlot: 0, slotLength: 1000 }, // Starting at Shelley era
+    preprod: {
+        zeroTime: 1654041600000 + 1728000000,
+        zeroSlot: 86400,
+        slotLength: 1000,
+    }, // Starting at Shelley era
+    /** Customizable slot config (Initialized with 0 values). */
+    testnet: { zeroTime: 0, zeroSlot: 0, slotLength: 0 },
+};
+const slotToBeginUnixTime = (slot, slotConfig) => {
+    const msAfterBegin = (slot - slotConfig.zeroSlot) * slotConfig.slotLength;
+    return slotConfig.zeroTime + msAfterBegin;
+};
+exports.slotToBeginUnixTime = slotToBeginUnixTime;
+// slotToBeginUnixTime and slotToEndUnixTime are identical when slotLength == 1. So we don't need to worry about this now.
+// function slotToEndUnixTime(slot: Slot, slotConfig: SlotConfig): UnixTime {
+//   return slotToBeginUnixTime(slot, slotConfig) + (slotConfig.slotLength - 1);
+// }
+const unixTimeToEnclosingSlot = (unixTime, slotConfig) => {
+    const timePassed = unixTime - slotConfig.zeroTime;
+    const slotsPassed = Math.floor(timePassed / slotConfig.slotLength);
+    return slotsPassed + slotConfig.zeroSlot;
+};
+exports.unixTimeToEnclosingSlot = unixTimeToEnclosingSlot;
+// const timeNow = new Date().getTime();
+// console.log(timeNow);
+// console.log(unixTimeToEnclosingSlot(timeNow, SLOT_CONFIG_NETWORK.Preprod));

package/dist/cjs/builder/index.d.ts

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

package/dist/cjs/builder/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./serializer"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./data"), exports);

package/dist/cjs/builder/serializer.d.ts

@@ -0,0 +1,7 @@
+import { MeshTxBuilderBody } from './types';
+import { Protocol } from '../types';
+export declare const emptyTxBuilderBody: () => MeshTxBuilderBody;
+export interface IMeshSerializer {
+    serializeTxBody(txBody: MeshTxBuilderBody, protocolParams: Protocol): string;
+    addSigningKeys(txHex: string, signingKeys: string[]): string;
+}

package/dist/cjs/builder/serializer.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emptyTxBuilderBody = void 0;
+const emptyTxBuilderBody = () => ({
+    inputs: [],
+    outputs: [],
+    extraInputs: [],
+    selectionThreshold: 0,
+    collaterals: [],
+    requiredSignatures: [],
+    referenceInputs: [],
+    mints: [],
+    changeAddress: '',
+    metadata: [],
+    validityRange: {},
+    certificates: [],
+    signingKey: [],
+    withdrawals: [],
+});
+exports.emptyTxBuilderBody = emptyTxBuilderBody;

package/dist/cjs/builder/types.d.ts

@@ -0,0 +1,142 @@
+import { Asset, Budget, Data, LanguageVersion, PlutusScript, UTxO, PoolParams } from '../types';
+export type MeshTxBuilderBody = {
+    inputs: TxIn[];
+    outputs: Output[];
+    collaterals: PubKeyTxIn[];
+    requiredSignatures: string[];
+    referenceInputs: RefTxIn[];
+    withdrawals: Withdrawal[];
+    mints: MintItem[];
+    changeAddress: string;
+    changeDatum?: BuilderData;
+    metadata: Metadata[];
+    validityRange: ValidityRange;
+    certificates: Certificate[];
+    signingKey: string[];
+    extraInputs: UTxO[];
+    selectionThreshold: number;
+};
+export type TxIn = PubKeyTxIn | ScriptTxIn;
+export type PubKeyTxIn = {
+    type: 'PubKey';
+    txIn: TxInParameter;
+};
+export type TxInParameter = {
+    txHash: string;
+    txIndex: number;
+    amount?: Asset[];
+    address?: string;
+};
+export type ScriptTxIn = {
+    type: 'Script';
+    txIn: TxInParameter;
+    scriptTxIn: ScriptTxInParameter;
+};
+export type ScriptTxInParameter = {
+    scriptSource?: ScriptSource;
+    datumSource?: {
+        type: 'Provided';
+        data: BuilderData;
+    } | {
+        type: 'Inline';
+        txHash: string;
+        txIndex: number;
+    };
+    redeemer?: Redeemer;
+};
+export type ScriptSource = {
+    type: 'Provided';
+    script: PlutusScript;
+} | {
+    type: 'Inline';
+    txInInfo: ScriptSourceInfo;
+};
+export type ScriptSourceInfo = {
+    txHash: string;
+    txIndex: number;
+    spendingScriptHash?: string;
+    version: LanguageVersion;
+};
+export type RefTxIn = {
+    txHash: string;
+    txIndex: number;
+};
+export type Output = {
+    address: string;
+    amount: Asset[];
+    datum?: {
+        type: 'Hash' | 'Inline';
+        data: BuilderData;
+    };
+    referenceScript?: PlutusScript;
+};
+export 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 type ValidityRange = {
+    invalidBefore?: number;
+    invalidHereafter?: number;
+};
+export type BuilderData = {
+    type: 'Mesh';
+    content: Data;
+} | {
+    type: 'JSON';
+    content: string;
+} | {
+    type: 'CBOR';
+    content: string;
+};
+export type Redeemer = {
+    data: BuilderData;
+    exUnits: Budget;
+};
+export type Metadata = {
+    tag: string;
+    metadata: object;
+};
+export 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 type Withdrawal = {
+    type: 'PubKeyWithdrawal';
+    address: string;
+    coin: number;
+} | {
+    type: 'PlutusScriptWithdrawal';
+    address: string;
+    coin: number;
+    scriptSource?: ScriptSource;
+    redeemer?: Redeemer;
+};
+export type RequiredWith<T, K extends keyof T> = Required<T> & {
+    [P in K]: Required<T[P]>;
+};

package/dist/cjs/builder/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/cip/CIP25.d.ts

@@ -0,0 +1,19 @@
+export 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 type Files = {
+    files?: [
+        {
+            name: string;
+            src: `${string}://${string}`;
+            mediaType: `${string}/${string}`;
+        }
+    ];
+};

package/dist/cjs/cip/CIP25.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/cip/CIP27.d.ts

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

package/dist/cjs/cip/CIP27.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/cip/CPS9.d.ts

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