@ocap/asset 1.30.2 → 1.30.4

package/esm/index.d.mts

@@ -1,87 +1,7 @@
-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.mjs";
+import { findPrerenderKeys, isValidNotation } from "./utils.mjs";
+import { formatFactoryState } from "./mint/shared.mjs";
+import { mintFromFactory, preMintFromFactory } from "./mint/server.mjs";
+import "./mint.mjs";
+import { isValidFactory, isValidHook } from "./validate.mjs";
+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/esm/index.mjs

@@ -1,250 +1,6 @@
-import { fromPublicKeyHash, toTypeInfo } from "@arcblock/did";
-import { toAssetAddress } from "@arcblock/did-util";
-import { schemas, vValidate } from "@arcblock/validator";
-import { proofTypes, stableStringify, verify } from "@arcblock/vc";
-import { compile, getQuota, validate } from "@ocap/contract";
-import { types } from "@ocap/mcrypto";
-import { toBase58, toBase64 } from "@ocap/util";
-import Debug from "debug";
-import flatten from "flat";
-import isAbsoluteUrl from "is-absolute-url";
-import cloneDeep from "lodash/cloneDeep.js";
-import get from "lodash/get.js";
-import isEmpty from "lodash/isEmpty.js";
-import set from "lodash/set.js";
-import uniq from "lodash/uniq.js";
-import uniqBy from "lodash/uniqBy.js";
-import mustache from "mustache";
+import { findPrerenderKeys, isValidNotation } from "./utils.mjs";
+import { formatFactoryState } from "./mint/shared.mjs";
+import { mintFromFactory, preMintFromFactory } from "./mint/server.mjs";
+import { isValidFactory, isValidHook } from "./validate.mjs";
 
-//#region src/index.ts
-const debug = Debug("@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 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;
-};
-/**
-* 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 });
-	return uniq(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("mintFromFactory.args", JSON.stringify({
-		output,
-		factoryAddress,
-		numMinted,
-		inputs,
-		owner,
-		issuer,
-		data
-	}, null, 2));
-	const asset = JSON.parse(mustache.render(JSON.stringify(output), {
-		input: inputs,
-		data: data?.value || data,
-		ctx: {
-			factory: factoryAddress,
-			id: (numMinted ?? 0) + 1,
-			owner,
-			issuer
-		}
-	}));
-	const address = toAssetAddress(asset);
-	debug("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("preMintFromFactory.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 = cloneDeep(output);
-	const prerenderKeys = findPrerenderKeys(template, "credentialSubject");
-	if (prerenderKeys.length) {
-		extra.issuanceDate = (/* @__PURE__ */ new Date()).toISOString();
-		for (const key of prerenderKeys) {
-			const subjectTemplate = get(template, key);
-			const subjectObject = Array.isArray(subjectTemplate) ? subjectTemplate.map((x) => render(x)) : render(subjectTemplate);
-			set(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];
-			set(template, vcIdPath, vcId);
-			if (!proofTypes[pkType]) throw new Error("Unsupported signer type when create verifiable credential");
-			let vcObj = render(get(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(cloneDeep(output));
-				vcObj = get(asset, vcRootPath);
-				debug("preMintFromFactory.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("preMintFromFactory.result", JSON.stringify(asset, null, 2));
-	}
-	return {
-		address: toAssetAddress(asset),
-		issuer: issuerObject,
-		variables: {
-			...inputs,
-			...extra
-		},
-		asset
-	};
-};
-const formatFactoryState = (state) => {
-	const { address, output, data, numMinted } = state;
-	const outputX = cloneDeep(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
 export { findPrerenderKeys, formatFactoryState, isValidFactory, isValidHook, isValidNotation, mintFromFactory, preMintFromFactory };

package/esm/mint/client.d.mts

@@ -0,0 +1,17 @@
+import { TInputMap, TIssuer, TPickedFactoryState, TPreMintResult } from "../types.mjs";
+import { formatFactoryState } from "./shared.mjs";
+
+//#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/esm/mint/client.mjs

@@ -0,0 +1,32 @@
+import { formatFactoryState, preparePreMintAsset } from "./shared.mjs";
+import { toAssetAddress } from "@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 preparePreMintAsset({
+		factory,
+		inputs,
+		owner,
+		issuer
+	});
+	return {
+		address: toAssetAddress(asset),
+		issuer: issuerObject,
+		variables,
+		asset
+	};
+};
+
+//#endregion
+export { formatFactoryState, preMintFromFactory };

package/esm/mint/server.d.mts

@@ -0,0 +1,34 @@
+import { TInputMap, TIssuer, TIssuerInput, TMintResult, TPickedFactoryState, TPreMintResult } from "../types.mjs";
+import { formatFactoryState } from "./shared.mjs";
+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/esm/mint/server.mjs

@@ -0,0 +1,49 @@
+import { formatFactoryState, preparePreMintAsset, renderMintAsset } from "./shared.mjs";
+import Debug from "debug";
+import { toAssetAddress } from "@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 = Debug("@ocap/asset");
+const mintFromFactory = ({ factory, inputs, owner, issuer, encoding }) => {
+	const asset = renderMintAsset({
+		factory,
+		inputs,
+		owner,
+		issuer
+	});
+	const address = toAssetAddress(asset, encoding);
+	debug("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 preparePreMintAsset({
+		factory,
+		inputs,
+		owner,
+		issuer
+	});
+	return {
+		address: toAssetAddress(asset, encoding),
+		issuer: issuerObject,
+		variables,
+		asset
+	};
+};
+
+//#endregion
+export { formatFactoryState, mintFromFactory, preMintFromFactory };

package/esm/mint/shared.d.mts

@@ -0,0 +1,47 @@
+import { TInputMap, TIssuer, TIssuerInput, TPickedFactoryState } from "../types.mjs";
+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 };