@ocap/asset 1.30.3 → 1.30.5

package/lib/index.d.cts

@@ -1,87 +1,6 @@
-import { TAssetFactoryState, TCreateAssetTx } from "@ocap/types";
-import { WalletObject } from "@ocap/wallet";
-import { LiteralUnion, PartialDeep } from "type-fest";
-
-//#region src/index.d.ts
-type $TSFixMe = any;
-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;
-};
-declare const isValidNotation: (notation: string) => boolean;
-declare const isValidHook: (hook: THook, quota?: $TSFixMe, throwOnError?: boolean) => boolean;
-declare const isValidFactory: (props: any) => 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: $TSFixMe, keyword: string) => string[];
-/**
- * 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
- */
-declare const mintFromFactory: ({
-  factory,
-  inputs,
-  owner,
-  issuer
-}: {
-  factory: TPickedFactoryState;
-  inputs: TInputMap;
-  owner: string;
-  issuer: TIssuerInput;
-}) => TMintResult;
-/**
- * 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
- */
-declare const preMintFromFactory: ({
-  factory,
-  inputs,
-  owner,
-  issuer
-}: {
-  factory?: TPickedFactoryState;
-  inputs: TInputMap;
-  owner?: string;
-  issuer?: TIssuer;
-}) => Promise<TPreMintResult>;
-declare const formatFactoryState: (state: TAssetFactoryState) => TPickedFactoryState;
-//#endregion
-export { THook, TInputMap, TIssuer, TIssuerInput, TMintResult, TPickedFactoryState, TPreMintResult, findPrerenderKeys, formatFactoryState, isValidFactory, isValidHook, isValidNotation, mintFromFactory, preMintFromFactory };
+import { DecodedAny, THook, TInputMap, TIssuer, TIssuerInput, TMintResult, TPickedFactoryState, TPreMintResult } from "./types.cjs";
+import { findPrerenderKeys, isValidNotation } from "./utils.cjs";
+import { formatFactoryState } from "./mint/shared.cjs";
+import { mintFromFactory, preMintFromFactory } from "./mint/server.cjs";
+import { isValidFactory, isValidHook } from "./validate.cjs";
+export { type DecodedAny, type THook, type TInputMap, type TIssuer, type TIssuerInput, type TMintResult, type TPickedFactoryState, type TPreMintResult, findPrerenderKeys, formatFactoryState, isValidFactory, isValidHook, isValidNotation, mintFromFactory, preMintFromFactory };

package/lib/mint/client.cjs

@@ -0,0 +1,34 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_mint_shared = require('./shared.cjs');
+let _arcblock_did_util_cbor = require("@arcblock/did-util/cbor");
+
+//#region src/mint/client.ts
+/**
+* `@ocap/asset/mint/client` — CBOR-only mint helpers.
+*
+* Pulls `toAssetAddress` from `@arcblock/did-util/cbor` so browser/Worker
+* bundles that stick to CBOR never drag `google-protobuf` or any `*_pb.js`
+* in through the aggregate did-util entry.
+*
+* The client-facing `preMintFromFactory` drops the legacy `encoding`
+* parameter — the subpath IS the encoding selector. Chain-side callers that
+* need dispatch keep using `@ocap/asset/mint/server` or `@ocap/asset`.
+*/
+const preMintFromFactory = async ({ factory, inputs, owner, issuer }) => {
+	const { asset, issuer: issuerObject, variables } = await require_mint_shared.preparePreMintAsset({
+		factory,
+		inputs,
+		owner,
+		issuer
+	});
+	return {
+		address: (0, _arcblock_did_util_cbor.toAssetAddress)(asset),
+		issuer: issuerObject,
+		variables,
+		asset
+	};
+};
+
+//#endregion
+exports.formatFactoryState = require_mint_shared.formatFactoryState;
+exports.preMintFromFactory = preMintFromFactory;

package/lib/mint/client.d.cts

