@ocap/asset 1.30.2 → 1.30.4

package/esm/mint/shared.mjs

@@ -0,0 +1,182 @@
+import { findPrerenderKeys } from "../utils.mjs";
+import { fromPublicKeyHash, toTypeInfo } from "@arcblock/did";
+import { proofTypes, stableStringify, verify } from "@arcblock/vc";
+import { types } from "@ocap/mcrypto";
+import { toBase58, toBase64 } from "@ocap/util";
+import Debug from "debug";
+import mustache from "mustache";
+
+//#region src/mint/shared.ts
+/**
+* Encoding-agnostic mint helpers shared by `./client` (CBOR-only) and
+* `./server` (dispatching) entries.
+*
+* Everything here is pure logic — no `@arcblock/did-util` import. The final
+* `toAssetAddress(asset, encoding?)` call is deferred to each entry so
+* browser/Worker bundles that stick to CBOR never drag the protobuf runtime
+* in via the aggregate did-util entry.
+*/
+const getPath = (obj, path) => {
+	if (obj == null) return void 0;
+	return path.split(".").reduce((acc, k) => acc == null ? acc : acc[k], obj);
+};
+const setPath = (obj, path, value) => {
+	if (obj == null) return obj;
+	const parts = path.split(".");
+	let current = obj;
+	for (let i = 0; i < parts.length - 1; i++) {
+		const part = parts[i];
+		if (current[part] == null || typeof current[part] !== "object") current[part] = {};
+		current = current[part];
+	}
+	current[parts[parts.length - 1]] = value;
+	return obj;
+};
+const debug = Debug("@ocap/asset");
+const formatFactoryState = (state) => {
+	const { address, output, data, numMinted } = state;
+	const outputX = structuredClone(output);
+	const outputData = outputX.data;
+	outputData.value = JSON.parse(outputData.value);
+	outputData.type = outputData.typeUrl;
+	const stateData = data;
+	return {
+		address,
+		output: outputX,
+		data: stateData?.value ? JSON.parse(stateData.value) : {},
+		numMinted
+	};
+};
+/**
+* Render the asset payload for `mintFromFactory`. Pure sync template expand —
+* no VC signing, no async calls. Callers compute the address via the
+* encoding-appropriate `toAssetAddress`.
+*/
+const renderMintAsset = ({ factory, inputs, owner, issuer }) => {
+	const { output, address: factoryAddress, numMinted, data } = factory;
+	debug("renderMintAsset.args", JSON.stringify({
+		output,
+		factoryAddress,
+		numMinted,
+		inputs,
+		owner,
+		issuer,
+		data
+	}, null, 2));
+	return JSON.parse(mustache.render(JSON.stringify(output), {
+		input: inputs,
+		data: data?.value || data,
+		ctx: {
+			factory: factoryAddress,
+			id: (numMinted ?? 0) + 1,
+			owner,
+			issuer
+		}
+	}));
+};
+/**
+* Build the rendered asset + resolved issuer + resolved variables for a
+* pre-mint flow. Handles credentialSubject prerender + VC proof signing.
+*
+* Callers compute the final address via the encoding-appropriate
+* `toAssetAddress`. Matches the original `preMintFromFactory` behavior one
+* for one — the only factored-out line is the final address derivation.
+*/
+const preparePreMintAsset = async ({ factory, inputs, owner, issuer }) => {
+	if (Object.keys(inputs).some((x) => typeof inputs[x] !== "string")) throw new Error("Failed to mint asset from factory: input values must be strings");
+	if (!factory) throw new Error("Failed to mint asset from factory: factory is required");
+	if (!issuer) throw new Error("Failed to mint asset from factory: issuer is required");
+	let asset = null;
+	const { output, numMinted, address: factoryAddress, data } = factory;
+	const { wallet, name } = issuer;
+	debug("preparePreMintAsset.args", JSON.stringify({
+		output,
+		factoryAddress,
+		numMinted,
+		inputs,
+		owner,
+		issuer,
+		data
+	}, null, 2));
+	const extra = {};
+	const issuerObject = {
+		id: wallet.address,
+		pk: toBase58(wallet.publicKey),
+		name
+	};
+	const render = (templateObject) => JSON.parse(mustache.render(JSON.stringify(templateObject), {
+		input: {
+			...inputs,
+			...extra
+		},
+		data: data?.value || data,
+		ctx: {
+			factory: factoryAddress,
+			id: (numMinted ?? 0) + 1,
+			owner,
+			issuer: issuerObject
+		}
+	}));
+	const template = structuredClone(output);
+	const prerenderKeys = findPrerenderKeys(template, "credentialSubject");
+	if (prerenderKeys.length) {
+		extra.issuanceDate = (/* @__PURE__ */ new Date()).toISOString();
+		for (const key of prerenderKeys) {
+			const subjectTemplate = getPath(template, key);
+			const subjectObject = Array.isArray(subjectTemplate) ? subjectTemplate.map((x) => render(x)) : render(subjectTemplate);
+			setPath(template, key, subjectObject);
+			const vcRootPath = key.split(".").slice(0, -1).join(".");
+			const vcIdPath = vcRootPath.split(".").concat(["id"]).join(".");
+			const typeInfo = toTypeInfo(issuerObject.id);
+			const pkType = typeInfo.pk;
+			const vcType = {
+				...typeInfo,
+				role: types.RoleType.ROLE_VC
+			};
+			const vcId = fromPublicKeyHash(wallet.hash(stableStringify(subjectObject)), vcType);
+			extra.id = vcId;
+			extra.proofType = proofTypes[pkType];
+			setPath(template, vcIdPath, vcId);
+			if (!proofTypes[pkType]) throw new Error("Unsupported signer type when create verifiable credential");
+			let vcObj = render(getPath(template, vcRootPath));
+			vcObj.proof = void 0;
+			const vcStr = stableStringify(vcObj);
+			const signature = toBase64(await wallet.sign(vcStr));
+			vcObj.proof = {
+				type: proofTypes[pkType],
+				created: extra.issuanceDate,
+				proofPurpose: "assertionMethod",
+				jws: signature
+			};
+			extra.signature = signature;
+			try {
+				asset = render(structuredClone(output));
+				vcObj = getPath(asset, vcRootPath);
+				debug("preparePreMintAsset.result", JSON.stringify(asset, null, 2));
+				await verify({
+					vc: vcObj,
+					trustedIssuers: [issuerObject.id],
+					ownerDid: owner,
+					ignoreExpired: true
+				});
+			} catch (err) {
+				console.error(err);
+				throw new Error("Failed to mint asset from factory: invalid verifiable credential minted");
+			}
+		}
+	} else {
+		asset = render(template);
+		debug("preparePreMintAsset.result", JSON.stringify(asset, null, 2));
+	}
+	return {
+		asset,
+		issuer: issuerObject,
+		variables: {
+			...inputs,
+			...extra
+		}
+	};
+};
+
+//#endregion
+export { formatFactoryState, preparePreMintAsset, renderMintAsset };

