@harmoniclabs/buildooor 0.1.0

package/dist/txBuild/ITxBuildProposalProcedure.d.ts

@@ -0,0 +1,11 @@
+import { IProposalProcedure, ProposalProcedure } from "@harmoniclabs/cardano-ledger-ts";
+import { IScriptWithRedeemer, ScriptWithRedeemer } from "./ScriptWithRedeemer.js";
+export interface ITxBuildProposalProcedure {
+    proposalProcedure: IProposalProcedure;
+    script?: IScriptWithRedeemer;
+}
+export interface NormalizedITxBuildProposalProcedure {
+    proposalProcedure: ProposalProcedure;
+    script?: ScriptWithRedeemer;
+}
+export declare function normalizeITxBuildProposalProcedure({ proposalProcedure, script }: ITxBuildProposalProcedure): NormalizedITxBuildProposalProcedure;

package/dist/txBuild/ITxBuildProposalProcedure.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeITxBuildProposalProcedure = void 0;
+var cardano_ledger_ts_1 = require("@harmoniclabs/cardano-ledger-ts");
+var ScriptWithRedeemer_1 = require("./ScriptWithRedeemer.js");
+function normalizeITxBuildProposalProcedure(_a) {
+    var proposalProcedure = _a.proposalProcedure, script = _a.script;
+    return {
+        proposalProcedure: new cardano_ledger_ts_1.ProposalProcedure(proposalProcedure),
+        script: script === undefined ? undefined : (0, ScriptWithRedeemer_1.normalizeIScriptWithRedeemer)(script)
+    };
+}
+exports.normalizeITxBuildProposalProcedure = normalizeITxBuildProposalProcedure;

package/dist/txBuild/ITxBuildVotingProcedure.d.ts

@@ -0,0 +1,13 @@
+import { ITypedVotingProceduresEntry, IVoter, IVotingProceduresEntry } from "@harmoniclabs/cardano-ledger-ts";
+import { IScriptWithRedeemer, ScriptWithRedeemer } from "./ScriptWithRedeemer.js";
+export interface ITxBuildVotingProcedure {
+    votingProcedure: IVotingProceduresEntry;
+    script?: IScriptWithRedeemer;
+}
+export interface NormalizedITxBuildVotingProcedure {
+    votingProcedure: ITypedVotingProceduresEntry;
+    script?: ScriptWithRedeemer;
+}
+export declare function eqIVoter(a: IVoter, b: IVoter): boolean;
+export declare function normalizeITxBuildVotingProcedure({ votingProcedure, script }: ITxBuildVotingProcedure): NormalizedITxBuildVotingProcedure;
+export declare function normalizeVotingProcedureEntry(votingProcedure: IVotingProceduresEntry): ITypedVotingProceduresEntry;

package/dist/txBuild/ITxBuildVotingProcedure.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeVotingProcedureEntry = exports.normalizeITxBuildVotingProcedure = exports.eqIVoter = void 0;
+var cardano_ledger_ts_1 = require("@harmoniclabs/cardano-ledger-ts");
+var ScriptWithRedeemer_1 = require("./ScriptWithRedeemer.js");
+var obj_utils_1 = require("@harmoniclabs/obj-utils");
+var uint8array_utils_1 = require("@harmoniclabs/uint8array-utils");
+function eqIVoter(a, b) {
+    if (!(0, obj_utils_1.isObject)(a))
+        return false;
+    if (!(0, obj_utils_1.isObject)(b))
+        return false;
+    return ((0, cardano_ledger_ts_1.isVoterKind)(a.kind) && a.kind === b.kind &&
+        (0, cardano_ledger_ts_1.canBeHash28)(a.hash) &&
+        (0, cardano_ledger_ts_1.canBeHash28)(b.hash) &&
+        (0, uint8array_utils_1.uint8ArrayEq)(new cardano_ledger_ts_1.Hash28(a.hash).toBuffer(), new cardano_ledger_ts_1.Hash28(b.hash).toBuffer()));
+}
+exports.eqIVoter = eqIVoter;
+function normalizeITxBuildVotingProcedure(_a) {
+    var votingProcedure = _a.votingProcedure, script = _a.script;
+    return {
+        votingProcedure: normalizeVotingProcedureEntry(votingProcedure),
+        script: script === undefined ? undefined : (0, ScriptWithRedeemer_1.normalizeIScriptWithRedeemer)(script)
+    };
+}
+exports.normalizeITxBuildVotingProcedure = normalizeITxBuildVotingProcedure;
+function normalizeVotesEntry(_a) {
+    var govActionId = _a.govActionId, vote = _a.vote;
+    return {
+        govActionId: (0, cardano_ledger_ts_1.forceTxOutRef)(govActionId),
+        vote: new cardano_ledger_ts_1.VotingProcedure(vote)
+    };
+}
+function normalizeVotingProcedureEntry(votingProcedure) {
+    return {
+        voter: new cardano_ledger_ts_1.Voter(votingProcedure.voter),
+        votes: votingProcedure.votes.map(normalizeVotesEntry)
+    };
+}
+exports.normalizeVotingProcedureEntry = normalizeVotingProcedureEntry;

