@talismn/scale 0.0.2 → 0.1.0

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

@@ -1,1366 +1,21 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var util = require('@talismn/util');
-var wasmFeatureDetect = require('wasm-feature-detect');
-var $ = require('@talismn/subshape-fork');
+var metadataBuilders = require('@polkadot-api/metadata-builders');
+var utils = require('@polkadot-api/utils');
+var substrateBindings = require('@polkadot-api/substrate-bindings');
 var anylogger = require('anylogger');
+var scaleTs = require('scale-ts');
 
-function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
+function _interopDefault (e) { return e && e.__esModule ? e : { default: 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 = UninitializedHasher;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let Xxhash = UninitializedHasher;
-let readyPromise = null;
-const watCryptoWaitReady = async () => {
-  // if this is the second/third/etc time we've called watCryptoWaitReady,
-  // then get a reference to the existing promise and wait for it to resolve/reject
-  if (readyPromise !== null) return await readyPromise;
-
-  // if this is the first time we've called watCryptoWaitReady,
-  // then create and return a new promise
-  const deferred = util.Deferred();
-  readyPromise = deferred.promise
-
-  // spawn a task to initialize the fns and resolve the readyPromise
-  ;
-  (async () => {
-    try {
-      // initialize simd or nosimd, based on wasm feature detection
-      if (await wasmFeatureDetect.simd()) {
-        // system supports wasm simd
-        const imported = await Promise.resolve().then(function () { return require('./simd-2ddb8d7c.cjs.dev.js'); });
-        Blake2b = imported.Blake2b;
-        Xxhash = imported.Xxhash;
-      } else {
-        // system does not support wasm simd
-        const imported = await Promise.resolve().then(function () { return require('./nosimd-18c022ec.cjs.dev.js'); });
-        Blake2b = imported.Blake2b;
-        Xxhash = imported.Xxhash;
-      }
-
-      // feature detection and loading complete
-      deferred.resolve();
-    } catch (error) {
-      // feature detection and loading failed
-      deferred.reject(error);
-    }
-  })();
-
-  // wait for the promise to resolve/reject
-  return await readyPromise;
-};
-
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-
-/**
- * {@linkcode encode} and {@linkcode decode} for
- * [base58](https://en.wikipedia.org/wiki/Binary-to-text_encoding#Base58) encoding.
- *
- * This module is browser compatible.
- *
- * @module
- */
-
-// deno-fmt-ignore
-const mapBase58 = {
-  "1": 0,
-  "2": 1,
-  "3": 2,
-  "4": 3,
-  "5": 4,
-  "6": 5,
-  "7": 6,
-  "8": 7,
-  "9": 8,
-  "A": 9,
-  "B": 10,
-  "C": 11,
-  "D": 12,
-  "E": 13,
-  "F": 14,
-  "G": 15,
-  "H": 16,
-  "J": 17,
-  "K": 18,
-  "L": 19,
-  "M": 20,
-  "N": 21,
-  "P": 22,
-  "Q": 23,
-  "R": 24,
-  "S": 25,
-  "T": 26,
-  "U": 27,
-  "V": 28,
-  "W": 29,
-  "X": 30,
-  "Y": 31,
-  "Z": 32,
-  "a": 33,
-  "b": 34,
-  "c": 35,
-  "d": 36,
-  "e": 37,
-  "f": 38,
-  "g": 39,
-  "h": 40,
-  "i": 41,
-  "j": 42,
-  "k": 43,
-  "m": 44,
-  "n": 45,
-  "o": 46,
-  "p": 47,
-  "q": 48,
-  "r": 49,
-  "s": 50,
-  "t": 51,
-  "u": 52,
-  "v": 53,
-  "w": 54,
-  "x": 55,
-  "y": 56,
-  "z": 57
-};
-const base58alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz".split("");
-
-/**
- * Encodes a given Uint8Array, ArrayBuffer or string into draft-mspotny-base58-03 RFC base58 representation:
- * https://tools.ietf.org/id/draft-msporny-base58-01.html#rfc.section.1
- *
- * @param data
- *
- * @returns Encoded value
- */
-function encode$1(data) {
-  const uint8tData = typeof data === "string" ? new TextEncoder().encode(data) : data instanceof Uint8Array ? data : new Uint8Array(data);
-  let length = 0;
-  let zeroes = 0;
-
-  // Counting leading zeroes
-  let index = 0;
-  while (uint8tData[index] === 0) {
-    zeroes++;
-    index++;
-  }
-  const notZeroUint8Data = uint8tData.slice(index);
-  const size = Math.round(uint8tData.length * 138 / 100 + 1);
-  const b58Encoding = [];
-  notZeroUint8Data.forEach(byte => {
-    let i = 0;
-    let carry = byte;
-    for (let reverse_iterator = size - 1; (carry > 0 || i < length) && reverse_iterator !== -1; reverse_iterator--, i++) {
-      carry += (b58Encoding[reverse_iterator] || 0) * 256;
-      b58Encoding[reverse_iterator] = Math.round(carry % 58);
-      carry = Math.floor(carry / 58);
-    }
-    length = i;
-  });
-  const strResult = Array.from({
-    length: b58Encoding.length + zeroes
-  });
-  if (zeroes > 0) {
-    strResult.fill("1", 0, zeroes);
-  }
-  b58Encoding.forEach(byteValue => strResult.push(base58alphabet[byteValue]));
-  return strResult.join("");
-}
-
-/**
- * Decodes a given b58 string according to draft-mspotny-base58-03 RFC base58 representation:
- * https://tools.ietf.org/id/draft-msporny-base58-01.html#rfc.section.1
- *
- * @param b58
- *
- * @returns Decoded value
- */
-function decode$1(b58) {
-  const splitInput = b58.trim().split("");
-  let length = 0;
-  let ones = 0;
-
-  // Counting leading ones
-  let index = 0;
-  while (splitInput[index] === "1") {
-    ones++;
-    index++;
-  }
-  const notZeroData = splitInput.slice(index);
-  const size = Math.round(b58.length * 733 / 1000 + 1);
-  const output = [];
-  notZeroData.forEach((char, idx) => {
-    let carry = mapBase58[char];
-    let i = 0;
-    if (carry === undefined) {
-      throw new Error(`Invalid base58 char at index ${idx} with value ${char}`);
-    }
-    for (let reverse_iterator = size - 1; (carry > 0 || i < length) && reverse_iterator !== -1; reverse_iterator--, i++) {
-      carry += 58 * (output[reverse_iterator] || 0);
-      output[reverse_iterator] = Math.round(carry % 256);
-      carry = Math.floor(carry / 256);
-    }
-    length = i;
-  });
-  const validOutput = output.filter(item => item !== undefined);
-  if (ones > 0) {
-    const onesResult = Array.from({
-      length: ones
-    }).fill(0, 0, ones);
-    return new Uint8Array([...onesResult, ...validOutput]);
-  }
-  return new Uint8Array(validOutput);
-}
-
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-function encode(prefix, payload, checksumLength) {
-  return encode$1(encodeRaw(prefix, payload, checksumLength));
-}
-function encodeRaw(prefix, payload, checksumLength) {
-  checksumLength ??= DEFAULT_PAYLOAD_CHECKSUM_LENGTHS[payload.length];
-  if (!checksumLength) throw new InvalidPayloadLengthError();
-  const prefixBytes = prefix < 64 ? Uint8Array.of(prefix) : Uint8Array.of((prefix & 0b0000_0000_1111_1100) >> 2 | 0b0100_0000, prefix >> 8 | (prefix & 0b0000_0000_0000_0011) << 6);
-  const hasher = new Blake2b();
-  hasher.update(SS58PRE);
-  hasher.update(prefixBytes);
-  hasher.update(payload);
-  const digest = hasher.digest();
-  const checksum = digest.subarray(0, checksumLength);
-  hasher.dispose();
-  const address = new Uint8Array(prefixBytes.length + payload.length + checksumLength);
-  address.set(prefixBytes, 0);
-  address.set(payload, prefixBytes.length);
-  address.set(checksum, prefixBytes.length + payload.length);
-  return address;
-}
-class InvalidPayloadLengthError extends Error {
-  name = "InvalidPayloadLengthError";
-}
-function decode(address) {
-  return decodeRaw(decode$1(address));
-}
-function decodeRaw(address) {
-  const checksumLength = VALID_ADDRESS_CHECKSUM_LENGTHS[address.length];
-  if (!checksumLength) throw new InvalidAddressLengthError();
-  const prefixLength = address[0] & 0b0100_0000 ? 2 : 1;
-  const prefix = prefixLength === 1 ? address[0] : (address[0] & 0b0011_1111) << 2 | address[1] >> 6 | (address[1] & 0b0011_1111) << 8;
-  const hasher = new Blake2b();
-  hasher.update(SS58PRE);
-  hasher.update(address.subarray(0, address.length - checksumLength));
-  const digest = hasher.digest();
-  const checksum = address.subarray(address.length - checksumLength);
-  hasher.dispose();
-  if (!isValidChecksum(digest, checksum, checksumLength)) {
-    throw new InvalidAddressChecksumError();
-  }
-  const pubKey = address.subarray(prefixLength, address.length - checksumLength);
-  return [prefix, pubKey];
-}
-class InvalidAddressLengthError extends Error {
-  name = "InvalidAddressError";
-}
-class InvalidAddressChecksumError extends Error {
-  name = "InvalidAddressChecksumError";
-}
-
-// SS58PRE string (0x53533538505245 hex) encoded as Uint8Array
-const SS58PRE = Uint8Array.of(83, 83, 53, 56, 80, 82, 69);
-const VALID_ADDRESS_CHECKSUM_LENGTHS = {
-  3: 1,
-  4: 1,
-  5: 2,
-  6: 1,
-  7: 2,
-  8: 3,
-  9: 4,
-  10: 1,
-  11: 2,
-  12: 3,
-  13: 4,
-  14: 5,
-  15: 6,
-  16: 7,
-  17: 8,
-  35: 2,
-  36: 2,
-  37: 2
-};
-const DEFAULT_PAYLOAD_CHECKSUM_LENGTHS = {
-  1: 1,
-  2: 1,
-  4: 1,
-  8: 1,
-  32: 2,
-  33: 2
-};
-function isValidChecksum(digest, checksum, checksumLength) {
-  for (let i = 0; i < checksumLength; i++) {
-    if (digest[i] !== checksum[i]) {
-      return false;
-    }
-  }
-  return true;
-}
-
-var ss58 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  encode: encode,
-  encodeRaw: encodeRaw,
-  InvalidPayloadLengthError: InvalidPayloadLengthError,
-  decode: decode,
-  decodeRaw: decodeRaw,
-  InvalidAddressLengthError: InvalidAddressLengthError,
-  InvalidAddressChecksumError: InvalidAddressChecksumError
-});
-
-/**
- * Adapted from https://github.com/paritytech/capi-old copyright Parity Technologies (APACHE License 2.0)
- * Changes August 19th 2023 :
- * - updated to use subshape for scale decoding
- * - adapted from deno to typescript
- *
-   Copyright 2023 Parity Technologies
-
-   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.
- */
-class Hasher {
-  $hash($inner) {
-    return $hash(this, $inner);
-  }
-  hash(data) {
-    const output = new Uint8Array(this.digestLength + (this.concat ? data.length : 0));
-    const hashing = this.create();
-    hashing.update(data);
-    hashing.digestInto(output);
-    hashing.dispose?.();
-    if (this.concat) {
-      output.set(data, this.digestLength);
-    }
-    return output;
-  }
-}
-function $hash(hasher, $inner) {
-  return $__namespace.createShape({
-    metadata: $__namespace.metadata("$hash", $hash, hasher, $inner),
-    staticSize: hasher.digestLength + $inner.staticSize,
-    subEncode(buffer, value) {
-      const hashArray = buffer.array.subarray(buffer.index, buffer.index += hasher.digestLength);
-      const cursor = hasher.concat ? buffer.createCursor($inner.staticSize) : new $.EncodeBuffer(buffer.stealAlloc($inner.staticSize));
-      $inner.subEncode(cursor, value);
-      buffer.waitForBuffer(cursor, () => {
-        if (hasher.concat) cursor.close();else cursor._commitWritten();
-        const hashing = hasher.create();
-        updateHashing(hashing, cursor);
-        hashing.digestInto(hashArray);
-        hashing.dispose?.();
-      });
-    },
-    subDecode(buffer) {
-      if (!hasher.concat) throw new DecodeNonTransparentKeyError();
-      buffer.index += hasher.digestLength;
-      return $inner.subDecode(buffer);
-    },
-    subAssert(assert) {
-      $inner.subAssert(assert);
-    }
-  });
-}
-class Blake2Hasher extends Hasher {
-  constructor(size, concat) {
-    super();
-    this.concat = concat;
-    this.digestLength = size / 8;
-  }
-  create() {
-    return new Blake2b(this.digestLength);
-  }
-}
-class IdentityHasher extends Hasher {
-  digestLength = 0;
-  concat = true;
-  create() {
-    return {
-      update() {},
-      digestInto() {}
-    };
-  }
-  $hash($inner) {
-    return $inner;
-  }
-  hash(data) {
-    return data.slice();
-  }
-}
-class TwoxHasher extends Hasher {
-  constructor(size, concat) {
-    super();
-    this.concat = concat;
-    this.digestLength = size / 8;
-    this.rounds = size / 64;
-  }
-  create() {
-    return new Xxhash(this.rounds);
-  }
-}
-const blake2_64 = new Blake2Hasher(64, false);
-const blake2_128 = new Blake2Hasher(128, false);
-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);
-function updateHashing(hashing, data) {
-  for (const array of data.finishedArrays) {
-    if (array instanceof $.EncodeBuffer) {
-      updateHashing(hashing, array);
-    } else {
-      hashing.update(array);
-    }
-  }
-}
-class DecodeNonTransparentKeyError extends Error {
-  name = "DecodeNonTransparentKeyError";
-}
-
-/**
- * Adapted from https://github.com/paritytech/capi-old copyright Parity Technologies (APACHE License 2.0)
- * Changes August 19th 2023 :
- * - updated to use subshape for scale decoding
- * - adapted from deno to typescript
- *
-   Copyright 2023 Parity Technologies
-
-   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.
- */
-const $tyId = $__namespace.compact($__namespace.u32);
-const $field = $__namespace.object($__namespace.optionalField("name", $__namespace.str), $__namespace.field("ty", $tyId), $__namespace.optionalField("typeName", $__namespace.str), $__namespace.field("docs", $__namespace.array($__namespace.str)));
-const $primitiveKind = $__namespace.literalUnion(["bool", "char", "str", "u8", "u16", "u32", "u64", "u128", "u256", "i8", "i16", "i32", "i64", "i128", "i256"]);
-const $tyDef = $__namespace.taggedUnion("type", [$__namespace.variant("Struct", $__namespace.field("fields", $__namespace.array($field))), $__namespace.variant("Union", $__namespace.field("members", $__namespace.array($__namespace.object($__namespace.field("name", $__namespace.str), $__namespace.field("fields", $__namespace.array($field)), $__namespace.field("index", $__namespace.u8), $__namespace.field("docs", $__namespace.array($__namespace.str)))))), $__namespace.variant("Sequence", $__namespace.field("typeParam", $tyId)), $__namespace.variant("SizedArray", $__namespace.field("len", $__namespace.u32), $__namespace.field("typeParam", $tyId)), $__namespace.variant("Tuple", $__namespace.field("fields", $__namespace.array($tyId))), $__namespace.variant("Primitive", $__namespace.field("kind", $primitiveKind)), $__namespace.variant("Compact", $__namespace.field("typeParam", $tyId)), $__namespace.variant("BitSequence", $__namespace.field("bitOrderType", $tyId), $__namespace.field("bitStoreType", $tyId))]);
-const $ty = $__namespace.object($__namespace.field("id", $__namespace.compact($__namespace.u32)), $__namespace.field("path", $__namespace.array($__namespace.str)), $__namespace.field("params", $__namespace.array($__namespace.object($__namespace.field("name", $__namespace.str), $__namespace.optionalField("ty", $tyId)))), $tyDef, $__namespace.field("docs", $__namespace.array($__namespace.str)));
-
-/**
- * Adapted from https://github.com/paritytech/capi-old copyright Parity Technologies (APACHE License 2.0)
- * Changes August 19th 2023 :
- * - updated to use subshape for scale decoding
- * - adapted from deno to typescript
- *
-   Copyright 2023 Parity Technologies
-
-   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.
- */
-
-const unquotedKey = /^(?!__proto__$)[$_\p{ID_Start}][$\p{ID_Continue}]+$|^\d+$/u;
-function stringifyKey(key) {
-  return unquotedKey.test(key) ? key : JSON.stringify(key);
-}
-function stringifyPropertyAccess(key) {
-  return unquotedKey.test(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
-}
-
-/**
- * Adapted from https://github.com/paritytech/capi-old copyright Parity Technologies (APACHE License 2.0)
- * Changes August 19th 2023 :
- * - updated to use subshape for scale decoding
- * - adapted from deno to typescript
- *
-   Copyright 2023 Parity Technologies
-
-   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.
- */
-
-function normalizeIdent(ident) {
-  if (ident.startsWith("r#")) ident = ident.slice(2);
-  return normalizeKeyword(ident.replace(/(?:[^\p{ID_Continue}]|_)+(.)/gu, (_, $1) => $1.toUpperCase()));
-}
-function normalizeDocs(docs) {
-  let str = docs?.join("\n") ?? "";
-  str = str.replace(/[^\S\n]+$/gm, "") // strip trailing whitespace
-  .replace(/^\n+|\n+$/g, ""); // strip leading and trailing newlines
-  const match = /^([^\S\n]+).*(?:\n\1.*)*$/.exec(str); // find a common indent
-  if (match) {
-    const {
-      1: prefix
-    } = match;
-    str = str.replace(new RegExp(`^${prefix}`, "gm"), ""); // strip the common indent
-    // this `new RegExp` is safe because `prefix` must be whitespace
-  }
-
-  return str;
-}
-function normalizePackageName(name) {
-  return name.replace(/[A-Z]/g, x => `-` + x.toLowerCase());
-}
-function normalizeTypeName(name) {
-  return normalizeIdent(name).replace(/^./, x => x.toUpperCase());
-}
-function normalizeVariableName(name) {
-  return normalizeIdent(name).replace(/^./, x => x.toLowerCase());
-}
-
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#reserved_words
-const keywords = ["break", "case", "catch", "class", "const", "continue", "debugger", "delete", "do", "else", "export", "extends", "false", "finally", "for", "function", "if", "import", "in", "instanceof", "new", "null", "return", "super", "switch", "this", "throw", "true", "try", "typeof", "var", "void", "while", "with", "let", "static", "yield", "await", "enum", "implements", "interface", "package", "private", "protected", "public"];
-function normalizeKeyword(ident) {
-  return keywords.includes(ident) ? ident + "_" : ident;
-}
-
-/**
- * Adapted from https://github.com/paritytech/capi-old copyright Parity Technologies (APACHE License 2.0)
- * Changes August 19th 2023 :
- * - updated to use subshape for scale decoding
- * - adapted from deno to typescript
- *
-   Copyright 2023 Parity Technologies
-
-   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.
- */
-
-function getOrInit(container, key, init) {
-  let value = container.get(key);
-  if (value === undefined) {
-    value = init();
-    container.set(key, value);
-  }
-  return value;
-}
-
-// export class WeakRefMap<K, V extends object> {
-//   map = new Map<K, WeakRef<V>>()
-//   finReg = new FinalizationRegistry<K>((key) => this.map.delete(key))
-//   get(key: K) {
-//     return this.map.get(key)?.deref()
-//   }
-//   set(key: K, value: V) {
-//     this.map.set(key, new WeakRef(value))
-//     this.finReg.register(value, key, value)
-//   }
-//   delete(key: K) {
-//     const value = this.get(key)
-//     if (!value) return false
-//     this.map.delete(key)
-//     this.finReg.unregister(value)
-//     return true
-//   }
-// }
-
-/**
- * Adapted from https://github.com/paritytech/capi-old copyright Parity Technologies (APACHE License 2.0)
- * Changes August 19th 2023 :
- * - updated to use subshape for scale decoding
- * - adapted from deno to typescript
- *
-   Copyright 2023 Parity Technologies
-
-   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.
- */
-
-class ChainError extends Error {
-  name = "ChainError";
-  constructor(value) {
-    super();
-    this.value = value;
-    this.stack = "ChainError: see error.value\n  [error occurred on chain]";
-  }
-  static toArgs = x => [x.value];
-}
-
-/**
- * Adapted from https://github.com/paritytech/capi-old copyright Parity Technologies (APACHE License 2.0)
- * Changes August 19th 2023 :
- * - updated to use subshape for scale decoding
- * - adapted from deno to typescript
- *
-   Copyright 2023 Parity Technologies
-
-   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.
- */
-// eslint-disable-next-line @typescript-eslint/no-namespace
-exports.Era = void 0;
-(function (_Era) {
-  _Era.Immortal = {
-    type: "Immortal"
-  };
-  function Mortal(period, current) {
-    const adjustedPeriod = minN(maxN(nextPowerOfTwo(period), 4n), 1n << 16n);
-    const phase = current % adjustedPeriod;
-    const quantizeFactor = maxN(adjustedPeriod >> 12n, 1n);
-    const quantizedPhase = phase / quantizeFactor * quantizeFactor;
-    return {
-      type: "Mortal",
-      period: adjustedPeriod,
-      phase: quantizedPhase
-    };
-  }
-  _Era.Mortal = Mortal;
-})(exports.Era || (exports.Era = {}));
-const $era = $__namespace.createShape({
-  metadata: $__namespace.metadata("$era"),
-  staticSize: 2,
-  subEncode(buffer, value) {
-    if (value.type === "Immortal") {
-      buffer.array[buffer.index++] = 0;
-    } else {
-      const quantizeFactor = maxN(value.period >> 12n, 1n);
-      const encoded = minN(maxN(trailingZeroes(value.period) - 1n, 1n), 15n) | value.phase / quantizeFactor << 4n;
-      $__namespace.u16.subEncode(buffer, Number(encoded));
-    }
-  },
-  subDecode(buffer) {
-    if (buffer.array[buffer.index] === 0) {
-      buffer.index++;
-      return {
-        type: "Immortal"
-      };
-    } else {
-      const encoded = BigInt($__namespace.u16.subDecode(buffer));
-      const period = 2n << encoded % (1n << 4n);
-      const quantizeFactor = maxN(period >> 12n, 1n);
-      const phase = (encoded >> 4n) * quantizeFactor;
-      if (period >= 4n && phase <= period) {
-        return {
-          type: "Mortal",
-          period,
-          phase
-        };
-      } else {
-        throw new Error("Invalid period and phase");
-      }
-    }
-  },
-  subAssert: $__namespace.taggedUnion("type", [$__namespace.variant("Immortal"), $__namespace.variant("Mortal", $__namespace.field("period", $__namespace.u64), $__namespace.field("phase", $__namespace.u64))]).subAssert
-});
-function maxN(a, b) {
-  return a > b ? a : b;
-}
-function minN(a, b) {
-  return a < b ? a : b;
-}
-function trailingZeroes(n) {
-  let i = 0n;
-  while (!(n & 1n)) {
-    i++;
-    n >>= 1n;
-  }
-  return i;
-}
-function nextPowerOfTwo(n) {
-  n--;
-  let p = 1n;
-  while (n > 0n) {
-    p <<= 1n;
-    n >>= 1n;
-  }
-  return p;
-}
-
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-const isResult = new $__namespace.ShapeVisitor().add($__namespace.result, () => true).fallback(() => false);
-const isOption = new $__namespace.ShapeVisitor().add($__namespace.option, () => true).fallback(() => false);
-const overrides = {
-  "Option": (ty, visit) => {
-    let $some = visit(ty.params[0].ty);
-    if (isOption.visit($some)) {
-      $some = $__namespace.tuple($some);
-    }
-    return $__namespace.option($some);
-  },
-  "Result": (ty, visit) => {
-    let $ok = visit(ty.params[0].ty);
-    if (isResult.visit($ok)) {
-      $ok = $__namespace.tuple($ok);
-    }
-    return $__namespace.result($ok, $__namespace.instance(ChainError, $__namespace.tuple(visit(ty.params[1].ty)), ChainError.toArgs));
-  },
-  "BTreeMap": (ty, visit) => {
-    return $__namespace.map(visit(ty.params[0].ty), visit(ty.params[1].ty));
-  },
-  "BTreeSet": (ty, visit) => {
-    return $__namespace.set(visit(ty.params[0].ty));
-  },
-  "frame_support::traits::misc::WrapperOpaque": (ty, visit) => {
-    return $__namespace.lenPrefixed(visit(ty.params[0].ty));
-  },
-  "frame_support::traits::misc::WrapperKeepOpaque": (ty, visit) => {
-    return $__namespace.lenPrefixed(visit(ty.params[0].ty));
-  },
-  "sp_runtime::generic::era::Era": () => {
-    return $era;
-  }
-};
-
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-/**
- * All derived codecs for ZSTs will use this exact codec,
- * so `derivedCodec === $null` is true iff the type is a ZST.
- */
-const $null = $__namespace.withMetadata($__namespace.metadata("$null"), $__namespace.constant(null));
-function transformTys(tys) {
-  const tysMap = new Map(tys.map(ty => [ty.id, ty]));
-  const memo = new Map();
-  const types = {};
-  const paths = {};
-  const seenPaths = new Map();
-  const includePaths = new Set();
-  const names = new Map();
-  const nameCounts = new Map();
-  for (const ty of tys) {
-    const path = ty.path.join("::");
-    if (!path) continue;
-    const last = seenPaths.get(path);
-    if (last !== undefined) {
-      if (last === null || !eqTy(tysMap, last.id, ty.id)) {
-        seenPaths.set(path, null);
-        includePaths.delete(path);
-      }
-      continue;
-    }
-    seenPaths.set(path, ty);
-    includePaths.add(path);
-  }
-  for (const path of includePaths) {
-    const parts = path.split("::");
-    const name = parts.at(-1);
-    const map = getOrInit(nameCounts, name, () => new Map());
-    for (let i = 0; i < parts.length; i++) {
-      const pathPart = parts.slice(0, i).join("::");
-      map.set(pathPart, (map.get(pathPart) ?? 0) + 1);
-    }
-  }
-  for (const path of includePaths) {
-    const parts = path.split("::");
-    const name = parts.at(-1);
-    const map = nameCounts.get(name);
-    const pathLength = parts.findIndex((_, i) => map.get(parts.slice(0, i).join("::")) === 1);
-    const newPath = [...parts.slice(0, pathLength), name].join("::");
-    const newName = normalizeTypeName(newPath);
-    names.set(path, newName);
-  }
-  return {
-    ids: tys.map(ty => visit(ty.id)),
-    types,
-    paths
-  };
-  function visit(i) {
-    return getOrInit(memo, i, () => {
-      memo.set(i, $__namespace.deferred(() => memo.get(i)));
-      const ty = tysMap.get(i);
-      const path = ty.path.join("::");
-      const usePath = includePaths.has(path);
-      const name = names.get(path);
-      if (usePath && types[name]) return types[name];
-      const codec = withDocs(ty.docs, _visit(ty));
-      if (usePath) return types[name] ??= paths[path] = codec;
-      return codec;
-    });
-  }
-  function _visit(ty) {
-    const overrideFn = overrides[ty.path.join("::")];
-    if (overrideFn) return overrideFn(ty, visit);
-    if (ty.type === "Struct") {
-      if (ty.fields.length === 0) {
-        return $null;
-      } else if (ty.fields[0].name === undefined) {
-        if (ty.fields.length === 1) {
-          // wrapper
-          return visit(ty.fields[0].ty);
-        } else {
-          return $__namespace.tuple(...ty.fields.map(x => visit(x.ty)));
-        }
-      } else {
-        return $__namespace.object(...ty.fields.map(x => withDocs(x.docs, maybeOptionalField(normalizeIdent(x.name), visit(x.ty)))));
-      }
-    } else if (ty.type === "Tuple") {
-      if (ty.fields.length === 0) {
-        return $null;
-      } else if (ty.fields.length === 1) {
-        // wrapper
-        return visit(ty.fields[0]);
-      } else {
-        return $__namespace.tuple(...ty.fields.map(x => visit(x)));
-      }
-    } else if (ty.type === "Union") {
-      if (ty.members.length === 0) {
-        return $__namespace.never;
-      } else if (ty.members.every(x => x.fields.length === 0)) {
-        const members = {};
-        for (const {
-          index,
-          name
-        } of ty.members) {
-          members[index] = normalizeIdent(name);
-        }
-        return $__namespace.literalUnion(members);
-      } else {
-        const members = {};
-        for (const {
-          fields,
-          name,
-          index
-        } of ty.members) {
-          let member;
-          const type = normalizeIdent(name);
-          if (fields.length === 0) {
-            member = $__namespace.variant(type);
-          } else if (fields[0].name === undefined) {
-            // Tuple variant
-            const $value = fields.length === 1 ? visit(fields[0].ty) : $__namespace.tuple(...fields.map(f => visit(f.ty)));
-            member = $__namespace.variant(type, maybeOptionalField("value", $value));
-          } else {
-            // Object variant
-            const memberFields = fields.map(field => {
-              return withDocs(field.docs, maybeOptionalField(normalizeIdent(field.name), visit(field.ty)));
-            });
-            member = $__namespace.variant(type, ...memberFields);
-          }
-          members[index] = member;
-        }
-        return $__namespace.taggedUnion("type", members);
-      }
-    } else if (ty.type === "Sequence") {
-      const $inner = visit(ty.typeParam);
-      if ($inner === $__namespace.u8) {
-        return $__namespace.uint8Array;
-      } else {
-        return $__namespace.array($inner);
-      }
-    } else if (ty.type === "SizedArray") {
-      const $inner = visit(ty.typeParam);
-      if ($inner === $__namespace.u8) {
-        return $__namespace.sizedUint8Array(ty.len);
-      } else {
-        return $__namespace.sizedArray($inner, ty.len);
-      }
-    } else if (ty.type === "Primitive") {
-      if (ty.kind === "char") return $__namespace.str;
-      return $__namespace[ty.kind];
-    } else if (ty.type === "Compact") {
-      return $__namespace.compact(visit(ty.typeParam));
-    } else if (ty.type === "BitSequence") {
-      return $__namespace.bitSequence;
-    } else {
-      throw new Error("unreachable");
-    }
-  }
-}
-function withDocs(_docs, codec) {
-  const docs = normalizeDocs(_docs);
-  if (docs) return $__namespace.documented(docs, codec);
-  return codec;
-}
-function eqTy(tysMap, a, b) {
-  const seen = new Set();
-  return eqTy(a, b);
-  function eqTy(ai, bi) {
-    const key = `${ai}=${bi}`;
-    if (seen.has(key)) return true;
-    seen.add(key);
-    const a = tysMap.get(ai);
-    const b = tysMap.get(bi);
-    if (a.id === b.id) return true;
-    if (a.type !== b.type) return false;
-    if (a.path.join("::") !== b.path.join("::")) return false;
-    if (normalizeDocs(a.docs) !== normalizeDocs(b.docs)) return false;
-    if (!eqArray(a.params, b.params, (a, b) => a.name === b.name && a.ty == null === (b.ty == null) && (a.ty == null || eqTy(a.ty, b.ty)))) {
-      return false;
-    }
-    if (a.type === "BitSequence") {
-      return true;
-    }
-    if (a.type === "Primitive" && b.type === "Primitive") {
-      return a.kind === b.kind;
-    }
-    if (a.type === "Compact" && b.type === "Compact" || a.type === "Sequence" && b.type === "Sequence") {
-      return eqTy(a.typeParam, b.typeParam);
-    }
-    if (a.type === "SizedArray" && b.type === "SizedArray") {
-      return a.len === b.len && eqTy(a.typeParam, b.typeParam);
-    }
-    if (a.type === "Struct" && b.type === "Struct") {
-      return eqArray(a.fields, b.fields, eqField);
-    }
-    if (a.type === "Tuple" && b.type === "Tuple") {
-      return eqArray(a.fields, b.fields, eqTy);
-    }
-    if (a.type === "Union" && b.type === "Union") {
-      return eqArray(a.members, b.members, (a, b) => a.index === b.index && a.name === b.name && normalizeDocs(a.docs) === normalizeDocs(b.docs) && eqArray(a.fields, b.fields, eqField));
-    }
-    return false;
-  }
-  function eqField(a, b) {
-    return a.name === b.name && a.typeName === b.typeName && eqDocs(a.docs, b.docs) && eqTy(a.ty, b.ty);
-  }
-  function eqDocs(a, b) {
-    return normalizeDocs(a) === normalizeDocs(b);
-  }
-  function eqArray(a, b, eqVal) {
-    return a.length === b.length && a.every((x, i) => eqVal(x, b[i]));
-  }
-}
-const optionInnerVisitor = new $__namespace.ShapeVisitor().add($__namespace.option, (_codec, $some) => $some).fallback(() => null);
-function maybeOptionalField(key, $value) {
-  const $inner = optionInnerVisitor.visit($value);
-  return $inner ? $__namespace.optionalField(key, $inner) : $__namespace.field(key, $value);
-}
-
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-function $storageKey(palletName, entryName, $key) {
-  const palletHash = twox128.hash(new TextEncoder().encode(palletName));
-  const entryHash = twox128.hash(new TextEncoder().encode(entryName));
-  return $__namespace.createShape({
-    metadata: $__namespace.metadata("$storageKey", $storageKey, palletName, entryName, $key),
-    staticSize: $key.staticSize + 32,
-    subEncode(buffer, key) {
-      buffer.insertArray(palletHash);
-      buffer.insertArray(entryHash);
-      $key.subEncode(buffer, key);
-    },
-    subDecode(buffer) {
-      // Ignore initial hashes
-      buffer.index += 32;
-      return $key.subDecode(buffer);
-    },
-    subAssert(assert) {
-      $key.subAssert(assert);
-    }
-  });
-}
-const $emptyKey = $__namespace.withMetadata($__namespace.metadata("$emptyKey"), $__namespace.constant(undefined));
-const $partialEmptyKey = $__namespace.createShape({
-  metadata: $__namespace.metadata("$partialEmptyKey"),
-  staticSize: 0,
-  subEncode() {},
-  subDecode() {
-    throw new Error("Cannot decode partial key");
-  },
-  subAssert(assert) {
-    if (assert.value != null) {
-      throw new $__namespace.ShapeAssertError(this, assert.value, `${assert.path} != null`);
-    }
-  }
-});
-function $partialSingleKey($inner) {
-  return $__namespace.createShape({
-    metadata: $__namespace.metadata("$partialSingleKey", $partialSingleKey, $inner),
-    staticSize: $inner.staticSize,
-    subEncode(buffer, key) {
-      if (key !== null) $inner.subEncode(buffer, key);
-    },
-    subDecode() {
-      throw new Error("Cannot decode partial key");
-    },
-    subAssert(assert) {
-      if (assert.value === null) return;
-      $inner.subAssert(assert);
-    }
-  });
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-function $partialMultiKey(...codecs) {
-  return $__namespace.createShape({
-    metadata: $__namespace.metadata("$partialMultiKey", $partialMultiKey, ...codecs),
-    staticSize: $__namespace.tuple(...codecs).staticSize,
-    subEncode(buffer, key) {
-      if (!key) return;
-      for (let i = 0; i < key.length; i++) {
-        codecs[i].subEncode(buffer, key[i]);
-      }
-    },
-    subDecode() {
-      throw new Error("Cannot decode partial key");
-    },
-    subAssert(assert) {
-      if (assert.value === null) return;
-      assert.instanceof(this, Array);
-      const assertLength = assert.key(this, "length");
-      assertLength.typeof(this, "number");
-      const length = assertLength.value;
-      $__namespace.tuple(...codecs.slice(0, length)).subAssert(assert);
-    }
-  });
-}
-
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-const hashers = {
-  blake2_128,
-  blake2_256,
-  blake2_128Concat,
-  twox128,
-  twox256,
-  twox64Concat,
-  identity
-};
-const $hasher = $__namespace.literalUnion(["blake2_128", "blake2_256", "blake2_128Concat", "twox128", "twox256", "twox64Concat", "identity"]);
-const $storageEntry = $__namespace.object($__namespace.field("name", $__namespace.str), $__namespace.field("modifier", $__namespace.literalUnion(["Optional", "Default"])), $__namespace.taggedUnion("type", [$__namespace.variant("Plain", $__namespace.field("value", $tyId)), $__namespace.variant("Map", $__namespace.field("hashers", $__namespace.array($hasher)), $__namespace.field("key", $tyId), $__namespace.field("value", $tyId))]), $__namespace.field("default", $__namespace.uint8Array), $__namespace.field("docs", $__namespace.array($__namespace.str)));
-const $constant = $__namespace.object($__namespace.field("name", $__namespace.str), $__namespace.field("ty", $tyId), $__namespace.field("value", $__namespace.uint8Array), $__namespace.field("docs", $__namespace.array($__namespace.str)));
-const $pallet = $__namespace.object($__namespace.field("name", $__namespace.str), $__namespace.optionalField("storage", $__namespace.object($__namespace.field("prefix", $__namespace.str), $__namespace.field("entries", $__namespace.array($storageEntry)))), $__namespace.optionalField("calls", $tyId), $__namespace.optionalField("event", $tyId), $__namespace.field("constants", $__namespace.array($constant)), $__namespace.optionalField("error", $tyId), $__namespace.field("id", $__namespace.u8));
-const $extrinsicDef = $__namespace.object($__namespace.field("ty", $tyId), $__namespace.field("version", $__namespace.u8), $__namespace.field("signedExtensions", $__namespace.array($__namespace.object($__namespace.field("ident", $__namespace.str), $__namespace.field("ty", $tyId), $__namespace.field("additionalSigned", $tyId)))));
-
-// https://docs.substrate.io/build/application-development/#metadata-system
+/** Constant: https://docs.substrate.io/build/application-development/#metadata-format */
 const magicNumber = 1635018093;
-const $metadata = $__namespace.object($__namespace.field("magicNumber", $__namespace.constant(magicNumber, $__namespace.u32)), $__namespace.field("version", $__namespace.constant(14, $__namespace.u8)), $__namespace.field("tys", $__namespace.array($ty)), $__namespace.field("pallets", $__namespace.array($pallet)), $__namespace.field("extrinsic", $extrinsicDef),
-// TODO: is this useful?
-$__namespace.field("runtime", $tyId));
-function transformMetadata(metadata) {
-  const {
-    ids,
-    types,
-    paths
-  } = transformTys(metadata.tys);
-  return {
-    types,
-    paths,
-    pallets: Object.fromEntries(metadata.pallets.map(pallet => [pallet.name, {
-      id: pallet.id,
-      name: pallet.name,
-      storagePrefix: pallet.storage?.prefix ?? pallet.name,
-      storage: Object.fromEntries(pallet.storage?.entries.map(storage => {
-        let key, partialKey;
-        if (storage.type === "Plain") {
-          key = $emptyKey;
-          partialKey = $partialEmptyKey;
-        } else if (storage.hashers.length === 1) {
-          key = hashers[storage.hashers[0]].$hash(ids[storage.key]);
-          partialKey = $partialSingleKey(key);
-        } else {
-          const codecs = extractTupleMembersVisitor.visit(ids[storage.key]).map((codec, i) => hashers[storage.hashers[i]].$hash(codec));
-          key = $__namespace.tuple(...codecs);
-          partialKey = $partialMultiKey(...codecs);
-        }
-        return [storage.name, {
-          singular: storage.type === "Plain",
-          name: storage.name,
-          key: $storageKey(pallet.name, storage.name, key),
-          partialKey: $storageKey(pallet.name, storage.name, partialKey),
-          value: ids[storage.value],
-          docs: normalizeDocs(storage.docs),
-          default: storage.modifier === "Default" ? storage.default : undefined
-        }];
-      }) ?? []),
-      constants: Object.fromEntries(pallet.constants.map(constant => [constant.name, {
-        name: constant.name,
-        codec: ids[constant.ty],
-        value: constant.value,
-        docs: normalizeDocs(constant.docs)
-      }])),
-      types: {
-        call: ids[pallet.calls],
-        error: ids[pallet.error],
-        event: ids[pallet.event]
-      },
-      docs: ""
-    }])),
-    extrinsic: {
-      call: getExtrinsicParameter("call"),
-      signature: getExtrinsicParameter("signature"),
-      address: getExtrinsicParameter("address"),
-      extra: getExtensionsCodec("ty"),
-      additional: getExtensionsCodec("additionalSigned")
-    }
-  };
-  function getExtrinsicParameter(key) {
-    if (!metadata.extrinsic.ty) return $__namespace.never;
-    const extrinsicTy = metadata.tys[metadata.extrinsic.ty];
-    if (!extrinsicTy) return $__namespace.never;
-    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 => {
-      const codec = ids[ext[key]];
-      if (codec === $null) return [];
-      return [$__namespace.field(normalizeIdent(ext.ident), codec)];
-    }) // eslint-disable-line @typescript-eslint/no-explicit-any
-    );
-  }
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const extractTupleMembersVisitor = new $__namespace.ShapeVisitor().add(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-$__namespace.tuple, (_codec, ...members) => members);
-
-/**
- * Adapted from https://github.com/paritytech/capi-old copyright Parity Technologies (APACHE License 2.0)
- * Changes August 19th 2023 :
- * - updated to use subshape for scale decoding
- * - adapted from deno to typescript
- *
-   Copyright 2023 Parity Technologies
-
-   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.
- */
-function decodeMetadata(encoded) {
-  return transformMetadata($metadata.decode(encoded));
-}
-const $metadataV14 = $metadata;
-
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-function $extrinsic(metadata) {
-  const $sig = metadata.extrinsic.signature;
-  const $sigPromise = $__namespace.promise($sig);
-  const $call = metadata.extrinsic.call;
-  const $address = metadata.extrinsic.address;
-  const $extra = metadata.extrinsic.extra;
-  const $additional = metadata.extrinsic.additional;
-  const toSignSize = $call.staticSize + $extra.staticSize + $additional.staticSize;
-  const totalSize = 1 + $address.staticSize + $sig.staticSize + toSignSize;
-  const $baseExtrinsic = $__namespace.createShape({
-    metadata: [],
-    staticSize: totalSize,
-    subEncode(buffer, extrinsic) {
-      const firstByte = +!!extrinsic.signature << 7 | extrinsic.protocolVersion;
-      buffer.array[buffer.index++] = firstByte;
-      const {
-        signature,
-        call
-      } = extrinsic;
-      if (signature) {
-        $address.subEncode(buffer, signature.sender.address);
-        if (signature.additional) {
-          const toSignBuffer = new $__namespace.EncodeBuffer(buffer.stealAlloc(toSignSize));
-          $call.subEncode(toSignBuffer, call);
-          const callEnd = toSignBuffer.finishedSize + toSignBuffer.index;
-          $extra.subEncode(toSignBuffer, signature.extra);
-          const extraEnd = toSignBuffer.finishedSize + toSignBuffer.index;
-          $additional.subEncode(toSignBuffer, signature.additional);
-          const toSignEncoded = toSignBuffer.finish();
-          const callEncoded = toSignEncoded.subarray(0, callEnd);
-          const extraEncoded = toSignEncoded.subarray(callEnd, extraEnd);
-          const toSign = toSignEncoded.length > 256 ? blake2_256.hash(toSignEncoded) : toSignEncoded;
-          const sig = signature.sender.sign(toSign, toSignEncoded);
-          if (sig instanceof Promise) {
-            $sigPromise.subEncode(buffer, sig);
-          } else {
-            $sig.subEncode(buffer, sig);
-          }
-          buffer.insertArray(extraEncoded);
-          buffer.insertArray(callEncoded);
-        } else {
-          $sig.subEncode(buffer, signature.sig);
-          $extra.subEncode(buffer, signature.extra);
-          $call.subEncode(buffer, call);
-        }
-      } else {
-        $call.subEncode(buffer, call);
-      }
-    },
-    subDecode(buffer) {
-      const firstByte = buffer.array[buffer.index++];
-      const hasSignature = firstByte & 1 << 7;
-      const protocolVersion = firstByte & ~(1 << 7);
-      let signature;
-      if (hasSignature) {
-        const address = $address.subDecode(buffer);
-        const sig = $sig.subDecode(buffer);
-        const extra = $extra.subDecode(buffer);
-        signature = {
-          sender: {
-            address
-          },
-          sig,
-          extra
-        };
-      }
-      const call = $call.subDecode(buffer);
-      return {
-        protocolVersion,
-        signature,
-        call
-      };
-    },
-    subAssert(assert) {
-      assert.typeof(this, "object");
-      assert.key(this, "protocolVersion").equals($__namespace.u8, 4);
-      const value_ = assert.value;
-      $call.subAssert(assert.key(this, "call"));
-      if (value_.signature) {
-        const signatureAssertState = assert.key(this, "signature");
-        $address.subAssert(signatureAssertState.key(this, "sender").key(this, "address"));
-        $extra.subAssert(signatureAssertState.key(this, "extra"));
-        if ("additional" in value_.signature) {
-          $additional.subAssert(signatureAssertState.key(this, "additional"));
-          signatureAssertState.key(this, "sender").key(this, "sign").typeof(this, "function");
-        } else {
-          $sig.subAssert(signatureAssertState.key(this, "sig"));
-        }
-      }
-    }
-  });
-  return $__namespace.withMetadata($__namespace.metadata("$extrinsic", $extrinsic, metadata), $__namespace.lenPrefixed($baseExtrinsic));
-}
-class SignerError extends Error {
-  name = "SignerError";
-  constructor(inner) {
-    super();
-    this.inner = inner;
-  }
-}
 
 var packageJson = {
 	name: "@talismn/scale",
-	version: "0.0.2",
+	version: "0.1.0",
 	author: "Talisman",
 	homepage: "https://talisman.xyz",
 	license: "GPL-3.0-or-later",
@@ -1383,27 +38,23 @@ var packageJson = {
 	scripts: {
 		test: "jest",
 		lint: "eslint src --max-warnings 0",
-		clean: "rm -rf dist && rm -rf .turbo rm -rf node_modules"
+		clean: "rm -rf dist .turbo node_modules"
 	},
 	dependencies: {
-		"@talismn/subshape-fork": "^0.0.2",
-		"@talismn/util": "workspace:*",
+		"@polkadot-api/metadata-builders": "0.9.1",
+		"@polkadot-api/substrate-bindings": "0.9.3",
+		"@polkadot-api/utils": "0.1.2",
 		anylogger: "^1.0.11",
-		"wasm-feature-detect": "^1.6.1",
-		"wat-the-crypto": "^0.0.3"
+		"scale-ts": "^1.6.1"
 	},
 	devDependencies: {
-		"@polkadot/util-crypto": "^12.3.2",
 		"@talismn/eslint-config": "workspace:*",
 		"@talismn/tsconfig": "workspace:*",
-		"@types/jest": "^27.5.1",
-		eslint: "^8.52.0",
+		"@types/jest": "^29.5.14",
+		eslint: "^8.57.1",
 		jest: "^29.7",
-		"ts-jest": "^29.1.1",
-		typescript: "^5.2.2"
-	},
-	peerDependencies: {
-		"@polkadot/util-crypto": "12.x"
+		"ts-jest": "^29.2.5",
+		typescript: "^5.6.3"
 	},
 	eslintConfig: {
 		root: true,
@@ -1413,47 +64,51 @@ var packageJson = {
 	}
 };
 
-var log = anylogger__default["default"](packageJson.name);
+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) => {
+/**
+ * Converts a `Metadata` into a `MiniMetadata`.
+ *
+ * A `MiniMetadata` only contains the types inside of its `lookup` which are relevant for
+ * the storage queries specified in `palletsAndItems`.
+ *
+ * E.g. if `palletsAndItems` is `{ pallet: "System", items: ["Account"] }`, then only the
+ * types used in the `System.Account` storage query will remain inside of metadata.lookups.
+ */
+const compactMetadata = (metadata, palletsAndItems, extraKeepTypes) => {
   // remove pallets we don't care about
   metadata.pallets = metadata.pallets.filter(pallet =>
   // keep this pallet if it's listed in `palletsAndItems`
   palletsAndItems.some(({
-    pallet: palletFilter
-  }) => palletFilter(pallet)));
+    pallet: palletName
+  }) => pallet.name === palletName));
 
   // remove fields we don't care about from each pallet, and extract types for each storage item we care about
   const items = palletsAndItems.flatMap(({
-    pallet: palletFilter,
-    items
+    pallet: palletName,
+    items: itemNames
   }) => {
-    const pallet = metadata.pallets.find(palletFilter);
-    if (!pallet || !pallet.storage) {
-      log.debug("Failed to find pallet", palletFilter);
+    const pallet = metadata.pallets.find(pallet => pallet.name === palletName);
+    if (!pallet) {
+      log.debug("Failed to find pallet", palletName);
       return [];
     }
 
-    // remove fields we don't care about
+    // remove pallet fields we don't care about
     pallet.calls = undefined;
     pallet.constants = [];
-    pallet.error = undefined;
-    pallet.event = undefined;
+    // v15 (NOT v14) has docs
+    if ("docs" in pallet) pallet.docs = [];
+    pallet.errors = undefined;
+    pallet.events = undefined;
+    if (!pallet.storage) return [];
 
     // filter and extract storage items we care about
-    pallet.storage.entries = pallet.storage.entries.filter(item => items.some(itemFilter => itemFilter(item)));
-    return pallet.storage.entries;
+    pallet.storage.items = pallet.storage.items.filter(item => itemNames.some(itemName => item.name === itemName));
+    return pallet.storage.items;
   });
 
-  // this is a set of type ids which we plan to keep in our mutated metadata
+  // this is a set of type ids which we plan to keep in our compacted metadata
   // anything not in this set will be deleted
   // we start off with just the types of the state calls we plan to make,
   // then we run those types through a function (addDependentTypes) which will also include
@@ -1462,15 +117,45 @@ const filterMetadataPalletsAndItems = (metadata, palletsAndItems, extraKeepTypes
   // each type can be either "Plain" or "Map"
   // if it's "Plain" we only need to get the value type
   // if it's a "Map" we want to keep both the key AND the value types
-  item.type === "Map" && item.key, item.value]).filter(type => typeof type === "number"));
+  item.type.tag === "plain" && item.type.value, item.type.tag === "map" && item.type.value.key, item.type.tag === "map" && item.type.value.value]).filter(type => typeof type === "number"));
   extraKeepTypes?.forEach(type => keepTypes.add(type));
 
   // recursively find all the types which our keepTypes depend on and add them to the keepTypes set