@@ -0,0 +1,17 @@
+import { TInputMap, TIssuer, TPickedFactoryState, TPreMintResult } from "../types.cjs";
+import { formatFactoryState } from "./shared.cjs";
+
+//#region src/mint/client.d.ts
+declare const preMintFromFactory: ({
+  factory,
+  inputs,
+  owner,
+  issuer
+}: {
+  factory?: TPickedFactoryState;
+  inputs: TInputMap;
+  owner?: string;
+  issuer?: TIssuer;
+}) => Promise<TPreMintResult>;
+//#endregion
+export { formatFactoryState, preMintFromFactory };

package/lib/mint/server.cjs

@@ -0,0 +1,53 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_mint_shared = require('./shared.cjs');
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let _arcblock_did_util = require("@arcblock/did-util");
+
+//#region src/mint/server.ts
+/**
+* `@ocap/asset/mint/server` — dual-encoding mint helpers for chain-side use.
+*
+* Pulls `toAssetAddress` from the aggregate `@arcblock/did-util` entry, which
+* dispatches on the explicit `encoding` argument. Server pipes read
+* `context.txEncoding` (filled by the DecodeTx pipe's tag-55799 check) and
+* pass it in.
+*/
+const debug$1 = (0, debug.default)("@ocap/asset");
+const mintFromFactory = ({ factory, inputs, owner, issuer, encoding }) => {
+	const asset = require_mint_shared.renderMintAsset({
+		factory,
+		inputs,
+		owner,
+		issuer
+	});
+	const address = (0, _arcblock_did_util.toAssetAddress)(asset, encoding);
+	debug$1("mintFromFactory.result", JSON.stringify({
+		asset,
+		address,
+		encoding
+	}, null, 2));
+	return {
+		asset,
+		address
+	};
+};
+const preMintFromFactory = async ({ factory, inputs, owner, issuer, encoding }) => {
+	const { asset, issuer: issuerObject, variables } = await require_mint_shared.preparePreMintAsset({
+		factory,
+		inputs,
+		owner,
+		issuer
+	});
+	return {
+		address: (0, _arcblock_did_util.toAssetAddress)(asset, encoding),
+		issuer: issuerObject,
+		variables,
+		asset
+	};
+};
+
+//#endregion
+exports.formatFactoryState = require_mint_shared.formatFactoryState;
+exports.mintFromFactory = mintFromFactory;
+exports.preMintFromFactory = preMintFromFactory;

package/lib/mint/server.d.cts

@@ -0,0 +1,34 @@
+import { TInputMap, TIssuer, TIssuerInput, TMintResult, TPickedFactoryState, TPreMintResult } from "../types.cjs";
+import { formatFactoryState } from "./shared.cjs";
+import { ItxEncoding } from "@arcblock/did-util";
+
+//#region src/mint/server.d.ts
+
+declare const mintFromFactory: ({
+  factory,
+  inputs,
+  owner,
+  issuer,
+  encoding
+}: {
+  factory: TPickedFactoryState;
+  inputs: TInputMap;
+  owner: string;
+  issuer: TIssuerInput;
+  encoding: ItxEncoding;
+}) => TMintResult;
+declare const preMintFromFactory: ({
+  factory,
+  inputs,
+  owner,
+  issuer,
+  encoding
+}: {
+  factory?: TPickedFactoryState;
+  inputs: TInputMap;
+  owner?: string;
+  issuer?: TIssuer;
+  encoding: ItxEncoding;
+}) => Promise<TPreMintResult>;
+//#endregion
+export { formatFactoryState, mintFromFactory, preMintFromFactory };

package/lib/mint/shared.cjs