package/dist/txBuild/ITxBuildWithdrawal.d.ts

@@ -0,0 +1,29 @@
+import { Hash28, ITxWithdrawalsEntry, ITxWithdrawalsEntryBigInt, IUTxO, Script, UTxO } from "@harmoniclabs/cardano-ledger-ts";
+import { CanBeData } from "../utils/CanBeData.js";
+import { Data } from "@harmoniclabs/plutus-data";
+export interface ITxBuildWithdrawal {
+    withdrawal: ITxWithdrawalsEntry;
+    script?: {
+        inline: Script;
+        redeemer: CanBeData;
+    } | {
+        ref: IUTxO;
+        redeemer: CanBeData;
+    };
+}
+export interface NormalizedITxBuildWithdrawal extends ITxBuildWithdrawal {
+    withdrawal: ITxWithdrawalsEntryBigInt | {
+        rewardAccount: Hash28;
+        amount: bigint;
+    };
+    script?: {
+        inline: Script;
+        redeemer: Data;
+    } | {
+        ref: UTxO;
+        redeemer: Data;
+    };
+}
+export declare function normalizeITxBuildWithdrawal({ withdrawal, script }: ITxBuildWithdrawal): NormalizedITxBuildWithdrawal;
+/** @deprecated use `normalizeITxBuildWithdrawal` instead */
+export declare function cloneITxBuildWithdrawal(stuff: ITxBuildWithdrawal): ITxBuildWithdrawal;

package/dist/txBuild/ITxBuildWithdrawal.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneITxBuildWithdrawal = exports.normalizeITxBuildWithdrawal = void 0;
+var cardano_ledger_ts_1 = require("@harmoniclabs/cardano-ledger-ts");
+var CanBeData_1 = require("../utils/CanBeData.js");
+var obj_utils_1 = require("@harmoniclabs/obj-utils");
+var plutus_data_1 = require("@harmoniclabs/plutus-data");
+;
+;
+function normalizeITxBuildWithdrawal(_a) {
+    var withdrawal = _a.withdrawal, script = _a.script;
+    script = script === undefined ? undefined : (0, obj_utils_1.hasOwn)(script, "ref") ?
+        {
+            ref: script.ref.clone(),
+            redeemer: (0, plutus_data_1.isData)(script.redeemer) ? (0, plutus_data_1.cloneData)(script.redeemer) : (0, CanBeData_1.forceData)(script.redeemer)
+        } :
+        {
+            inline: script.inline.clone(),
+            redeemer: (0, plutus_data_1.isData)(script.redeemer) ? (0, plutus_data_1.cloneData)(script.redeemer) : (0, CanBeData_1.forceData)(script.redeemer)
+        };
+    return {
+        withdrawal: {
+            rewardAccount: (0, cardano_ledger_ts_1.canBeHash28)(withdrawal.rewardAccount) ? new cardano_ledger_ts_1.Hash28(withdrawal.rewardAccount) : withdrawal.rewardAccount,
+            amount: BigInt(withdrawal.amount)
+        },
+        script: script
+    };
+}
+exports.normalizeITxBuildWithdrawal = normalizeITxBuildWithdrawal;
+/** @deprecated use `normalizeITxBuildWithdrawal` instead */
+function cloneITxBuildWithdrawal(stuff) {
+    return normalizeITxBuildWithdrawal(stuff);
+}
+exports.cloneITxBuildWithdrawal = cloneITxBuildWithdrawal;