-  const metadataTysMap = new Map(metadata.tys.map(ty => [ty.id, ty]));
+  const metadataTysMap = new Map(metadata.lookup.map(ty => [ty.id, ty]));
   addDependentTypes(metadataTysMap, keepTypes, [...keepTypes]);
 
   // ditch the types we aren't keeping
-  metadata.tys = metadata.tys.filter(type => keepTypes.has(type.id));
+  metadata.lookup = metadata.lookup.filter(type => keepTypes.has(type.id));
+
+  // update all type ids to be sequential (fill the gaps left by the deleted types)
+  const newTypeIds = new Map();
+  metadata.lookup.forEach((type, index) => newTypeIds.set(type.id, index));
+  const getNewTypeId = oldTypeId => {
+    const newTypeId = newTypeIds.get(oldTypeId);
+    if (typeof newTypeId !== "number") log.error(`Failed to find newTypeId for type ${oldTypeId}`);
+    return newTypeId ?? 0;
+  };
+  remapTypeIds(metadata, getNewTypeId);
+
+  // ditch the remaining data we don't need to keep in a miniMetata
+  if ("apis" in metadata) {
+    // metadata is v15 (NOT v14)
+    metadata.apis = [];
+  }
+  if ("address" in metadata.extrinsic) {
+    // metadata is v15 (NOT v14)
+    metadata.extrinsic.address = 0;
+    metadata.extrinsic.call = 0;
+    metadata.extrinsic.extra = 0;
+    metadata.extrinsic.signature = 0;
+  }
+  metadata.extrinsic.signedExtensions = [];
+  if ("outerEnums" in metadata) {
+    // metadata is v15 (NOT v14)
+    metadata.outerEnums.call = 0;
+    metadata.outerEnums.error = 0;
+    metadata.outerEnums.event = 0;
+  }
 };
 const addDependentTypes = (metadataTysMap, keepTypes, types,
 // Prevent stack overflow when a type references itself
@@ -1485,296 +170,262 @@ addedTypes = new Set()) => {
     if (addedTypes.has(type.id)) continue;
     keepTypes.add(type.id);
     addedTypes.add(type.id);
-    switch (type.type) {
-      case "Struct":
-        addDependentSubTypes([...type.params.map(param => param.ty).filter(ty => typeof ty === "number"), ...type.fields.map(field => field.ty).filter(ty => typeof ty === "number")]);
+    const paramTypes = type.params.map(param => param.type).filter(type => typeof type === "number");
+    addDependentSubTypes(paramTypes);
+    switch (type.def.tag) {
+      case "array":
+        addDependentSubTypes([type.def.value.type]);
         break;
-      case "Union":
-        addDependentSubTypes([...type.params.map(param => param.ty).filter(ty => typeof ty === "number"), ...type.members.flatMap(member => member.fields.map(field => field.ty)).filter(ty => typeof ty === "number")]);
+      case "bitSequence":
+        addDependentSubTypes([type.def.value.bitOrderType, type.def.value.bitStoreType]);
         break;
-      case "Sequence":
-        addDependentSubTypes([...type.params.map(param => param.ty).filter(ty => typeof ty === "number"), type.typeParam]);
+      case "compact":
+        addDependentSubTypes([type.def.value]);
         break;
-      case "SizedArray":
-        addDependentSubTypes([...type.params.map(param => param.ty).filter(ty => typeof ty === "number"), type.typeParam]);
+      case "composite":
+        addDependentSubTypes(type.def.value.map(field => field.type).filter(type => typeof type === "number"));
         break;
-      case "Tuple":
-        addDependentSubTypes([...type.params.map(param => param.ty).filter(ty => typeof ty === "number"), ...type.fields.filter(ty => typeof ty === "number")]);
+      case "primitive":
         break;
-      case "Primitive":
-        addDependentSubTypes([...type.params.map(param => param.ty).filter(ty => typeof ty === "number")]);
+      case "sequence":
+        addDependentSubTypes([type.def.value]);
         break;
-      case "Compact":
-        addDependentSubTypes([...type.params.map(param => param.ty).filter(ty => typeof ty === "number"), type.typeParam]);
+      case "tuple":
+        addDependentSubTypes(type.def.value.filter(type => typeof type === "number"));
         break;
-      case "BitSequence":
-        addDependentSubTypes([type.bitOrderType, type.bitStoreType]);
+      case "variant":
+        addDependentSubTypes(type.def.value.flatMap(member => member.fields.map(field => field.type)).filter(type => typeof type === "number"));
         break;
       default:
         {
           // force compilation error if any types don't have a case
-          const exhaustiveCheck = type;
-          log.error(`Unhandled TyMV14 type ${exhaustiveCheck}`);
+          const exhaustiveCheck = type.def;
+          log.error(`Unhandled V15Type type ${exhaustiveCheck}`);
         }
     }
   }
 };