package/esm/mint.d.mts

@@ -0,0 +1,3 @@
+import { formatFactoryState } from "./mint/shared.mjs";
+import { mintFromFactory, preMintFromFactory } from "./mint/server.mjs";
+export { formatFactoryState, mintFromFactory, preMintFromFactory };

package/esm/mint.mjs

@@ -0,0 +1,4 @@
+import { formatFactoryState } from "./mint/shared.mjs";
+import { mintFromFactory, preMintFromFactory } from "./mint/server.mjs";
+
+export { formatFactoryState, mintFromFactory, preMintFromFactory };

package/esm/types.d.mts

@@ -0,0 +1,39 @@
+import { TAssetFactoryState, TCreateAssetTx } from "@ocap/types";
+import { WalletObject } from "@ocap/wallet";
+import { LiteralUnion, PartialDeep } from "type-fest";
+
+//#region src/types.d.ts
+type TPickedFactoryState = PartialDeep<TAssetFactoryState>;
+type TIssuer = {
+  name: string;
+  wallet: WalletObject;
+};
+type TIssuerInput = {
+  id: string;
+  pk: string;
+  name: string;
+};
+type THook = {
+  type: LiteralUnion<'contract' | 'url', string>;
+  name: LiteralUnion<'mint' | 'postMint' | 'preMint', string>;
+  hook: string;
+};
+type TInputMap = {
+  [key: string]: string;
+};
+type TMintResult = {
+  address: string;
+  asset: TCreateAssetTx;
+};
+type TPreMintResult = TMintResult & {
+  variables: TInputMap;
+  issuer: TIssuerInput;
+};
+/** Decoded Any type from protobuf with value property */
+interface DecodedAny {
+  typeUrl?: string;
+  type?: string;
+  value?: string;
+}
+//#endregion
+export { DecodedAny, THook, TInputMap, TIssuer, TIssuerInput, TMintResult, TPickedFactoryState, TPreMintResult };

