@ocap/asset 1.18.166 → 1.19.0

package/esm/index.d.ts

@@ -0,0 +1,74 @@
+import type { LiteralUnion, PartialDeep } from 'type-fest';
+import type { WalletObject } from '@ocap/wallet';
+import type { TAssetFactoryState, TCreateAssetTx } from '@ocap/types';
+type $TSFixMe = any;
+export type TPickedFactoryState = PartialDeep<TAssetFactoryState>;
+export type TIssuer = {
+    name: string;
+    wallet: WalletObject;
+};
+export type TIssuerInput = {
+    id: string;
+    pk: string;
+    name: string;
+};
+export type THook = {
+    type: LiteralUnion<'contract' | 'url', string>;
+    name: LiteralUnion<'mint' | 'postMint' | 'preMint', string>;
+    hook: string;
+};
+export type TInputMap = {
+    [key: string]: string;
+};
+export type TMintResult = {
+    address: string;
+    asset: TCreateAssetTx;
+};
+export type TPreMintResult = TMintResult & {
+    variables: TInputMap;
+    issuer: TIssuerInput;
+};
+export declare const isValidNotation: (notation: string) => boolean;
+export declare const isValidHook: (hook: THook, quota?: $TSFixMe, throwOnError?: boolean) => boolean;
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export declare const preMintFromFactory: ({ factory, inputs, owner, issuer, }: {
+    factory?: TPickedFactoryState;
+    inputs: TInputMap;
+    owner?: string;
+    issuer?: TIssuer;
+}) => Promise<TPreMintResult>;
+export declare const formatFactoryState: (state: TAssetFactoryState) => TPickedFactoryState;
+export {};

package/esm/index.js

