@talismn/scale 0.0.0-pr997-20231115151657 → 0.0.2

package/dist/talismn-scale.cjs.prod.js

@@ -30,16 +30,63 @@ function _interopNamespace(e) {
 var $__namespace = /*#__PURE__*/_interopNamespace($);
 var anylogger__default = /*#__PURE__*/_interopDefault(anylogger);
 
+const ignoreModuleMessages = {
+  "PORTABLEREGISTRY:": ["Unable to determine runtime Event type, cannot inspect frame_system::EventRecord", "Unable to determine runtime Call type, cannot inspect sp_runtime::generic::unchecked_extrinsic::UncheckedExtrinsic"]
+};
+function suppressPortableRegistryConsoleWarnings() {
+  /* eslint-disable-next-line no-console */
+  const originalWarn = console.warn;
+
+  /* eslint-disable-next-line no-console */
+  console.warn = (...data) => {
+    const [, dataModule, dataMessage] = data;
+    const ignoreMessages = typeof dataModule === "string" && ignoreModuleMessages[dataModule];
+    if (Array.isArray(ignoreMessages) && ignoreMessages.includes(dataMessage)) return;
+    if (data[0] === "Unable to map Bytes to a lookup index") return;
+    if (data[0] === "Unable to map [u8; 32] to a lookup index") return;
+    if (data[0] === "Unable to map u16 to a lookup index") return;
+    if (data[0] === "Unable to map u32 to a lookup index") return;
+    if (data[0] === "Unable to map u64 to a lookup index") return;
+    if (data[0] === "Unable to map u128 to a lookup index") return;
+    originalWarn(...data);
+  };
+}
+
 //
 // The simd variants of these hash fns are faster, but some devices don't support them.
 //
 // This file re-exports the faster fns from `./simd` for devices which support them,
 // and falls back to `./nosimd` re-exports for devices which do not.
 //
+/**
+ * Show a useful error message when someone attempts to use one of the classes
+ * from this lib without waiting for them to be initialized.
+ */
+class UninitializedHasher {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
+  constructor(...args) {
+    throw new Error(`This class cannot be used before @talismn/scale has initialized it. Please await 'watCryptoWaitReady' before attempting to construct this class.`);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  update(input) {
+    throw new Error(`This class cannot be used before @talismn/scale has initialized it. Please await 'watCryptoWaitReady' before attempting to construct this class.`);
+  }
+  digest() {
+    throw new Error(`This class cannot be used before @talismn/scale has initialized it. Please await 'watCryptoWaitReady' before attempting to construct this class.`);
+  }
+  digestInto(digest) {
+    digest.set(this.digest());
+  }
+  dispose() {
+    throw new Error(`This class cannot be used before @talismn/scale has initialized it. Please await 'watCryptoWaitReady' before attempting to construct this class.`);
+  }
+}
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-let Blake2b;
+let Blake2b = UninitializedHasher;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-let Xxhash;
+let Xxhash = UninitializedHasher;
 let readyPromise = null;
 const watCryptoWaitReady = async () => {
   // if this is the second/third/etc time we've called watCryptoWaitReady,
@@ -63,7 +110,7 @@ const watCryptoWaitReady = async () => {
         Xxhash = imported.Xxhash;
       } else {
         // system does not support wasm simd
-        const imported = await Promise.resolve().then(function () { return require('./nosimd-3e5ed5a9.cjs.prod.js'); });
+        const imported = await Promise.resolve().then(function () { return require('./nosimd-b32b4901.cjs.prod.js'); });
         Blake2b = imported.Blake2b;
         Xxhash = imported.Xxhash;
       }
@@ -448,6 +495,7 @@ const blake2_128Concat = new Blake2Hasher(128, true);
 const blake2_256 = new Blake2Hasher(256, false);
 const blake2_512 = new Blake2Hasher(512, false);
 const identity = new IdentityHasher();
+const twox64 = new TwoxHasher(64, false);
 const twox128 = new TwoxHasher(128, false);
 const twox256 = new TwoxHasher(256, false);
 const twox64Concat = new TwoxHasher(64, true);
@@ -1161,9 +1209,12 @@ function transformMetadata(metadata) {
     }
   };
   function getExtrinsicParameter(key) {
+    if (!metadata.extrinsic.ty) return $__namespace.never;
     const extrinsicTy = metadata.tys[metadata.extrinsic.ty];
     if (!extrinsicTy) return $__namespace.never;
-    return ids[extrinsicTy.params.find(x => x.name.toLowerCase() === key).ty];
+    const id = extrinsicTy.params.find(x => x.name.toLowerCase() === key)?.ty;
+    if (id === undefined) return $__namespace.never;
+    return ids[id];
   }
   function getExtensionsCodec(key) {
     return $__namespace.object(...metadata.extrinsic.signedExtensions.flatMap(ext => {
@@ -1309,7 +1360,7 @@ class SignerError extends Error {
 
 var packageJson = {
 	name: "@talismn/scale",
-	version: "0.0.0-pr997-20231115151657",
+	version: "0.0.2",
 	author: "Talisman",
 	homepage: "https://talisman.xyz",
 	license: "GPL-3.0-or-later",
@@ -1335,14 +1386,14 @@ var packageJson = {
 		clean: "rm -rf dist && rm -rf .turbo rm -rf node_modules"
 	},
 	dependencies: {
-		"@talismn/subshape-fork": "^0.0.1",
+		"@talismn/subshape-fork": "^0.0.2",
 		"@talismn/util": "workspace:*",
 		anylogger: "^1.0.11",
-		"wasm-feature-detect": "^1.6.0",
+		"wasm-feature-detect": "^1.6.1",
 		"wat-the-crypto": "^0.0.3"
 	},
 	devDependencies: {
-		"@polkadot/util-crypto": "^11.1.1",
+		"@polkadot/util-crypto": "^12.3.2",
 		"@talismn/eslint-config": "workspace:*",
 		"@talismn/tsconfig": "workspace:*",
 		"@types/jest": "^27.5.1",
@@ -1352,7 +1403,7 @@ var packageJson = {
 		typescript: "^5.2.2"
 	},
 	peerDependencies: {
-		"@polkadot/util-crypto": "^11.x"
+		"@polkadot/util-crypto": "12.x"
 	},
 	eslintConfig: {
 		root: true,
@@ -1364,6 +1415,14 @@ var packageJson = {
 
 var log = anylogger__default["default"](packageJson.name);
 
+const getMetadataVersion = metadataRpc => {
+  // https://docs.substrate.io/build/application-development/#metadata-system
+  const magicNumber = 1635018093;
+  const {
+    version
+  } = $__namespace.object($__namespace.field("magicNumber", $__namespace.constant(magicNumber, $__namespace.u32)), $__namespace.field("version", $__namespace.u8)).decode($__namespace.decodeHex(metadataRpc));
+  return version;
+};
 const filterMetadataPalletsAndItems = (metadata, palletsAndItems, extraKeepTypes) => {
   // remove pallets we don't care about
   metadata.pallets = metadata.pallets.filter(pallet =>
@@ -1379,7 +1438,7 @@ const filterMetadataPalletsAndItems = (metadata, palletsAndItems, extraKeepTypes
   }) => {
     const pallet = metadata.pallets.find(palletFilter);
     if (!pallet || !pallet.storage) {
-      log.warn("Failed to find pallet", palletFilter);
+      log.debug("Failed to find pallet", palletFilter);
       return [];
     }
 
@@ -1461,6 +1520,209 @@ addedTypes = new Set()) => {
   }
 };
 
+/**
+ * This module is largely copied from https://github.com/0xKheops/substrate-metadata-explorer/blob/4b5a991e5ced45cad3b8675ff9104b8366d20429/packages/sme-codegen/src/types/getConstantVariableName.ts
+ *
+ * The primary difference between this module and `sme-codegen` is in the output.
+ *
+ * The `sme-codegen` module exports typescript code as a string, which can then be interpretted in order to construct subshape objects.
+ *
+ * Whereas this module directly exports the subshape objects described by that code.
+ */
+
+/** Returns a unique name (relative to all of the types in `metadata`) to identify this type. */
+const getTypeName = (metadata, type) => {
+  const uniqueName = getUniqueTypeName(metadata, type);
+  return `${uniqueName.charAt(0).toUpperCase()}${uniqueName.substring(1)}`;
+};
+
+/**
+ * Tries each of `getSimpleTypeName`, `getSmartTypeName`, `getFullTypeName` in order and
+ * returns the first name which is unique in the collection of types in `metadata`.
+ */
+const getUniqueTypeName = (metadata, type) => {
+  const rawTypeName = getRawTypeName(type);
+  if (type.path.length < 1) return rawTypeName;
+
+  // use simpleName if it is unique
+  const simpleName = getSimpleTypeName(type);
+  if (!metadata.tys.some(t => t.id !== type.id && getSimpleTypeName(t) === simpleName)) return simpleName;
+
+  // use smartName if it is unique
+  const smartName = getSmartTypeName(type);
+  if (!metadata.tys.some(t => t.id !== type.id && getSmartTypeName(t) === smartName)) return smartName;
+
+  // use fullName if it is unique
+  const fullName = getFullTypeName(type);
+  if (!metadata.tys.some(t => t.id !== type.id && getFullTypeName(t) === fullName))
+    // return if fullName is unique
+    return fullName;
+
+  // use fullName + type number
+  return `${fullName}${type.id}`;
+};
+
+/** Gets "Type" + type number */
+const getRawTypeName = type => `Type${type.id}`;
+
+/** Gets the last element of `type.path` */
+const getSimpleTypeName = type => type.path.slice(-1)[0];
+
+/** Gets the first two elements, and the last element, of `type.path` and joins them together with `::` */
+const getSmartTypeName = type => type.path.length > 3 ? normalizeTypeName([...type.path.slice(0, 2), ...type.path.slice(-1)].join("::")) : getFullTypeName(type);
+
+/** Gets all elements of `type.path` and joins them together with `::` */
+const getFullTypeName = type => normalizeTypeName(type.path.join("::"));
+
+/**
+ * This module is largely copied from https://github.com/0xKheops/substrate-metadata-explorer/blob/4b5a991e5ced45cad3b8675ff9104b8366d20429/packages/sme-codegen/src/types/getShape.ts
+ *
+ * The primary difference between this module and `sme-codegen` is in the output.
+ *
+ * The `sme-codegen` module exports typescript code as a string, which can then be interpretted in order to construct subshape objects.
+ *
+ * Whereas this module directly exports the subshape objects described by that code.
+ */
+const getShape = (metadata, typeId, gotShapes = new Map()) => {
+  const type = metadata.tys.find(type => type.id === typeId);
+  if (!type) throw new Error(`Type not found (${typeId})`);
+
+  // Short circuit if we've already encountered this shape
+  const typeName = getTypeName(metadata, type);
+  if (gotShapes.has(typeName)) return gotShapes.get(typeName);
+
+  // TODO: Use `$.deferred(() => Type)` for self-referential types
+
+  // Get shape, add to gotShapes list, return shape
+  const shape = getTypeShape(metadata, type, gotShapes);
+  gotShapes.set(typeName, shape);
+  return shape;
+};
+const getTypeShape = (metadata, type, gotShapes) => {
+  const tyType = type.type;
+  switch (tyType) {
+    case "Primitive":
+      return getPrimitiveShape(type);
+    case "SizedArray":
+      return getSizedArrayShape(metadata, type, gotShapes);
+    case "Compact":
+      return getCompactShape(metadata, type, gotShapes);
+    case "Sequence":
+      return getSequenceShape(metadata, type, gotShapes);
+    case "Struct":
+      return getStructShape(metadata, type, gotShapes);
+    case "Tuple":
+      return getTupleShape(metadata, type, gotShapes);
+    case "Union":
+      return getUnionShape(metadata, type, gotShapes);
+    case "BitSequence":
+      return $__namespace.bitSequence;
+    default:
+      {
+        // force compilation error if any types don't have a case
+        const exhaustiveCheck = tyType;
+        throw new Error(`Unsupported type shape ${exhaustiveCheck}`);
+      }
+  }
+};
+const tyIsU8 = type => type?.type === "Primitive" && type.kind === "u8";
+const getPrimitiveShape = primitive => {
+  // TODO: Test that `char` and `$.u8` are equivalent (`$.char` does not exist)
+  if (primitive.kind === "char") return $__namespace.u8;
+  return $__namespace[primitive.kind];
+};
+const getSizedArrayShape = (metadata, sizedArray, gotShapes) => {
+  // Get the type definition for the items of this array from the metadata
+  const typeParam = metadata.tys.find(({
+    id
+  }) => id === sizedArray.typeParam);
+  if (!typeParam) {
+    const typeName = getTypeName(metadata, sizedArray);
+    throw new Error(`Could not find typeParam ${sizedArray.typeParam} for sizedArray ${typeName}`);
+  }
+
+  // Shortcut for uint8 arrays
+  if (tyIsU8(typeParam)) return $__namespace.sizedUint8Array(sizedArray.len);
+
+  // Get the subshape object for the items of this array
+  const typeParamShape = getShape(metadata, typeParam.id, gotShapes);
+
+  // Return a subshape sizedArray
+  return $__namespace.sizedArray(typeParamShape, sizedArray.len);
+};
+const getCompactShape = (metadata, compact, gotShapes) => {
+  // Get the type definition for the item of this compact from the metadata
+  const typeParam = metadata.tys.find(({
+    id
+  }) => id === compact.typeParam);
+  if (!typeParam) {
+    const typeName = getTypeName(metadata, compact);
+    throw new Error(`Could not find typeParam ${compact.typeParam} for compact ${typeName}`);
+  }
+
+  // Get the subshape object for the item of this compact
+  const typeParamShape = getShape(metadata, typeParam.id, gotShapes);
+
+  // Return a subshape compact
+  return $__namespace.compact(typeParamShape);
+};
+const getSequenceShape = (metadata, sequence, gotShapes) => {
+  // Get the type definition for the items of this sequence from the metadata
+  const typeParam = metadata.tys.find(({
+    id
+  }) => id === sequence.typeParam);
+  if (!typeParam) {
+    const typeName = getTypeName(metadata, sequence);
+    throw new Error(`Could not find typeParam ${sequence.typeParam} for sequence ${typeName}`);
+  }
+
+  // Shortcut for uint8 sequences
+  if (tyIsU8(typeParam)) return $__namespace.uint8Array;
+
+  // Get the subshape object for the items of this sequence
+  const typeParamShape = getShape(metadata, typeParam.id, gotShapes);
+
+  // Return a subshape sequence
+  return $__namespace.array(typeParamShape);
+};
+const getStructShape = (metadata, struct, gotShapes) => {
+  // If there's only one field and it has no name, don't wrap it in $.object
+  if (struct.fields.length === 1 && !struct.fields[0].name) return getShape(metadata, struct.fields[0].ty, gotShapes);
+
+  // Check that all fields have a name
+  if (!struct.fields.every(field => field.name)) {
+    const typeName = getTypeName(metadata, struct);
+    throw new Error(`Could not build subshape object for struct ${struct.id} (${typeName})): Not all fields have a name`);
+  }
+
+  // Get the type definition for the fields of this struct from the metadata
+  const fieldsShape = struct.fields.map(field => $__namespace.field(normalizeIdent(field.name), getShape(metadata, field.ty, gotShapes)));
+  return $__namespace.object(...fieldsShape);
+};
+const getTupleShape = (metadata, tuple, gotShapes) =>
+// Get the type definition for the fields of this tuple from the metadata and wrap them in `$.tuple`
+$__namespace.tuple(...tuple.fields.map(type => getShape(metadata, type, gotShapes)));
+const getUnionShape = (metadata, union, gotShapes) => {
+  if (union.members.every(member => !member.fields.length)) return $__namespace.literalUnion(Object.fromEntries(union.members.map(member => [member.index, normalizeIdent(member.name)])));
+
+  // TODO: Check if invalid
+  if (union.members.length === 2 && union.path[union.path.length - 1] === "Option" && union.members[0]?.name === "None" && union.members[1]?.name === "Some") return $__namespace.option(getShape(metadata, union.members[1].fields[0].ty, gotShapes));
+  return $__namespace.taggedUnion("type", Object.fromEntries(union.members.map(member => {
+    const args = [];
+
+    // invalid if only some fields (but not all of them) have a name
+    if (member.fields.some(field => field.name) && !member.fields.every(field => field.name)) {
+      const typeName = getTypeName(metadata, union);
+      throw new Error(`Could not build subshape object for union ${union.id} (${typeName}): Not all fields have a name`);
+    }
+    if (member.fields.every(field => field.name)) for (const field of member.fields) args.push($__namespace.field(normalizeIdent(field.name), getShape(metadata, field.ty, gotShapes)));else if (member.fields.length > 1) args.push($__namespace.field("value", $__namespace.tuple(...member.fields.map(field => getShape(metadata, field.ty, gotShapes)))));else args.push($__namespace.field("value", getShape(metadata, member.fields[0].ty, gotShapes)));
+    return [member.index, $__namespace.variant(normalizeIdent(member.name), ...args)];
+  })));
+};
+
+// TODO: Get the DX of this lib as close as possible to the DX of `const jsonResult = '{"someKey":"someValue"}'; JSON.decode(jsonResult)`
+suppressPortableRegistryConsoleWarnings();
+
 exports.$emptyKey = $emptyKey;
 exports.$era = $era;
 exports.$extrinsic = $extrinsic;
@@ -1490,7 +1752,16 @@ exports.blake2_512 = blake2_512;
 exports.blake2_64 = blake2_64;
 exports.decodeMetadata = decodeMetadata;
 exports.filterMetadataPalletsAndItems = filterMetadataPalletsAndItems;
+exports.getFullTypeName = getFullTypeName;
+exports.getMetadataVersion = getMetadataVersion;
 exports.getOrInit = getOrInit;
+exports.getRawTypeName = getRawTypeName;
+exports.getShape = getShape;
+exports.getSimpleTypeName = getSimpleTypeName;
+exports.getSmartTypeName = getSmartTypeName;
+exports.getTypeName = getTypeName;
+exports.getTypeShape = getTypeShape;
+exports.getUniqueTypeName = getUniqueTypeName;
 exports.identity = identity;
 exports.normalizeDocs = normalizeDocs;
 exports.normalizeIdent = normalizeIdent;
@@ -1504,5 +1775,6 @@ exports.transformMetadataV14 = transformMetadata;
 exports.transformTys = transformTys;
 exports.twox128 = twox128;
 exports.twox256 = twox256;
+exports.twox64 = twox64;
 exports.twox64Concat = twox64Concat;
 exports.watCryptoWaitReady = watCryptoWaitReady;