package/dist/txBuild/ScriptWithRedeemer.d.ts

@@ -0,0 +1,18 @@
+import { IUTxO, Script, UTxO } from "@harmoniclabs/cardano-ledger-ts";
+import { Data } from "@harmoniclabs/plutus-data";
+import { CanBeData } from "../utils/CanBeData.js";
+export type ScriptWithRedeemer = {
+    inline: Script;
+    redeemer: Data;
+} | {
+    ref: UTxO;
+    redeemer: Data;
+};
+export type IScriptWithRedeemer = {
+    inline: Script;
+    redeemer: CanBeData;
+} | {
+    ref: IUTxO;
+    redeemer: CanBeData;
+};
+export declare function normalizeIScriptWithRedeemer(script: IScriptWithRedeemer): ScriptWithRedeemer;

package/dist/txBuild/ScriptWithRedeemer.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeIScriptWithRedeemer = void 0;
+var cardano_ledger_ts_1 = require("@harmoniclabs/cardano-ledger-ts");
+var CanBeData_1 = require("../utils/CanBeData.js");
+function normalizeIScriptWithRedeemer(script) {
+    var redeemer = (0, CanBeData_1.forceData)(script.redeemer);
+    return (0, cardano_ledger_ts_1.isIUTxO)(script.ref) ? {
+        ref: new cardano_ledger_ts_1.UTxO(script.ref),
+        redeemer: redeemer
+    } : {
+        inline: script.inline.clone(),
+        redeemer: redeemer
+    };
+}
+exports.normalizeIScriptWithRedeemer = normalizeIScriptWithRedeemer;

package/dist/txBuild/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./ITxBuildArgs.js";
+export * from "./ITxBuildCert.js";
+export * from "./ITxBuildInput/ITxBuildInput.js";
+export * from "./ITxBuildMint.js";
+export * from "./ITxBuildOptions.js";
+export * from "./ITxBuildOutput.js";
+export * from "./ITxBuildWithdrawal.js";

package/dist/txBuild/index.js

@@ -0,0 +1,23 @@
+"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("./ITxBuildArgs.js"), exports);
+__exportStar(require("./ITxBuildCert.js"), exports);
+__exportStar(require("./ITxBuildInput/ITxBuildInput.js"), exports);
+__exportStar(require("./ITxBuildMint.js"), exports);
+__exportStar(require("./ITxBuildOptions.js"), exports);
+__exportStar(require("./ITxBuildOutput.js"), exports);
+__exportStar(require("./ITxBuildWithdrawal.js"), exports);

package/dist/utils/CanBeData.d.ts

@@ -0,0 +1,7 @@
+import { CborObj, CborString } from "@harmoniclabs/cbor";
+import { Data } from "@harmoniclabs/plutus-data";
+import { ToUPLC } from "@harmoniclabs/uplc";
+export type CanBeData = Data | ToUPLC | CborObj | CborString | string;
+export declare function cloneCanBeData(stuff: CanBeData): CanBeData;
+export declare function canBeData(something: any): something is CanBeData;
+export declare function forceData(data: CanBeData): Data;