package/esm/types.mjs

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

package/esm/utils.d.mts

@@ -0,0 +1,13 @@
+//#region src/utils.d.ts
+declare const isValidNotation: (notation: string) => boolean;
+/**
+ * Find credentialSubject path in the object
+ * Because they need prerender
+ *
+ * @param {object} obj
+ * @param {string} keyword
+ * @return {string} list of keys
+ */
+declare const findPrerenderKeys: (obj: any, keyword: string) => string[];
+//#endregion
+export { findPrerenderKeys, isValidNotation };

package/esm/utils.mjs

@@ -0,0 +1,24 @@
+import flatten from "flat";
+
+//#region src/utils.ts
+const isValidNotation = (notation) => [
+	"ctx",
+	"data",
+	"input"
+].includes(notation.split(".").shift() ?? "");
+/**
+* Find credentialSubject path in the object
+* Because they need prerender
+*
+* @param {object} obj
+* @param {string} keyword
+* @return {string} list of keys
+*/
+const findPrerenderKeys = (obj, keyword) => {
+	const flatObj = flatten(obj, { safe: true });
+	const keys = Object.keys(flatObj).map((x) => x.split(".")).filter((x) => x.includes(keyword)).map((x) => x.slice(0, x.lastIndexOf(keyword) + 1)).sort((a, b) => b.length - a.length).map((x) => x.join("."));
+	return Array.from(new Set(keys));
+};
+
+//#endregion
+export { findPrerenderKeys, isValidNotation };

package/esm/validate.d.mts

@@ -0,0 +1,8 @@
+import { THook } from "./types.mjs";
+
+//#region src/validate.d.ts
+type $TSFixMe = any;
+declare const isValidHook: (hook: THook, quota?: $TSFixMe, throwOnError?: boolean) => boolean;
+declare const isValidFactory: (props: any) => boolean;
+//#endregion
+export { isValidFactory, isValidHook };

package/esm/validate.mjs