@@ -0,0 +1,247 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import get from 'lodash/get';
+import set from 'lodash/set';
+import uniq from 'lodash/uniq';
+import uniqBy from 'lodash/uniqBy';
+import isEmpty from 'lodash/isEmpty';
+import flatten from 'flat';
+import mustache from 'mustache';
+import isAbsoluteUrl from 'is-absolute-url';
+import cloneDeep from 'lodash/cloneDeep';
+import { toTypeInfo, fromPublicKeyHash } from '@arcblock/did';
+import { verify, stableStringify, proofTypes } from '@arcblock/vc';
+import { schemas } from '@arcblock/validator';
+import { toAssetAddress } from '@arcblock/did-util';
+import { types } from '@ocap/mcrypto';
+import { toBase58, toBase64 } from '@ocap/util';
+import { compile, validate, getQuota } from '@ocap/contract';
+import Debug from 'debug';
+const debug = Debug('@ocap/asset');
+const SUPPORTED_HOOK_NAMES = ['preMint', 'mint', 'postMint'];
+const SUPPORTED_HOOK_TYPES = ['contract', 'url'];
+export const isValidNotation = (notation) => ['ctx', 'data', 'input'].includes(notation.split('.').shift());
+export 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 {
+            const compiled = compile(hook.hook);
+            validate(compiled, 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;
+};
+// @link https://github.com/improbable-eng/ts-protoc-gen
+export const isValidFactory = (props) => {
+    if (!props) {
+        throw new Error('Factory props should not be empty');
+    }
+    const { value, error } = schemas.factorySchema.validate(props);
+    if (error) {
+        throw new Error(`Invalid factory: ${error.details.map((x) => x.message).join(', ')}`);
+    }
+    // input.tokens and input.assets should not be empty
+    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 {
+        // should be a valid mustache template when serialized as json
+        const template = JSON.stringify(value.output, null, 2);
+        const result = mustache.parse(template);
+        if (result.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');
+    }
+    // validate hooks
+    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`);
+        }
+    }
+    // ensure input and hook are zero-sum for factories that consumes token
+    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 {
+            const compiled = compile(mintHook.hook);
+            validate(compiled, 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
+ */
+export 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 uniq(keys);
+};
+/**
+ * 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
+ */
+export 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 + 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
+ */
+export 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');
+    }
+    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 + 1, owner, issuer: issuerObject },
+    }));
+    const template = cloneDeep(output);
+    // prerender credentialSubjects if they exists
+    // then populate their ids
+    const prerenderKeys = findPrerenderKeys(template, 'credentialSubject');
+    if (prerenderKeys.length) {
+        extra.issuanceDate = 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);
+            // calculate credential id from credentialSubject
+            const vcRootPath = key.split('.').slice(0, -1).join('.');
+            const vcIdPath = vcRootPath.split('.').concat(['id']).join('.');
+            const typeInfo = toTypeInfo(issuerObject.id);
+            const vcType = { ...typeInfo, role: types.RoleType.ROLE_VC };
+            const vcId = fromPublicKeyHash(wallet.hash(stableStringify(subjectObject)), vcType);
+            extra.id = vcId;
+            extra.proofType = proofTypes[typeInfo.pk];
+            // technically we do not support nested vc when minting
+            // But it is possible to support multiple credentialSubjects when minting
+            set(template, vcIdPath, vcId);
+            // Generate proof signatures
+            if (!proofTypes[typeInfo.pk]) {
+                throw new Error('Unsupported signer type when create verifiable credential');
+            }
+            let vcObj = render(get(template, vcRootPath));
+            delete vcObj.proof;
+            const vcStr = stableStringify(vcObj);
+            const signature = toBase64(wallet.sign(vcStr));
+            vcObj.proof = {
+                type: proofTypes[typeInfo.pk],
+                created: extra.issuanceDate,
+                proofPurpose: 'assertionMethod',
+                jws: signature,
+            };
+            extra.signature = signature;
+            try {
+                // Simulate minting from start, so that we can ensure the validity of minted asset
+                asset = render(cloneDeep(output));
+                vcObj = get(asset, vcRootPath);
+                debug('preMintFromFactory.result', JSON.stringify(asset, null, 2));
+                // eslint-disable-next-line no-await-in-loop
+                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 {
+        // populate other variables into the whole output
+        asset = render(template);
+        debug('preMintFromFactory.result', JSON.stringify(asset, null, 2));
+    }
+    // calculate address
+    const address = toAssetAddress(asset);
+    // return extra inputs
+    return { address, issuer: issuerObject, variables: { ...inputs, ...extra }, asset };
+};
+export const formatFactoryState = (state) => {
+    const { address, output, data, numMinted } = state;
+    const outputX = cloneDeep(output);
+    outputX.data.value = JSON.parse(outputX.data.value);
+    outputX.data.type = outputX.data.typeUrl;
+    return {
+        address,
+        output: outputX,
+        data: data.value ? JSON.parse(data.value) : {},
+        numMinted,
+    };
+};

package/lib/index.d.ts

@@ -1,30 +1,30 @@
 import type { LiteralUnion, PartialDeep } from 'type-fest';
 import type { WalletObject } from '@ocap/wallet';
 import type { TAssetFactoryState, TCreateAssetTx } from '@ocap/types';
-declare type $TSFixMe = any;
-export declare type TPickedFactoryState = PartialDeep<TAssetFactoryState>;
-export declare type TIssuer = {
+type $TSFixMe = any;
+export type TPickedFactoryState = PartialDeep<TAssetFactoryState>;
+export type TIssuer = {
     name: string;
     wallet: WalletObject;
 };
-export declare type TIssuerInput = {
+export type TIssuerInput = {
     id: string;
     pk: string;
     name: string;
 };
-export declare type THook = {
+export type THook = {
     type: LiteralUnion<'contract' | 'url', string>;
     name: LiteralUnion<'mint' | 'postMint' | 'preMint', string>;
     hook: string;
 };
-export declare type TInputMap = {
+export type TInputMap = {
     [key: string]: string;
 };
-export declare type TMintResult = {
+export type TMintResult = {
     address: string;
     asset: TCreateAssetTx;
 };
-export declare type TPreMintResult = TMintResult & {
+export type TPreMintResult = TMintResult & {
     variables: TInputMap;
     issuer: TIssuerInput;
 };
@@ -69,6 +69,6 @@ export declare const preMintFromFactory: ({ factory, inputs, owner, issuer, }: {
     inputs: TInputMap;
     owner?: string;
     issuer?: TIssuer;
-}) => TPreMintResult;
+}) => Promise<TPreMintResult>;
 export declare const formatFactoryState: (state: TAssetFactoryState) => TPickedFactoryState;
 export {};

package/lib/index.js

@@ -167,7 +167,7 @@ exports.mintFromFactory = mintFromFactory;
  * @param {string} params.owner owner did for the new asset
  * @param {object} params.issuer factory issuer wallet and name
  */
-const preMintFromFactory = ({ factory, inputs, owner, issuer, }) => {
+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');
     }
@@ -225,7 +225,8 @@ const preMintFromFactory = ({ factory, inputs, owner, issuer, }) => {
                 asset = render((0, cloneDeep_1.default)(output));
                 vcObj = (0, get_1.default)(asset, vcRootPath);
                 debug('preMintFromFactory.result', JSON.stringify(asset, null, 2));
-                (0, vc_1.verify)({ vc: vcObj, trustedIssuers: [issuerObject.id], ownerDid: owner, ignoreExpired: true });
+                // eslint-disable-next-line no-await-in-loop
+                await (0, vc_1.verify)({ vc: vcObj, trustedIssuers: [issuerObject.id], ownerDid: owner, ignoreExpired: true });
             }
             catch (err) {
                 console.error(err);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ocap/asset",
   "description": "Utility to work with asset and factory on ArcBlock blockchain",
-  "version": "1.18.166",
+  "version": "1.19.0",
   "author": {
     "name": "wangshijun",
     "email": "shijun@arcblock.io",
@@ -18,15 +18,15 @@
     "wangshijun <shijun@arcblock.io> (https://github.com/wangshijun)"
   ],
   "dependencies": {
-    "@arcblock/did": "1.18.166",
-    "@arcblock/did-util": "1.18.166",
-    "@arcblock/validator": "1.18.166",
-    "@arcblock/vc": "1.18.166",
-    "@ocap/contract": "1.18.166",
-    "@ocap/mcrypto": "1.18.166",
-    "@ocap/types": "1.18.166",
-    "@ocap/util": "1.18.166",
-    "@ocap/wallet": "1.18.166",
+    "@arcblock/did": "1.19.0",
+    "@arcblock/did-util": "1.19.0",
+    "@arcblock/validator": "1.19.0",
+    "@arcblock/vc": "1.19.0",
+    "@ocap/contract": "1.19.0",
+    "@ocap/mcrypto": "1.19.0",
+    "@ocap/types": "1.19.0",
+    "@ocap/util": "1.19.0",
+    "@ocap/wallet": "1.19.0",
     "debug": "^4.3.6",
     "flat": "^5.0.2",
     "is-absolute-url": "^3.0.3",
@@ -35,17 +35,17 @@
     "mustache": "^4.2.0"
   },
   "devDependencies": {
-    "@arcblock/eslint-config-ts": "0.2.3",
-    "@types/flat": "^5.0.2",
-    "@types/jest": "^29.5.12",
-    "@types/mustache": "^4.2.1",
-    "@types/node": "^17.0.45",
-    "eslint": "^8.25.0",
+    "@arcblock/eslint-config-ts": "0.3.3",
+    "@types/flat": "^5.0.5",
+    "@types/jest": "^29.5.13",
+    "@types/mustache": "^4.2.5",
+    "@types/node": "^22.7.5",
+    "eslint": "^8.57.0",
     "jest": "^29.7.0",
-    "prettier": "^2.7.1",
+    "prettier": "^3.3.2",
     "ts-jest": "^29.2.5",
     "type-fest": "^3.1.0",
-    "typescript": "^4.8.4"
+    "typescript": "^5.6.2"
   },
   "homepage": "https://github.com/ArcBlock/blockchain/tree/master/core/asset",
   "keywords": [
@@ -55,10 +55,19 @@
     "nodejs"
   ],
   "license": "Apache-2.0",
-  "main": "lib/index.js",
-  "typings": "lib/index.d.ts",
+  "main": "./lib/index.js",
+  "module": "./lib/index.js",
+  "types": "./esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./lib/index.js",
+      "default": "./esm/index.js"
+    }
+  },
   "files": [
-    "lib"
+    "lib",
+    "esm"
   ],
   "repository": {
     "type": "git",
@@ -69,10 +78,12 @@
     "lint:fix": "npm run lint -- --fix",
     "test": "jest --forceExit --detectOpenHandles",
     "coverage": "npm run test -- --coverage",
-    "clean": "rm -fr lib",
+    "clean": "rm -fr lib esm",
     "prebuild": "npm run clean",
-    "build": "tsc",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build": "npm run build:cjs && npm run build:esm",
     "build:watch": "npm run build -- -w"
   },
-  "gitHead": "58c8356b3b8c238728560e4c3fef6ed1704d3ac4"
+  "gitHead": "1b6fac03988fb18507c8ef4c21de282762005f87"
 }