package/dist/utils/CanBeData.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forceData = exports.canBeData = exports.cloneCanBeData = void 0;
+var bytestring_1 = require("@harmoniclabs/bytestring");
+var cbor_1 = require("@harmoniclabs/cbor");
+var obj_utils_1 = require("@harmoniclabs/obj-utils");
+var plutus_data_1 = require("@harmoniclabs/plutus-data");
+var plutus_machine_1 = require("@harmoniclabs/plutus-machine");
+function cloneCanBeData(stuff) {
+    if (typeof stuff === "string")
+        return stuff;
+    if (stuff instanceof cbor_1.CborString ||
+        (0, cbor_1.isCborObj)(stuff) ||
+        (0, plutus_data_1.isData)(stuff))
+        return stuff.clone();
+    var result = plutus_machine_1.Machine.evalSimple(stuff.toUPLC());
+    if (!(result instanceof plutus_machine_1.CEKConst)) {
+        throw new Error("`CanBeData` object that implements `ToUPLC` did not evaluated to a constant");
+    }
+    var value = result.value;
+    if (!(0, plutus_data_1.isData)(value)) {
+        throw new Error("`CanBeData` object that implements `ToUPLC` evaluated to a constant with a non-Data value");
+    }
+    return value;
+}
+exports.cloneCanBeData = cloneCanBeData;
+function canBeData(something) {
+    if (typeof something === "string" &&
+        bytestring_1.ByteString.isValidHexValue(something))
+        return true;
+    if (typeof something !== "object")
+        return false;
+    return ((0, plutus_data_1.isData)(something) ||
+        (typeof something === "object" &&
+            (0, obj_utils_1.hasOwn)(something, "toUPLC") &&
+            typeof something.toUPLC === "function") ||
+        something instanceof cbor_1.CborString ||
+        (0, cbor_1.isCborObj)(something));
+}
+exports.canBeData = canBeData;
+function forceData(data) {
+    if (typeof data === "string")
+        data = (0, plutus_data_1.dataFromCbor)(data);
+    if ((0, plutus_data_1.isData)(data)) {
+        return data;
+    }
+    if (typeof data === "object" &&
+        (0, obj_utils_1.hasOwn)(data, "toUPLC") &&
+        typeof data.toUPLC === "function") {
+        var uplcData = plutus_machine_1.Machine.evalSimple(data.toUPLC());
+        if (!(uplcData instanceof plutus_machine_1.CEKConst)) {
+            throw new Error("term passed as 'datum' field evaluated to an error");
+        }
+        var _data = uplcData.value;
+        if (!(0, plutus_data_1.isData)(_data)) {
+            throw new Error("term of type 'data' evaluation resulted in a value that is not data");
+        }
+        return _data;
+    }
+    if (data instanceof cbor_1.CborString) {
+        return (0, plutus_data_1.dataFromCbor)(data);
+    }
+    if ((0, cbor_1.isCborObj)(data)) {
+        return (0, plutus_data_1.dataFromCborObj)(data);
+    }
+    throw new Error("'forceData' did not match any possible 'CanBeData' value");
+}
+exports.forceData = forceData;

package/dist/utils/Rational.d.ts

@@ -0,0 +1,8 @@
+import { CborObj, CborPositiveRational, CborTag } from "@harmoniclabs/cbor";
+export type Rational = CborPositiveRational | number;
+export declare function canBeCborPostiveRational(cbor: CborObj): cbor is CborPositiveRational | CborTag;
+export declare function isRational(n: any): n is Rational;
+export declare function isRationalOrUndefined(n: any): n is Rational | undefined;
+export declare function cborFromRational(n: Rational): CborPositiveRational;
+export declare function tryCborFromRational(n: any): CborPositiveRational | undefined;
+export declare function numberFromRational(n: Rational): number;