-
-/**
- * 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)}`;
+const remapTypeIds = (metadata, getNewTypeId) => {
+  remapLookupTypeIds(metadata, getNewTypeId);
+  remapStorageTypeIds(metadata, getNewTypeId);
 };
-
-/**
- * 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}`;
+const remapLookupTypeIds = (metadata, getNewTypeId) => {
+  for (const type of metadata.lookup) {
+    type.id = getNewTypeId(type.id);
+    for (const param of type.params) {
+      if (typeof param.type !== "number") continue;
+      param.type = getNewTypeId(param.type);
+    }
+    switch (type.def.tag) {
+      case "array":
+        type.def.value.type = getNewTypeId(type.def.value.type);
+        break;
+      case "bitSequence":
+        type.def.value.bitOrderType = getNewTypeId(type.def.value.bitOrderType);
+        type.def.value.bitStoreType = getNewTypeId(type.def.value.bitStoreType);
+        break;
+      case "compact":
+        type.def.value = getNewTypeId(type.def.value);
+        break;
+      case "composite":
+        for (const field of type.def.value) {
+          if (typeof field.type !== "number") continue;
+          field.type = getNewTypeId(field.type);
+        }
+        break;
+      case "primitive":
+        break;
+      case "sequence":
+        type.def.value = getNewTypeId(type.def.value);
+        break;
+      case "tuple":
+        type.def.value = type.def.value.map(type => {
+          if (typeof type !== "number") return type;
+          return getNewTypeId(type);
+        });
+        break;
+      case "variant":
+        for (const member of type.def.value) {
+          for (const field of member.fields) {
+            if (typeof field.type !== "number") continue;
+            field.type = getNewTypeId(field.type);
+          }
+        }
+        break;
+      default:
+        {
+          // force compilation error if any types don't have a case
+          const exhaustiveCheck = type.def;
+          log.error(`Unhandled V15Type type ${exhaustiveCheck}`);
+        }
+    }
+  }
+};
+const remapStorageTypeIds = (metadata, getNewTypeId) => {
+  for (const pallet of metadata.pallets) {
+    for (const item of pallet.storage?.items ?? []) {
+      if (item.type.tag === "plain") item.type.value = getNewTypeId(item.type.value);
+      if (item.type.tag === "map") {
+        item.type.value.key = getNewTypeId(item.type.value.key);
+        item.type.value.value = getNewTypeId(item.type.value.value);
+      }
+    }
+  }
 };
-
-/** 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.
+ * Extracts the `version` u8 from a SCALE-encoded metadata blob and returns it as a `number`.
  *
- * 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.
+ * Only reads the first 40 bytes of the blob.
  */
