@ocap/asset 1.6.10

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2018-2019 ArcBlock
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,29 @@
+![nft](https://www.arcblock.io/.netlify/functions/badge/?text=Asset+Factory)
+
+[![styled with prettier](https://img.shields.io/badge/styled_with-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
+[![docs](https://img.shields.io/badge/powered%20by-arcblock-green.svg)](https://docs.arcblock.io)
+[![Gitter](https://badges.gitter.im/ArcBlock/community.svg)](https://gitter.im/ArcBlock/community?utm_source=badge\&utm_medium=badge\&utm_campaign=pr-badge)
+
+> Utility to create standard assets that can be rendered in [DID Wallet](https://www.abtwallet.io)
+
+
+## Table of Contents
+
+* [Install](#install)
+* [Usage](#usage)
+
+
+## Install
+
+```sh
+npm install @ocap/asset
+// or
+yarn add @ocap/asset
+```
+
+
+## Usage
+
+```js
+// TODO
+```

package/lib/index.d.ts

@@ -0,0 +1,40 @@
+// Generate by [js2dts@0.3.3](https://github.com/whxaxes/js2dts#readme)
+
+declare const _Lib: _Lib.T107;
+declare namespace _Lib {
+  export interface T101 {
+    factory: any;
+    inputs: any;
+    owner: string;
+    issuer: any;
+  }
+  export interface T102 {
+    asset: any;
+    address: string;
+  }
+  export interface T103 {
+    address: any;
+    output: any;
+    data: any;
+  }
+  export interface T105 {
+    id: any;
+    pk: string;
+    name: any;
+  }
+  export interface T106 {
+    address: string;
+    issuer: _Lib.T105;
+    variables: any;
+    asset: any;
+  }
+  export interface T107 {
+    isValidFactory: (props: any) => boolean;
+    isValidHook: (hook: any, quota: any, throwOnError?: boolean) => boolean;
+    findPrerenderKeys: (obj: any, keyword: string) => string;
+    mintFromFactory: (T100: _Lib.T101) => _Lib.T102;
+    formatFactoryState: (state: any) => _Lib.T103;
+    preMintFromFactory: (T104: _Lib.T101) => _Lib.T106;
+  }
+}
+export = _Lib;

package/lib/index.js

@@ -0,0 +1,318 @@
+/* eslint-disable no-restricted-syntax */
+const get = require('lodash/get');
+const set = require('lodash/set');
+const uniq = require('lodash/uniq');
+const uniqBy = require('lodash/uniqBy');
+const flatten = require('flat');
+const mustache = require('mustache');
+const isEmpty = require('empty-value');
+const isAbsoluteUrl = require('is-absolute-url');
+
+const cloneDeep = require('lodash/cloneDeep');
+const { toTypeInfo, fromPublicKeyHash } = require('@arcblock/did');
+const { verify, stableStringify, proofTypes } = require('@arcblock/vc');
+const { toAssetAddress } = require('@arcblock/did-util');
+const { types } = require('@ocap/mcrypto');
+const { BN, toBase58, toBase64 } = require('@ocap/util');
+const { compile, validate, getQuota } = require('@ocap/contract');
+
+const debug = require('debug')(require('../package.json').name);
+
+const SUPPORTED_HOOK_NAMES = ['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 {
+      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;
+};
+
+const isValidFactory = (props) => {
+  if (!props) {
+    throw new Error('Factory props should not be empty');
+  }
+
+  // required props
+  const missingProp = ['name', 'description', 'input', 'output', 'settlement'].find((x) => !props[x]);
+  if (missingProp) {
+    throw new Error(`Factory ${missingProp} prop should not be empty`);
+  }
+
+  if (['instant', 'periodic'].includes(props.settlement) === false) {
+    throw new Error('Factory settlement prop should only be instant or periodic');
+  }
+
+  // input.tokens and input.assets should not be empty
+  if (['value', 'tokens', 'assets'].every((x) => isEmpty(props.input[x]))) {
+    throw new Error('Factory input should contain at least one token or asset');
+  }
+
+  if (uniqBy(props.input.tokens, 'address').length !== props.input.tokens.length) {
+    throw new Error('Factory token input should not contains duplicate address');
+  }
+
+  if (uniq(props.input.assets).length !== props.input.assets.length) {
+    throw new Error('Factory asset input should not contains duplicate address');
+  }
+
+  for (const token of props.input.tokens) {
+    try {
+      // eslint-disable-next-line no-new
+      new BN(token.value);
+    } catch (err) {
+      throw new Error(`Factory token ${token.address} is invalid: token value is not valid big number`);
+    }
+  }
+
+  // validate output
+  if (!props.output || typeof props.output !== 'object') {
+    throw new Error('Factory output should be an object');
+  }
+  try {
+    // should be a valid mustache template when serialized as json
+    const template = JSON.stringify(props.output);
+    mustache.parse(template);
+  } catch (err) {
+    throw new Error('Factory output should be a valid mustache template when serialized as json');
+  }
+
+  // validate hooks
+  const quota = getQuota(props.input);
+  if (Array.isArray(props.hooks)) {
+    const invalidHook = props.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 (props.settlement === 'instant') {
+    if (quota.value <= 0 && Object.keys(quota.tokens).every((x) => quota[x] <= 0)) {
+      return true;
+    }
+
+    if (isEmpty(props.hooks)) {
+      throw new Error('Factory hooks should not be empty for instant settlement');
+    }
+
+    const mintHook = props.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
+ */
+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
+ */
+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 },
+    })
+  );
+
+  debug('mintFromFactory.result', JSON.stringify(asset, null, 2));
+  const address = toAssetAddress(asset);
+  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 = ({ 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));
+        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 };
+};
+
+const formatFactoryState = (state) => {
+  const { address, output, data } = state;
+  const outputX = cloneDeep(output);
+
+  outputX.data.value = JSON.parse(outputX.data.value);
+  outputX.data.type = outputX.data.typeUrl;
+
+  return {
+    address,
+    output: outputX,
+    data: JSON.parse(data.value),
+  };
+};
+
+module.exports = {
+  isValidFactory,
+  isValidHook,
+  findPrerenderKeys,
+  mintFromFactory,
+  formatFactoryState,
+  preMintFromFactory,
+};

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@ocap/asset",
+  "description": "Utility to work with asset and factory on ArcBlock blockchain",
+  "version": "1.6.10",
+  "author": {
+    "name": "wangshijun",
+    "email": "shijun@arcblock.io",
+    "url": "https://github.com/wangshijun"
+  },
+  "bugs": {
+    "url": "https://github.com/ArcBlock/asset-chain/issues",
+    "email": "shijun@arcblock.io"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "contributors": [
+    "wangshijun <shijun@arcblock.io> (https://github.com/wangshijun)"
+  ],
+  "dependencies": {
+    "@arcblock/did": "1.6.10",
+    "@arcblock/did-util": "1.6.10",
+    "@arcblock/vc": "1.6.10",
+    "@ocap/contract": "1.6.10",
+    "@ocap/mcrypto": "1.6.10",
+    "@ocap/util": "1.6.10",
+    "@ocap/wallet": "1.6.10",
+    "debug": "^4.3.3",
+    "empty-value": "^1.0.1",
+    "flat": "^5.0.2",
+    "is-absolute-url": "^3.0.3",
+    "json-stable-stringify": "^1.0.1",
+    "lodash": "^4.17.21",
+    "mustache": "^4.1.0"
+  },
+  "devDependencies": {
+    "jest": "^27.3.1",
+    "remark-cli": "^10.0.1",
+    "remark-preset-github": "^4.0.1"
+  },
+  "remarkConfig": {
+    "plugins": [
+      "preset-github",
+      [
+        {
+          "repository": "ArcBlock/asset-chain"
+        }
+      ]
+    ]
+  },
+  "homepage": "https://github.com/ArcBlock/asset-chain/tree/master/core/asset",
+  "keywords": [
+    "blockchain",
+    "arcblock",
+    "sdk",
+    "nodejs"
+  ],
+  "license": "Apache-2.0",
+  "main": "./lib/index.js",
+  "files": [
+    "lib"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ArcBlock/asset-chain/tree/master/core/asset"
+  },
+  "scripts": {
+    "lint": "eslint lib tests",
+    "lint:fix": "eslint --fix lib tests",
+    "docs": "yarn gen-dts && yarn gen-docs && yarn cleanup-docs && yarn format-docs",
+    "cleanup-docs": "node ../../scripts/cleanup-docs.js docs/README.md $npm_package_name",
+    "gen-dts": "j2d lib/index.js",
+    "gen-docs": "jsdoc2md lib/index.js > docs/README.md",
+    "format-docs": "remark . -o",
+    "test": "jest --forceExit --detectOpenHandles",
+    "coverage": "yarn test -- --coverage"
+  },
+  "gitHead": "ab272e8db3a15c6571cc7fae7cc3d3e0fdd4bdb1"
+}