package/dist/utils/Rational.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberFromRational = exports.tryCborFromRational = exports.cborFromRational = exports.isRationalOrUndefined = exports.isRational = exports.canBeCborPostiveRational = void 0;
+var cbor_1 = require("@harmoniclabs/cbor");
+function canBeCborPostiveRational(cbor) {
+    return cbor instanceof cbor_1.CborPositiveRational || (cbor instanceof cbor_1.CborTag &&
+        Number(cbor.tag) === 30 &&
+        cbor.data instanceof cbor_1.CborArray &&
+        cbor.data.array.length === 2 &&
+        cbor.data.array[0] instanceof cbor_1.CborUInt &&
+        cbor.data.array[1] instanceof cbor_1.CborUInt);
+}
+exports.canBeCborPostiveRational = canBeCborPostiveRational;
+function isRational(n) {
+    return typeof n === "number" || n instanceof cbor_1.CborPositiveRational;
+}
+exports.isRational = isRational;
+function isRationalOrUndefined(n) {
+    return typeof n == "undefined" || isRational(n);
+}
+exports.isRationalOrUndefined = isRationalOrUndefined;
+function cborFromRational(n) {
+    return n instanceof cbor_1.CborPositiveRational ? n : cbor_1.CborPositiveRational.fromNumber(n);
+}
+exports.cborFromRational = cborFromRational;
+function tryCborFromRational(n) {
+    return n instanceof cbor_1.CborPositiveRational ? n : (typeof n === "number" ? cbor_1.CborPositiveRational.fromNumber(n) :
+        undefined);
+}
+exports.tryCborFromRational = tryCborFromRational;
+function numberFromRational(n) {
+    return n instanceof cbor_1.CborPositiveRational ? n.toNumber() : Number(n);
+}
+exports.numberFromRational = numberFromRational;

package/dist/utils/assert.d.ts

@@ -0,0 +1 @@
+export declare function assert(condition: boolean, errorMessage: string | Error, addInfos?: any, ...args: any[]): void;

package/dist/utils/assert.js

@@ -0,0 +1,44 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = void 0;
+function assert(condition, errorMessage, addInfos) {
+    var args = [];
+    for (var _i = 3; _i < arguments.length; _i++) {
+        args[_i - 3] = arguments[_i];
+    }
+    if (condition)
+        return;
+    args.length > 0 && console.error.apply(console, __spreadArray([], __read(args), false));
+    addInfos && console.error(addInfos);
+    if (errorMessage instanceof Error) {
+        throw errorMessage;
+    }
+    ;
+    throw new Error(errorMessage);
+}
+exports.assert = assert;

package/dist/utils/ints.d.ts

@@ -0,0 +1,4 @@
+export type CanBeUInteger = bigint | number;
+export declare function canBeUInteger(something: any): something is (number | bigint);
+export declare function forceBigUInt(toForce: CanBeUInteger): bigint;
+export declare function unsafeForceUInt(toForce: CanBeUInteger): number;

package/dist/utils/ints.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsafeForceUInt = exports.forceBigUInt = exports.canBeUInteger = void 0;
+function canBeUInteger(something) {
+    return ((typeof something === "bigint" && something >= BigInt(0)) ||
+        (typeof something === "number" && something === Math.round(Math.abs(something))));
+}
+exports.canBeUInteger = canBeUInteger;
+function forceBigUInt(toForce) {
+    if (!canBeUInteger(toForce)) {
+        // console.error( toForce );
+        throw new Error("trying to convert an integer to an unsigned Integer, the number was negative");
+    }
+    return BigInt(toForce);
+}
+exports.forceBigUInt = forceBigUInt;
+;
+function unsafeForceUInt(toForce) {
+    if (!canBeUInteger(toForce)) {
+        // console.error( toForce );
+        throw new Error("trying to convert an integer to an unsigned Integer, the number was negative");
+    }
+    return Number(toForce);
+}
+exports.unsafeForceUInt = unsafeForceUInt;

package/dist/utils/stringify.d.ts

@@ -0,0 +1,2 @@
+export declare function mkReplacer(replacer?: (key: string, value: any) => any | null, map?: WeakMap<any, string>): (key: string, value: any) => any;
+export declare function stringify(value: any, replacer?: (key: string, value: any) => any | null | (number | string)[], space?: string | number): string;