@@ -0,0 +1,187 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_utils = require('../utils.cjs');
+let _arcblock_did = require("@arcblock/did");
+let _arcblock_vc = require("@arcblock/vc");
+let _ocap_mcrypto = require("@ocap/mcrypto");
+let _ocap_util = require("@ocap/util");
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let mustache = require("mustache");
+mustache = require_rolldown_runtime.__toESM(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$1 = (0, debug.default)("@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$1("renderMintAsset.args", JSON.stringify({
+		output,
+		factoryAddress,
+		numMinted,
+		inputs,
+		owner,
+		issuer,
+		data
+	}, null, 2));
+	return JSON.parse(mustache.default.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$1("preparePreMintAsset.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 = structuredClone(output);
+	const prerenderKeys = require_utils.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 = (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];
+			setPath(template, vcIdPath, vcId);
+			if (!_arcblock_vc.proofTypes[pkType]) throw new Error("Unsupported signer type when create verifiable credential");
+			let vcObj = render(getPath(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(structuredClone(output));
+				vcObj = getPath(asset, vcRootPath);
+				debug$1("preparePreMintAsset.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("preparePreMintAsset.result", JSON.stringify(asset, null, 2));
+	}
+	return {
+		asset,
+		issuer: issuerObject,
+		variables: {
+			...inputs,
+			...extra
+		}
+	};
+};
+
+//#endregion
+exports.formatFactoryState = formatFactoryState;
+exports.preparePreMintAsset = preparePreMintAsset;
+exports.renderMintAsset = renderMintAsset;

package/lib/mint/shared.d.cts

@@ -0,0 +1,47 @@
+import { TInputMap, TIssuer, TIssuerInput, TPickedFactoryState } from "../types.cjs";
+import { TAssetFactoryState, TCreateAssetTx } from "@ocap/types";
+
+//#region src/mint/shared.d.ts
+type $TSFixMe = any;
+declare const formatFactoryState: (state: TAssetFactoryState) => TPickedFactoryState;
+/**
+ * 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`.
+ */
+declare const renderMintAsset: ({
+  factory,
+  inputs,
+  owner,
+  issuer
+}: {
+  factory: TPickedFactoryState;
+  inputs: TInputMap;
+  owner: string;
+  issuer: TIssuerInput;
+}) => TCreateAssetTx;
+/**
+ * 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.
+ */
+declare const preparePreMintAsset: ({
+  factory,
+  inputs,
+  owner,
+  issuer
+}: {
+  factory?: TPickedFactoryState;
+  inputs: TInputMap;
+  owner?: string;
+  issuer?: TIssuer;
+}) => Promise<{
+  asset: $TSFixMe;
+  issuer: TIssuerInput;
+  variables: TInputMap;
+}>;
+//#endregion
+export { formatFactoryState, preparePreMintAsset, renderMintAsset };

package/lib/mint.cjs

@@ -0,0 +1,6 @@
+const require_mint_shared = require('./mint/shared.cjs');
+const require_mint_server = require('./mint/server.cjs');
+
+exports.formatFactoryState = require_mint_shared.formatFactoryState;
+exports.mintFromFactory = require_mint_server.mintFromFactory;
+exports.preMintFromFactory = require_mint_server.preMintFromFactory;

package/lib/mint.d.cts

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

package/lib/types.d.cts

@@ -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/lib/utils.cjs

@@ -0,0 +1,27 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let flat = require("flat");
+flat = require_rolldown_runtime.__toESM(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 = (0, flat.default)(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
+exports.findPrerenderKeys = findPrerenderKeys;
+exports.isValidNotation = isValidNotation;

package/lib/utils.d.cts

@@ -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/lib/validate.cjs

@@ -0,0 +1,71 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_utils = require('./utils.cjs');
+let mustache = require("mustache");
+mustache = require_rolldown_runtime.__toESM(mustache);
+let _arcblock_validator = require("@arcblock/validator");
+let _ocap_contract = require("@ocap/contract");
+let is_absolute_url = require("is-absolute-url");
+is_absolute_url = require_rolldown_runtime.__toESM(is_absolute_url);
+let lodash_isEmpty = require("lodash/isEmpty");
+lodash_isEmpty = require_rolldown_runtime.__toESM(lodash_isEmpty);
+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);
+
+//#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 (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]) => require_utils.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;
+};
+
+//#endregion
+exports.isValidFactory = isValidFactory;
+exports.isValidHook = isValidHook;

package/lib/validate.d.cts

@@ -0,0 +1,8 @@
+import { THook } from "./types.cjs";
+
+//#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 };