@ocap/proto 1.30.2 → 1.30.4

package/lib/schema.js

@@ -0,0 +1,240 @@
+/**
+ * `@ocap/proto/schema` — schema-only entry.
+ *
+ * Derives enums, message metadata, and typeUrls from `gen/spec.json` without
+ * touching any `*_pb.js` constructor. New Client SDK / Worker / Kernel builds
+ * import from here so bundlers can tree-shake the `google-protobuf` runtime
+ * and every generated `*_pb.js` out of the CBOR path.
+ *
+ * Public API (locked in phase_4_decisions q10):
+ *   - Functions: getFields, getEnum, listTxTypes, getTypeUrl, fromTypeUrl
+ *   - Constants: enums, typeUrls, messages, transactions, stakes, compactSpec
+ *
+ * Does NOT expose `getMessageType(t).fn` — that is a runtime concern
+ * (`@ocap/proto/runtime`) because pulling in the jspb constructor is what
+ * drags `*_pb.js` into the bundle.
+ *
+ * @module @ocap/proto/schema
+ */
+
+// Encode path reads only the core partition; Request/Response/service descriptors
+// stay out of bundles. `lib/runtime.js` merges `spec.rpc.json` on top for chain
+// side consumers. See tools/split-spec.js for the partition contract.
+//
+// `structuredClone` is mandatory because `compactSpec` mutates its input.
+// Node's require cache is shared with `lib/runtime.js`, so skipping the clone
+// here would flatten the JSON under ocap.nested and break runtime's merge.
+const rawSpec = structuredClone(require('./gen/spec.core.json'));
+
+// Dotted-path lookup. Replaces lodash/get so the encode bundle stays off
+// lodash; callers pass `vendor.Version` style keys (see getMessageType).
+const getByPath = (obj, path) => {
+  if (!obj || !path) return undefined;
+  if (Object.prototype.hasOwnProperty.call(obj, path)) return obj[path];
+  return path.split('.').reduce((o, k) => (o == null ? o : o[k]), obj);
+};
+
+const txTypePattern = /Tx$/;
+const stateTypePattern = /State$/;
+const stakeTypePattern = /^StakeFor/i;
+const requestTypePattern = /^Request/i;
+const responseTypePattern = /^Response/i;
+
+const lowerUnder = (x) =>
+  x
+    .split(/(?=[A-Z])/)
+    .join('_')
+    .toLowerCase();
+
+const compactSpec = (object) => {
+  if (object.nested) {
+    object = object.nested;
+  }
+
+  Object.keys(object).forEach((x) => {
+    if (object[x] && typeof object[x] === 'object') {
+      object[x] = compactSpec(object[x]);
+    }
+  });
+
+  return object;
+};
+
+const spec = compactSpec(rawSpec);
+const packageName = 'ocap';
+const { [packageName]: abi } = spec;
+Object.assign(spec, spec[packageName]);
+
+const messages = {};
+const enums = Object.keys(abi)
+  .filter((x) => abi[x].values)
+  .reduce((obj, x) => {
+    messages[x] = {};
+    obj[x] = Object.keys(abi[x].values).reduce((values, k) => {
+      values[k.toUpperCase()] = abi[x].values[k];
+      messages[x][abi[x].values[k]] = k.toUpperCase();
+      return values;
+    }, {});
+
+    return obj;
+  }, {});
+
+function createTypeUrls(abi) {
+  return Object.keys(abi).reduce((obj, type) => {
+    let typeUrl = type;
+    if (!requestTypePattern.test(type) && !responseTypePattern.test(type)) {
+      if (txTypePattern.test(type)) {
+        typeUrl = `fg:t:${lowerUnder(type.replace(txTypePattern, ''))}`;
+      }
+      if (stateTypePattern.test(type)) {
+        typeUrl = `fg:s:${lowerUnder(type.replace(stateTypePattern, ''))}`;
+      }
+      if (stakeTypePattern.test(type)) {
+        typeUrl = `fg:x:${lowerUnder(`Stake${type.replace(stakeTypePattern, '')}`)}`;
+      }
+      if (['TransactionInfo'].includes(type)) {
+        typeUrl = `fg:x:${lowerUnder(type)}`;
+      }
+      if (type === 'AssetFactoryState') {
+        typeUrl = 'fg:s:asset_factory_state';
+      }
+      if (type === 'AssetFactory') {
+        typeUrl = 'fg:x:asset_factory';
+      }
+      if (type === 'DummyCodec') {
+        typeUrl = 'fg:x:address';
+      }
+    }
+
+    obj[type] = typeUrl;
+    return obj;
+  }, {});
+}
+
+const typeUrls = createTypeUrls(abi);
+
+// `transactions` / `stakes` are derived from spec keys — no dependency on the
+// generated `*_pb.js` constructors. Runtime.js also computes these via
+// Object.keys(types); both paths converge on the same list because every tx /
+// stake message appears in spec.json.
+const transactions = Object.keys(abi).filter(
+  (x) => txTypePattern.test(x) && !requestTypePattern.test(x) && !responseTypePattern.test(x)
+);
+const stakes = Object.keys(abi).filter((x) => stakeTypePattern.test(x));
+
+enums.SupportedTxs = transactions;
+enums.SupportedStakes = stakes;
+
+// Historical multisign subsets. These are runtime conventions rather than
+// schema data (no equivalent field in spec.json), but the Client SDK needs
+// them to wire up multi-sign extension methods and the list is independent of
+// the jspb constructors — exposing it here keeps the client off `/runtime`.
+const multiSignTxs = ['ExchangeV2Tx'].filter((x) => transactions.includes(x));
+const multiSignV2Txs = [
+  'TransferV3Tx',
+  'AcquireAssetV3Tx',
+  'StakeTx',
+  'UpdateRollupTx',
+  'JoinRollupTx',
+  'LeaveRollupTx',
+  'PauseRollupTx',
+  'CloseRollupTx',
+  'MigrateRollupTx',
+  'ResumeRollupTx',
+  'DepositTokenV2Tx',
+  'WithdrawTokenV2Tx',
+  'CreateRollupBlockTx',
+  'ClaimBlockRewardTx',
+  'CreateAssetTx',
+  'ConsumeAssetTx',
+  'MintTokenTx',
+  'BurnTokenTx',
+].filter((x) => transactions.includes(x));
+
+/**
+ * Look up proto field descriptors for a message type. Schema-only — no jspb
+ * constructor returned. Callers needing the constructor must use
+ * `@ocap/proto/runtime` `getMessageType(type).fn`.
+ *
+ * Returns an array of `{name, type, id, rule?}` so callers can iterate
+ * without relying on insertion order of the underlying object literal.
+ *
+ * @param {string} type - e.g. 'Transaction', 'TransferTx'
+ * @returns {Array<{name: string, type: string, id: number, rule?: string}>}
+ */
+function getFields(type) {
+  const descriptor = getByPath(spec, type) || getByPath(spec, `vendor.${type}`) || {};
+  const fields = descriptor.fields;
+  if (!fields) {
+    return [];
+  }
+  return Object.keys(fields).map((name) => Object.assign({ name }, fields[name]));
+}
+
+/**
+ * Look up an enum descriptor (numeric values keyed by uppercased name).
+ *
+ * @param {string} name - e.g. 'KeyType', 'RoleType'
+ * @returns {object|undefined}
+ */
+function getEnum(name) {
+  return enums[name];
+}
+
+/**
+ * List every transaction type name known to the schema.
+ *
+ * @returns {string[]}
+ */
+function listTxTypes() {
+  return transactions.slice();
+}
+
+/**
+ * Schema-only `getMessageType` — returns `{ fields, oneofs }` for registry
+ * integration in `@ocap/message/provider`. Never returns `fn`; callers who
+ * need the jspb constructor must use `@ocap/proto/runtime`.
+ *
+ * Emits the raw spec.json object (keyed by field name) so the canonical CBOR
+ * encoder can iterate `Object.entries(fields)` the same way it does against
+ * the runtime provider. For a plain array, use `getFields(type)`.
+ *
+ * @param {string} type
+ * @returns {{fields?: object, oneofs?: object}}
+ */
+function getMessageType(type) {
+  const descriptor = getByPath(spec, type) || getByPath(spec, `vendor.${type}`) || {};
+  return { fields: descriptor.fields, oneofs: descriptor.oneofs };
+}
+
+function getTypeUrl(type) {
+  return typeUrls[type] || type;
+}
+
+function fromTypeUrl(url) {
+  const found = Object.entries(typeUrls).find(([, value]) => value === url);
+  if (found) {
+    return found[0];
+  }
+
+  return url;
+}
+
+module.exports = {
+  enums,
+  messages,
+  typeUrls,
+  transactions,
+  stakes,
+  multiSignTxs,
+  multiSignV2Txs,
+  compactSpec,
+  getFields,
+  getEnum,
+  listTxTypes,
+  getMessageType,
+  getTypeUrl,
+  fromTypeUrl,
+  // backwards-compatible alias; `toTypeUrl` was the historic name
+  toTypeUrl: getTypeUrl,
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ocap/proto",
   "description": "Static modules generated from forge-sdk protobuf files",
-  "version": "1.30.2",
+  "version": "1.30.4",
   "author": {
     "name": "wangshijun",
     "email": "shijun@arcblock.io",
@@ -26,6 +26,22 @@
   ],
   "license": "Apache-2.0",
   "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./schema": {
+      "types": "./lib/schema.d.ts",
+      "default": "./lib/schema.js"
+    },
+    "./runtime": {
+      "types": "./lib/runtime.d.ts",
+      "default": "./lib/runtime.js"
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
     "lib"
   ],
@@ -37,15 +53,13 @@
     "compile": "make build && make build-deps",
     "lint": "biome check",
     "lint:fix": "biome check --write",
-    "gen-proto": "node tools/gen-proto.js",
-    "gen-dts": "j2d lib/index.js && node tools/gen-dts.js && bash tools/patch-dts.sh",
+    "gen-dts": "node tools/gen-dts.js && bash tools/patch-dts.sh",
     "strip-classes": "node tools/strip-classes.js",
     "test": "bun test",
     "coverage": "npm run test -- --coverage"
   },
   "dependencies": {
-    "debug": "^4.4.3",
-    "lodash": "^4.17.23"
+    "debug": "^4.4.3"
   },
   "gitHead": "87990c8b5e215107fc587c1ced0d6b3e2cd2483e"
 }