package/dist/utils/stringify.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = exports.mkReplacer = void 0;
+var obj_utils_1 = require("@harmoniclabs/obj-utils");
+var uint8array_utils_1 = require("@harmoniclabs/uint8array-utils");
+function mkReplacer(replacer, map) {
+    if (map === void 0) { map = new WeakMap(); }
+    if (typeof replacer !== "function")
+        replacer = function (k, v) { return v; };
+    return function (key, value) {
+        value = replacer(key, value);
+        if ((0, obj_utils_1.isObject)(value)) {
+            if (map.has(value)) {
+                return map.get(value);
+            }
+            map.set(value, key);
+            if (typeof value.buffer === "object" && value.buffer instanceof ArrayBuffer) {
+                value = new Uint8Array(value.buffer);
+            }
+            if (value instanceof Uint8Array) {
+                value = (0, uint8array_utils_1.toHex)(value);
+            }
+        }
+        if (typeof value === "bigint") {
+            value = value.toString();
+        }
+        return value;
+    };
+}
+exports.mkReplacer = mkReplacer;
+function stringify(value, replacer, space) {
+    if (space === void 0) { space = 0; }
+    if (replacer) {
+        return JSON.stringify(value, replacer, space);
+    }
+    return JSON.stringify(value, mkReplacer(replacer, new WeakMap()), space);
+}
+exports.stringify = stringify;

package/package.json

@@ -0,0 +1,72 @@
+{
+    "name": "@harmoniclabs/buildooor",
+    "version": "0.1.0",
+    "description": "Cardano transaction builder in typescript",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "browser": {
+        "worker_threads": false
+    },
+    "type": "commonjs",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "test": "jest",
+        "clear-jest": "jest --clearCache",
+        "test-watch": "jest --watchman",
+        "test-coverage": "jest --coverage",
+        "build": "rm -rf ./dist && tsc --project ./tsconfig.json && tsc-alias -p ./tsconfig.json",
+        "build:light": "tsc --project ./tsconfig.json && tsc-alias -p ./tsconfig.json",
+        "buidl": "npm run build",
+        "ci": "npm i && npm run test && npm run build",
+        "start": "npm-run-all --parallel build:watch run:watch"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org"
+    },
+    "keywords": [
+        "cardano",
+        "plutus",
+        "blockchain",
+        "offchain",
+        "ada",
+        "dApp"
+    ],
+    "author": "Michele Nuzzi",
+    "license": "Apache-2.0",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/HarmonicLabs/plu-ts.git"
+    },
+    "bugs": {
+        "url": "https://github.com/HarmonicLabs/plu-ts/issues"
+    },
+    "homepage": "https://github.com/HarmonicLabs/plu-ts#readme",
+    "dependencies": {
+        "@harmoniclabs/bigint-utils": "^1.0.0",
+        "@harmoniclabs/crypto": "^0.2.5",
+        "@harmoniclabs/obj-utils": "^1.0.0",
+        "@harmoniclabs/uint8array-utils": "^1.0.3",
+        "@harmoniclabs/bip32_ed25519": "^0.1.2",
+        "@harmoniclabs/bytestring": "^1.0.0",
+        "@harmoniclabs/cardano-costmodels-ts": "^1.3.0",
+        "@harmoniclabs/cardano-ledger-ts": "^0.3.2",
+        "@harmoniclabs/cbor": "^1.6.0",
+        "@harmoniclabs/pair": "^1.0.0",
+        "@harmoniclabs/plutus-data": "^1.2.4",
+        "@harmoniclabs/plutus-machine": "^2.1.0",
+        "@harmoniclabs/uplc": "^1.4.0"
+    },
+    "devDependencies": {
+        "@babel/preset-env": "^7.18.6",
+        "@babel/preset-typescript": "^7.18.6",
+        "@types/jest": "^28.1.4",
+        "@types/node": "^18.14.6",
+        "jest": "^29.4.3",
+        "jest-environment-jsdom": "^29.4.3",
+        "tsc-alias": "^1.7.1",
+        "typescript": "^4.6.3"
+    },
+    "funding": "https://github.com/sponsors/HarmonicLabs"
+}