-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 getMetadataVersion = metadataRpc => {
+  try {
+    return scaleTs.Struct({
+      magicNumber: scaleTs.u32,
+      version: scaleTs.u8
+    }).dec(metadataRpc).version;
+  } catch {
+    return 0;
   }
 };
-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 decodeMetadata = metadataRpc => {
+  const metadataVersion = getMetadataVersion(metadataRpc);
+  if (metadataVersion !== 15 && metadataVersion !== 14) return {
+    metadataVersion
+  };
+  const decoded = substrateBindings.metadata.dec(metadataRpc);
+  if (decoded.metadata.tag === "v15") return {
+    metadataVersion,
+    metadata: decoded.metadata.value,
+    tag: decoded.metadata.tag
+  };
+  if (decoded.metadata.tag === "v14") return {
+    metadataVersion,
+    metadata: decoded.metadata.value,
+    tag: decoded.metadata.tag
+  };
+  return {
+    metadataVersion
+  };
 };
-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}`);
+const decodeScale = (scaleCoder, change, error) => {
+  if (change === null) return null;
+  try {
+    return scaleCoder?.dec(change) ?? null;
+  } catch (cause) {
+    log.warn(error ?? `Failed to decode ${change}`, cause);
+    return null;
   }
-
-  // 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`);
+const encodeMetadata = ({
+  metadata,
+  tag
+}) => utils.toHex(substrateBindings.metadata.enc({
+  magicNumber,
+  metadata: tag === "v15" ? {
+    tag,
+    value: metadata
+  } : {
+    tag,
+    value: metadata
+  }
+}));
+
+const encodeStateKey = (scaleCoder, error, ...args) => {
+  try {
+    return scaleCoder?.enc(...args);
+  } catch (cause) {
+    log.warn(error ?? `Failed to encode stateKey ${JSON.stringify(args)}`, cause);
+    return;
   }
-
-  // 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)];
-  })));
+/**
+ * For the substrate-tokens (and other) modules, we configure the `onChainId` field in chaindata to tell the module how to query each token.
+ * These queries are made to the tokens pallet.
+ * E.g. api.query.Tokens.Account(accountAddress, papiParse(onChainId))
+ *
+ * The `onChainId` field on chaindata must be a JSON-parseable string, but for some SCALE types (especially the Binary type) we must
+ * use specific `polkadot-api` classes to handle SCALE-encoding the statekey.
+ *
+ * Some examples:
+ * Input: `5`
+ * Output: `5`
+ *
+ * Input: `{ type: "DexShare", value: [ { type: "Token", value: { type: "ACA" } }, { type: "Token", value: { type: "AUSD" } } ] }`
+ * Output: `Enum("DexShare", [Enum("Token", Enum("ACA")), Enum("Token", Enum("AUSD"))])`
+ *
+ * Input: `{ type: "LiquidCrowdloan", value: 13 }`
+ * Output: `Enum("LiquidCrowdloan", 13)`
+ *
+ * Input: `{ type: "NativeToken", value: "bigint:2" }`
+ * Output: `Enum("NativeToken", 2n)`
+ *
+ * Input: `{ type: "Erc20", value: "hex:0x07df96d1341a7d16ba1ad431e2c847d978bc2bce" }`
+ * Output: `Enum("Erc20", Binary.fromHex("0x07df96d1341a7d16ba1ad431e2c847d978bc2bce"))`
+ *
+ * Input: `{ type: "Stellar", value: { code: "bin:TZS", issuer: "hex:0x34c94b2a4ba9e8b57b22547dcbb30f443c4cb02da3829a89aa1bd4780e4466ba" } }`
+ * Output: `Enum("Stellar", { code: Binary.fromText("TZS"), issuer: Binary.fromHex("0x34c94b2a4ba9e8b57b22547dcbb30f443c4cb02da3829a89aa1bd4780e4466ba") })`
+ */
+const papiParse = text => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const reviver = (_key, value) => {
+    if (typeof value !== "string") return value;
+    if (value.startsWith("bigint:")) return BigInt(value.slice("bigint:".length));
+    if (value.startsWith("hex:")) return substrateBindings.Binary.fromHex(value.slice("hex:".length));
+    if (value.startsWith("bin:")) return substrateBindings.Binary.fromText(value.slice("bin:".length));
+    return value;
+  };
+  if (typeof text !== "string") return text;
+  return JSON.parse(text, reviver);
+};
+const papiStringify = (value, space) => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const replacer = (_key, value) => {
+    if (typeof value === "bigint") return `bigint:${String(value)}`;
+    if (value instanceof substrateBindings.Binary) return `hex:${value.asHex()}`;
+    return value;
+  };
+  return JSON.stringify(value, replacer, space);
 };
 