@@ -0,0 +1,64 @@
+import { isValidNotation } from "./utils.mjs";
+import mustache from "mustache";
+import { schemas, vValidate } from "@arcblock/validator";
+import { compile, getQuota, validate } from "@ocap/contract";
+import isAbsoluteUrl from "is-absolute-url";
+import isEmpty from "lodash/isEmpty.js";
+import uniq from "lodash/uniq.js";
+import uniqBy from "lodash/uniqBy.js";
+
+//#region src/validate.ts
+const SUPPORTED_HOOK_NAMES = [
+	"preMint",
+	"mint",
+	"postMint"
+];
+const SUPPORTED_HOOK_TYPES = ["contract", "url"];
+const isValidHook = (hook, quota, throwOnError = false) => {
+	if (SUPPORTED_HOOK_TYPES.includes(hook.type) === false) return false;
+	if (SUPPORTED_HOOK_NAMES.includes(hook.name) === false) return false;
+	if (hook.type === "url") return isAbsoluteUrl(hook.hook);
+	if (hook.type === "contract") try {
+		validate(compile(hook.hook), quota);
+		return true;
+	} catch (err) {
+		if (process.env.NODE_ENV !== "test") console.error("invalid contract hook", err.message);
+		if (throwOnError) throw new Error(`Factory hook ${hook.name} is invalid: ${err.message}`);
+		return false;
+	}
+	return false;
+};
+const isValidFactory = (props) => {
+	if (!props) throw new Error("Factory props should not be empty");
+	const { value, error } = vValidate(schemas.factorySchema, props);
+	if (error) throw new Error(`Invalid factory: ${error.details.map((x) => x.message).join(", ")}`);
+	if (["tokens", "assets"].every((x) => isEmpty(value.input[x])) && value.input.value <= 0) throw new Error("Factory input should contain at least one token or asset");
+	if (uniqBy(value.input.tokens, "address").length !== value.input.tokens.length) throw new Error("Factory token input should not contains duplicate address");
+	if (uniq(value.input.assets).length !== value.input.assets.length) throw new Error("Factory asset input should not contains duplicate address");
+	try {
+		const template = JSON.stringify(value.output, null, 2);
+		if (mustache.parse(template).filter(([type]) => type === "name").some(([, notation]) => isValidNotation(notation) === false)) throw new Error("Invalid tags found in the output template");
+	} catch (_err) {
+		throw new Error("Factory output should be a valid mustache template when serialized as json");
+	}
+	const quota = getQuota(value.input);
+	if (Array.isArray(value.hooks)) {
+		const invalidHook = value.hooks.find((x) => isValidHook(x, quota, true) === false);
+		if (invalidHook) throw new Error(`Factory hook ${invalidHook.name} is invalid`);
+	}
+	if (value.settlement === "instant") {
+		if (quota.value <= 0 && Object.keys(quota.tokens).every((x) => quota[x] <= 0)) return true;
+		if (isEmpty(value.hooks)) throw new Error("Factory hooks should not be empty for instant settlement");
+		const mintHook = value.hooks.find((x) => x.name === "mint");
+		if (!mintHook) throw new Error("Factory hook mint should not be empty for instant settlement that consumes token");
+		try {
+			validate(compile(mintHook.hook), quota, true);
+		} catch (err) {
+			throw new Error(`Factory hook mint is invalid: ${err.message}`);
+		}
+	}
+	return true;
+};
+
+//#endregion
+export { isValidFactory, isValidHook };

package/lib/index.cjs

@@ -1,267 +1,12 @@
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
-let _arcblock_did = require("@arcblock/did");
-let _arcblock_did_util = require("@arcblock/did-util");
-let _arcblock_validator = require("@arcblock/validator");
-let _arcblock_vc = require("@arcblock/vc");
-let _ocap_contract = require("@ocap/contract");
-let _ocap_mcrypto = require("@ocap/mcrypto");
-let _ocap_util = require("@ocap/util");
-let debug = require("debug");
-debug = require_rolldown_runtime.__toESM(debug);
-let flat = require("flat");
-flat = require_rolldown_runtime.__toESM(flat);
-let is_absolute_url = require("is-absolute-url");
-is_absolute_url = require_rolldown_runtime.__toESM(is_absolute_url);
-let lodash_cloneDeep = require("lodash/cloneDeep");
-lodash_cloneDeep = require_rolldown_runtime.__toESM(lodash_cloneDeep);
-let lodash_get = require("lodash/get");
-lodash_get = require_rolldown_runtime.__toESM(lodash_get);
-let lodash_isEmpty = require("lodash/isEmpty");
-lodash_isEmpty = require_rolldown_runtime.__toESM(lodash_isEmpty);
-let lodash_set = require("lodash/set");
-lodash_set = require_rolldown_runtime.__toESM(lodash_set);
-let lodash_uniq = require("lodash/uniq");
-lodash_uniq = require_rolldown_runtime.__toESM(lodash_uniq);
-let lodash_uniqBy = require("lodash/uniqBy");
-lodash_uniqBy = require_rolldown_runtime.__toESM(lodash_uniqBy);
-let mustache = require("mustache");
-mustache = require_rolldown_runtime.__toESM(mustache);
+const require_utils = require('./utils.cjs');
+const require_mint_shared = require('./mint/shared.cjs');
+const require_mint_server = require('./mint/server.cjs');
+const require_validate = require('./validate.cjs');
 