-// 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;
-exports.$field = $field;
-exports.$hash = $hash;
-exports.$metadataV14 = $metadataV14;
-exports.$null = $null;
-exports.$partialEmptyKey = $partialEmptyKey;
-exports.$partialMultiKey = $partialMultiKey;
-exports.$partialSingleKey = $partialSingleKey;
-exports.$primitiveKind = $primitiveKind;
-exports.$storageKey = $storageKey;
-exports.$ty = $ty;
-exports.$tyDef = $tyDef;
-exports.$tyId = $tyId;
-exports.Blake2Hasher = Blake2Hasher;
-exports.DecodeNonTransparentKeyError = DecodeNonTransparentKeyError;
-exports.Hasher = Hasher;
-exports.IdentityHasher = IdentityHasher;
-exports.SignerError = SignerError;
-exports.TwoxHasher = TwoxHasher;
-exports.addDependentTypes = addDependentTypes;
-exports.blake2_128 = blake2_128;
-exports.blake2_128Concat = blake2_128Concat;
-exports.blake2_256 = blake2_256;
-exports.blake2_512 = blake2_512;
-exports.blake2_64 = blake2_64;
+Object.defineProperty(exports, "getDynamicBuilder", {
+  enumerable: true,
+  get: function () { return metadataBuilders.getDynamicBuilder; }
+});
+Object.defineProperty(exports, "getLookupFn", {
+  enumerable: true,
+  get: function () { return metadataBuilders.getLookupFn; }
+});
+Object.defineProperty(exports, "fromHex", {
+  enumerable: true,
+  get: function () { return utils.fromHex; }
+});
+Object.defineProperty(exports, "toHex", {
+  enumerable: true,
+  get: function () { return utils.toHex; }
+});
+Object.defineProperty(exports, "metadata", {
+  enumerable: true,
+  get: function () { return substrateBindings.metadata; }
+});
+Object.defineProperty(exports, "v14", {
+  enumerable: true,
+  get: function () { return substrateBindings.v14; }
+});
+Object.defineProperty(exports, "v15", {
+  enumerable: true,
+  get: function () { return substrateBindings.v15; }
+});
+exports.compactMetadata = compactMetadata;
 exports.decodeMetadata = decodeMetadata;
-exports.filterMetadataPalletsAndItems = filterMetadataPalletsAndItems;
-exports.getFullTypeName = getFullTypeName;
+exports.decodeScale = decodeScale;
+exports.encodeMetadata = encodeMetadata;
+exports.encodeStateKey = encodeStateKey;
 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;
-exports.normalizePackageName = normalizePackageName;
-exports.normalizeTypeName = normalizeTypeName;
-exports.normalizeVariableName = normalizeVariableName;
-exports.ss58 = ss58;
-exports.stringifyKey = stringifyKey;
-exports.stringifyPropertyAccess = stringifyPropertyAccess;
-exports.transformMetadataV14 = transformMetadata;
-exports.transformTys = transformTys;
-exports.twox128 = twox128;
-exports.twox256 = twox256;
-exports.twox64 = twox64;
-exports.twox64Concat = twox64Concat;
-exports.watCryptoWaitReady = watCryptoWaitReady;
+exports.magicNumber = magicNumber;
+exports.papiParse = papiParse;
+exports.papiStringify = papiStringify;