-//#region src/index.ts
-const debug$1 = (0, debug.default)("@ocap/asset");
-const SUPPORTED_HOOK_NAMES = [
-	"preMint",
-	"mint",
-	"postMint"
-];
-const SUPPORTED_HOOK_TYPES = ["contract", "url"];
-const isValidNotation = (notation) => [
-	"ctx",
-	"data",
-	"input"
-].includes(notation.split(".").shift() ?? "");
-const isValidHook = (hook, quota, throwOnError = false) => {
-	if (SUPPORTED_HOOK_TYPES.includes(hook.type) === false) return false;
-	if (SUPPORTED_HOOK_NAMES.includes(hook.name) === false) return false;
-	if (hook.type === "url") return (0, is_absolute_url.default)(hook.hook);
-	if (hook.type === "contract") try {
-		(0, _ocap_contract.validate)((0, _ocap_contract.compile)(hook.hook), quota);
-		return true;
-	} catch (err) {
-		if (process.env.NODE_ENV !== "test") console.error("invalid contract hook", err.message);
-		if (throwOnError) throw new Error(`Factory hook ${hook.name} is invalid: ${err.message}`);
-		return false;
-	}
-	return false;
-};
-const isValidFactory = (props) => {
-	if (!props) throw new Error("Factory props should not be empty");
-	const { value, error } = (0, _arcblock_validator.vValidate)(_arcblock_validator.schemas.factorySchema, props);
-	if (error) throw new Error(`Invalid factory: ${error.details.map((x) => x.message).join(", ")}`);
-	if (["tokens", "assets"].every((x) => (0, lodash_isEmpty.default)(value.input[x])) && value.input.value <= 0) throw new Error("Factory input should contain at least one token or asset");
-	if ((0, lodash_uniqBy.default)(value.input.tokens, "address").length !== value.input.tokens.length) throw new Error("Factory token input should not contains duplicate address");
-	if ((0, lodash_uniq.default)(value.input.assets).length !== value.input.assets.length) throw new Error("Factory asset input should not contains duplicate address");
-	try {
-		const template = JSON.stringify(value.output, null, 2);
-		if (mustache.default.parse(template).filter(([type]) => type === "name").some(([, notation]) => isValidNotation(notation) === false)) throw new Error("Invalid tags found in the output template");
-	} catch (_err) {
-		throw new Error("Factory output should be a valid mustache template when serialized as json");
-	}
-	const quota = (0, _ocap_contract.getQuota)(value.input);
-	if (Array.isArray(value.hooks)) {
-		const invalidHook = value.hooks.find((x) => isValidHook(x, quota, true) === false);
-		if (invalidHook) throw new Error(`Factory hook ${invalidHook.name} is invalid`);
-	}
-	if (value.settlement === "instant") {
-		if (quota.value <= 0 && Object.keys(quota.tokens).every((x) => quota[x] <= 0)) return true;
-		if ((0, lodash_isEmpty.default)(value.hooks)) throw new Error("Factory hooks should not be empty for instant settlement");
-		const mintHook = value.hooks.find((x) => x.name === "mint");
-		if (!mintHook) throw new Error("Factory hook mint should not be empty for instant settlement that consumes token");
-		try {
-			(0, _ocap_contract.validate)((0, _ocap_contract.compile)(mintHook.hook), quota, true);
-		} catch (err) {
-			throw new Error(`Factory hook mint is invalid: ${err.message}`);
-		}
-	}
-	return true;
-};
-/**
-* Find credentialSubject path in the object
-* Because they need prerender
-*
-* @param {object} obj
-* @param {string} keyword
-* @return {string} list of keys
-*/
-const findPrerenderKeys = (obj, keyword) => {
-	const flatObj = (0, flat.default)(obj, { safe: true });
-	return (0, lodash_uniq.default)(Object.keys(flatObj).map((x) => x.split(".")).filter((x) => x.includes(keyword)).map((x) => x.slice(0, x.lastIndexOf(keyword) + 1)).sort((a, b) => b.length - a.length).map((x) => x.join(".")));
-};
-/**
-* Mint from an asset factory, used on server side
-*
-* @param {object} params { factory, inputs, issuer }
-* @param {object} params.factory factory object
-* @param {object} params.inputs factory input variables
-* @param {string} params.owner owner did for the new asset
-* @param {object} params.issuer issuer object
-*/
-const mintFromFactory = ({ factory, inputs, owner, issuer }) => {
-	const { output, address: factoryAddress, numMinted, data } = factory;
-	debug$1("mintFromFactory.args", JSON.stringify({
-		output,
-		factoryAddress,
-		numMinted,
-		inputs,
-		owner,
-		issuer,
-		data
-	}, null, 2));
-	const asset = JSON.parse(mustache.default.render(JSON.stringify(output), {
-		input: inputs,
-		data: data?.value || data,
-		ctx: {
-			factory: factoryAddress,
-			id: (numMinted ?? 0) + 1,
-			owner,
-			issuer
-		}
-	}));
-	const address = (0, _arcblock_did_util.toAssetAddress)(asset);
-	debug$1("mintFromFactory.result", JSON.stringify({
-		asset,
-		address
-	}, null, 2));
-	return {
-		asset,
-		address
-	};
-};
-/**
-* Simulate minting from an asset factory, used for client side
-*
-* @param {object} params { factory, inputs, issuer }
-* @param {object} params.factory factory object
-* @param {object} params.inputs factory input variables
-* @param {string} params.owner owner did for the new asset
-* @param {object} params.issuer factory issuer wallet and name
-*/
-const preMintFromFactory = async ({ factory, inputs, owner, issuer }) => {
-	if (Object.keys(inputs).some((x) => typeof inputs[x] !== "string")) throw new Error("Failed to mint asset from factory: input values must be strings");
-	if (!factory) throw new Error("Failed to mint asset from factory: factory is required");
-	if (!issuer) throw new Error("Failed to mint asset from factory: issuer is required");
-	let asset = null;
-	const { output, numMinted, address: factoryAddress, data } = factory;
-	const { wallet, name } = issuer;
-	debug$1("preMintFromFactory.args", JSON.stringify({
-		output,
-		factoryAddress,
-		numMinted,
-		inputs,
-		owner,
-		issuer,
-		data
-	}, null, 2));
-	const extra = {};
-	const issuerObject = {
-		id: wallet.address,
-		pk: (0, _ocap_util.toBase58)(wallet.publicKey),
-		name
-	};
-	const render = (templateObject) => JSON.parse(mustache.default.render(JSON.stringify(templateObject), {
-		input: {
-			...inputs,
-			...extra
-		},
-		data: data?.value || data,
-		ctx: {
-			factory: factoryAddress,
-			id: (numMinted ?? 0) + 1,
-			owner,
-			issuer: issuerObject
-		}
-	}));
-	const template = (0, lodash_cloneDeep.default)(output);
-	const prerenderKeys = findPrerenderKeys(template, "credentialSubject");
-	if (prerenderKeys.length) {
-		extra.issuanceDate = (/* @__PURE__ */ new Date()).toISOString();
-		for (const key of prerenderKeys) {
-			const subjectTemplate = (0, lodash_get.default)(template, key);
-			const subjectObject = Array.isArray(subjectTemplate) ? subjectTemplate.map((x) => render(x)) : render(subjectTemplate);
-			(0, lodash_set.default)(template, key, subjectObject);
-			const vcRootPath = key.split(".").slice(0, -1).join(".");
-			const vcIdPath = vcRootPath.split(".").concat(["id"]).join(".");
-			const typeInfo = (0, _arcblock_did.toTypeInfo)(issuerObject.id);
-			const pkType = typeInfo.pk;
-			const vcType = {
-				...typeInfo,
-				role: _ocap_mcrypto.types.RoleType.ROLE_VC
-			};
-			const vcId = (0, _arcblock_did.fromPublicKeyHash)(wallet.hash((0, _arcblock_vc.stableStringify)(subjectObject)), vcType);
-			extra.id = vcId;
-			extra.proofType = _arcblock_vc.proofTypes[pkType];
-			(0, lodash_set.default)(template, vcIdPath, vcId);
-			if (!_arcblock_vc.proofTypes[pkType]) throw new Error("Unsupported signer type when create verifiable credential");
-			let vcObj = render((0, lodash_get.default)(template, vcRootPath));
-			vcObj.proof = void 0;
-			const vcStr = (0, _arcblock_vc.stableStringify)(vcObj);
-			const signature = (0, _ocap_util.toBase64)(await wallet.sign(vcStr));
-			vcObj.proof = {
-				type: _arcblock_vc.proofTypes[pkType],
-				created: extra.issuanceDate,
-				proofPurpose: "assertionMethod",
-				jws: signature
-			};
-			extra.signature = signature;
-			try {
-				asset = render((0, lodash_cloneDeep.default)(output));
-				vcObj = (0, lodash_get.default)(asset, vcRootPath);
-				debug$1("preMintFromFactory.result", JSON.stringify(asset, null, 2));
-				await (0, _arcblock_vc.verify)({
-					vc: vcObj,
-					trustedIssuers: [issuerObject.id],
-					ownerDid: owner,
-					ignoreExpired: true
-				});
-			} catch (err) {
-				console.error(err);
-				throw new Error("Failed to mint asset from factory: invalid verifiable credential minted");
-			}
-		}
-	} else {
-		asset = render(template);
-		debug$1("preMintFromFactory.result", JSON.stringify(asset, null, 2));
-	}
-	return {
-		address: (0, _arcblock_did_util.toAssetAddress)(asset),
-		issuer: issuerObject,
-		variables: {
-			...inputs,
-			...extra
-		},
-		asset
-	};
-};
-const formatFactoryState = (state) => {
-	const { address, output, data, numMinted } = state;
-	const outputX = (0, lodash_cloneDeep.default)(output);
-	const outputData = outputX.data;
-	outputData.value = JSON.parse(outputData.value);
-	outputData.type = outputData.typeUrl;
-	const stateData = data;
-	return {
-		address,
-		output: outputX,
-		data: stateData?.value ? JSON.parse(stateData.value) : {},
-		numMinted
-	};
-};
-
-//#endregion
-exports.findPrerenderKeys = findPrerenderKeys;
-exports.formatFactoryState = formatFactoryState;
-exports.isValidFactory = isValidFactory;
-exports.isValidHook = isValidHook;
-exports.isValidNotation = isValidNotation;
-exports.mintFromFactory = mintFromFactory;
-exports.preMintFromFactory = preMintFromFactory;
+exports.findPrerenderKeys = require_utils.findPrerenderKeys;
+exports.formatFactoryState = require_mint_shared.formatFactoryState;
+exports.isValidFactory = require_validate.isValidFactory;
+exports.isValidHook = require_validate.isValidHook;
+exports.isValidNotation = require_utils.isValidNotation;
+exports.mintFromFactory = require_mint_server.mintFromFactory;
+exports.preMintFromFactory = require_mint_server.preMintFromFactory;