web-dc-api 0.0.61 → 0.0.62

package/dist/cjs/node_modules/@polkadot/types/create/registry.js

@@ -0,0 +1,531 @@
+'use strict';
+
+var index = require('../extrinsic/signedExtensions/index.js');
+var Event = require('../generic/Event.js');
+var index_types = require('../index.types.js');
+var definitions = require('../interfaces/definitions.js');
+var index$1 = require('../metadata/decorate/extrinsics/index.js');
+var Metadata = require('../metadata/Metadata.js');
+var index$3 = require('../metadata/decorate/constants/index.js');
+var index$2 = require('../metadata/decorate/events/index.js');
+var lazy$1 = require('./lazy.js');
+var PortableRegistry = require('../metadata/PortableRegistry/PortableRegistry.js');
+var assert = require('../../util/assert.js');
+var _class = require('../../types-create/create/class.js');
+var consts = require('../../util/bn/consts.js');
+var asU8a = require('../../util-crypto/blake2/asU8a.js');
+var spread = require('../../util/object/spread.js');
+var Raw = require('../../types-codec/native/Raw.js');
+var Json = require('../../types-codec/native/Json.js');
+var formatBalance = require('../../util/format/formatBalance.js');
+var type = require('../../types-create/create/type.js');
+var u8a = require('../../util/is/u8a.js');
+var logger = require('../../util/logger.js');
+var number = require('../../util/is/number.js');
+var _function = require('../../util/is/function.js');
+var string = require('../../util/is/string.js');
+var stringify = require('../../util/stringify.js');
+var bn = require('../../util/is/bn.js');
+var DoNotConstruct = require('../../types-codec/base/DoNotConstruct.js');
+var camelCase = require('../../util/string/camelCase.js');
+var lazy = require('../../util/lazy.js');
+
+const DEFAULT_FIRST_CALL_IDX = new Uint8Array(2);
+const l = logger.logger('registry');
+function sortDecimalStrings(a, b) {
+  return parseInt(a, 10) - parseInt(b, 10);
+}
+function valueToString(v) {
+  return v.toString();
+}
+function getFieldArgs(lookup, fields) {
+  const count = fields.length;
+  const args = new Array(count);
+  for (let i = 0; i < count; i++) {
+    args[i] = lookup.getTypeDef(fields[i].type).type;
+  }
+  return args;
+}
+function clearRecord(record) {
+  const keys = Object.keys(record);
+  for (let i = 0, count = keys.length; i < count; i++) {
+    delete record[keys[i]];
+  }
+}
+function getVariantStringIdx(_ref) {
+  let {
+    index
+  } = _ref;
+  return index.toString();
+}
+function injectErrors(_, _ref2, version, result) {
+  let {
+    lookup,
+    pallets
+  } = _ref2;
+  clearRecord(result);
+  for (let i = 0, count = pallets.length; i < count; i++) {
+    const {
+      errors,
+      index,
+      name
+    } = pallets[i];
+    if (errors.isSome) {
+      const sectionName = camelCase.stringCamelCase(name);
+      lazy.lazyMethod(result, version >= 12 ? index.toNumber() : i, () => lazy$1.lazyVariants(lookup, errors.unwrap(), getVariantStringIdx, _ref3 => {
+        let {
+          docs,
+          fields,
+          index,
+          name
+        } = _ref3;
+        return {
+          args: getFieldArgs(lookup, fields),
+          docs: docs.map(valueToString),
+          fields,
+          index: index.toNumber(),
+          method: name.toString(),
+          name: name.toString(),
+          section: sectionName
+        };
+      }));
+    }
+  }
+}
+function injectEvents(registry, _ref4, version, result) {
+  let {
+    lookup,
+    pallets
+  } = _ref4;
+  const filtered = pallets.filter(index$2.filterEventsSome);
+  clearRecord(result);
+  for (let i = 0, count = filtered.length; i < count; i++) {
+    const {
+      events,
+      index,
+      name
+    } = filtered[i];
+    lazy.lazyMethod(result, version >= 12 ? index.toNumber() : i, () => lazy$1.lazyVariants(lookup, events.unwrap(), getVariantStringIdx, variant => {
+      const meta = registry.createType('EventMetadataLatest', spread.objectSpread({}, variant, {
+        args: getFieldArgs(lookup, variant.fields)
+      }));
+      return class extends Event.GenericEventData {
+        constructor(registry, value) {
+          super(registry, value, meta, camelCase.stringCamelCase(name), variant.name.toString());
+        }
+      };
+    }));
+  }
+}
+function injectExtrinsics(registry, _ref5, version, result, mapping) {
+  let {
+    lookup,
+    pallets
+  } = _ref5;
+  const filtered = pallets.filter(index$1.filterCallsSome);
+  clearRecord(result);
+  clearRecord(mapping);
+  for (let i = 0, count = filtered.length; i < count; i++) {
+    const {
+      calls,
+      index,
+      name
+    } = filtered[i];
+    const sectionIndex = version >= 12 ? index.toNumber() : i;
+    const sectionName = camelCase.stringCamelCase(name);
+    const allCalls = calls.unwrap();
+    lazy.lazyMethod(result, sectionIndex, () => lazy$1.lazyVariants(lookup, allCalls, getVariantStringIdx, variant => index$1.createCallFunction(registry, lookup, variant, sectionName, sectionIndex)));
+    const {
+      path
+    } = registry.lookup.getSiType(allCalls.type);
+    // frame_system::pallet::Call / pallet_balances::pallet::Call / polkadot_runtime_parachains::configuration::pallet::Call /
+    const palletIdx = path.findIndex(v => v.eq('pallet'));
+    if (palletIdx !== -1) {
+      const name = camelCase.stringCamelCase(path.slice(0, palletIdx).map((p, i) => i === 0
+      // frame_system || pallet_balances
+      ? p.replace(/^(frame|pallet)_/, '') : p).join(' '));
+      if (!mapping[name]) {
+        mapping[name] = [sectionName];
+      } else {
+        mapping[name].push(sectionName);
+      }
+    }
+  }
+}
+function extractProperties(registry, metadata) {
+  const original = registry.getChainProperties();
+  const constants = index$3.decorateConstants(registry, metadata.asLatest, metadata.version);
+  const ss58Format = constants['system'] && (constants['system']['sS58Prefix'] || constants['system']['ss58Prefix']);
+  if (!ss58Format) {
+    return original;
+  }
+  const {
+    isEthereum,
+    tokenDecimals,
+    tokenSymbol
+  } = original || {};
+  return registry.createTypeUnsafe('ChainProperties', [{
+    isEthereum,
+    ss58Format,
+    tokenDecimals,
+    tokenSymbol
+  }]);
+}
+class TypeRegistry {
+  __internal__chainProperties;
+  __internal__classes = (() => new Map())();
+  __internal__definitions = (() => new Map())();
+  __internal__firstCallIndex = null;
+  __internal__hasher = (() => asU8a.blake2AsU8a)();
+  __internal__knownTypes = {};
+  __internal__lookup;
+  __internal__metadata;
+  __internal__metadataVersion = 0;
+  __internal__signedExtensions = (() => index.fallbackExtensions)();
+  __internal__unknownTypes = (() => new Map())();
+  __internal__userExtensions;
+  __internal__knownDefaults;
+  __internal__knownDefaultsEntries;
+  __internal__knownDefinitions;
+  __internal__metadataCalls = {};
+  __internal__metadataErrors = {};
+  __internal__metadataEvents = {};
+  __internal__moduleMap = {};
+  createdAtHash;
+  constructor(createdAtHash) {
+    this.__internal__knownDefaults = spread.objectSpread({
+      Json: Json.Json,
+      Metadata: Metadata.Metadata,
+      PortableRegistry: PortableRegistry.PortableRegistry,
+      Raw: Raw.Raw
+    }, index_types);
+    this.__internal__knownDefaultsEntries = Object.entries(this.__internal__knownDefaults);
+    this.__internal__knownDefinitions = definitions;
+    const allKnown = Object.values(this.__internal__knownDefinitions);
+    for (let i = 0, count = allKnown.length; i < count; i++) {
+      this.register(allKnown[i].types);
+    }
+    if (createdAtHash) {
+      this.createdAtHash = this.createType('BlockHash', createdAtHash);
+    }
+  }
+  get chainDecimals() {
+    if (this.__internal__chainProperties?.tokenDecimals.isSome) {
+      const allDecimals = this.__internal__chainProperties.tokenDecimals.unwrap();
+      if (allDecimals.length) {
+        return allDecimals.map(b => b.toNumber());
+      }
+    }
+    return [12];
+  }
+  get chainIsEthereum() {
+    return this.__internal__chainProperties?.isEthereum.isTrue || false;
+  }
+  get chainSS58() {
+    return this.__internal__chainProperties?.ss58Format.isSome ? this.__internal__chainProperties.ss58Format.unwrap().toNumber() : undefined;
+  }
+  get chainTokens() {
+    if (this.__internal__chainProperties?.tokenSymbol.isSome) {
+      const allTokens = this.__internal__chainProperties.tokenSymbol.unwrap();
+      if (allTokens.length) {
+        return allTokens.map(valueToString);
+      }
+    }
+    return [formatBalance.formatBalance.getDefaults().unit];
+  }
+  get firstCallIndex() {
+    return this.__internal__firstCallIndex || DEFAULT_FIRST_CALL_IDX;
+  }
+  /**
+   * @description Returns true if the type is in a Compat format
+   */
+  isLookupType(value) {
+    return /Lookup\d+$/.test(value);
+  }
+  /**
+   * @description Creates a lookup string from the supplied id
+   */
+  createLookupType(lookupId) {
+    return `Lookup${typeof lookupId === 'number' ? lookupId : lookupId.toNumber()}`;
+  }
+  get knownTypes() {
+    return this.__internal__knownTypes;
+  }
+  get lookup() {
+    return assert.assertReturn(this.__internal__lookup, 'PortableRegistry has not been set on this registry');
+  }
+  get metadata() {
+    return assert.assertReturn(this.__internal__metadata, 'Metadata has not been set on this registry');
+  }
+  get unknownTypes() {
+    return [...this.__internal__unknownTypes.keys()];
+  }
+  get signedExtensions() {
+    return this.__internal__signedExtensions;
+  }
+  clearCache() {
+    this.__internal__classes = new Map();
+  }
+  /**
+   * @describe Creates an instance of the class
+   */
+  createClass(type) {
+    return _class.createClassUnsafe(this, type);
+  }
+  /**
+   * @describe Creates an instance of the class
+   */
+  createClassUnsafe(type) {
+    return _class.createClassUnsafe(this, type);
+  }
+  /**
+   * @description Creates an instance of a type as registered
+   */
+  createType(type$1) {
+    for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      params[_key - 1] = arguments[_key];
+    }
+    return type.createTypeUnsafe(this, type$1, params);
+  }
+  /**
+   * @description Creates an instance of a type as registered
+   */
+  createTypeUnsafe(type$1, params, options) {
+    return type.createTypeUnsafe(this, type$1, params, options);
+  }
+  // find a specific call
+  findMetaCall(callIndex) {
+    const [section, method] = [callIndex[0], callIndex[1]];
+    return assert.assertReturn(this.__internal__metadataCalls[`${section}`] && this.__internal__metadataCalls[`${section}`][`${method}`], () => `findMetaCall: Unable to find Call with index [${section}, ${method}]/[${callIndex.toString()}]`);
+  }
+  // finds an error
+  findMetaError(errorIndex) {
+    const [section, method] = u8a.isU8a(errorIndex) ? [errorIndex[0], errorIndex[1]] : [errorIndex.index.toNumber(), u8a.isU8a(errorIndex.error) ? errorIndex.error[0] : errorIndex.error.toNumber()];
+    return assert.assertReturn(this.__internal__metadataErrors[`${section}`] && this.__internal__metadataErrors[`${section}`][`${method}`], () => `findMetaError: Unable to find Error with index [${section}, ${method}]/[${errorIndex.toString()}]`);
+  }
+  findMetaEvent(eventIndex) {
+    const [section, method] = [eventIndex[0], eventIndex[1]];
+    return assert.assertReturn(this.__internal__metadataEvents[`${section}`] && this.__internal__metadataEvents[`${section}`][`${method}`], () => `findMetaEvent: Unable to find Event with index [${section}, ${method}]/[${eventIndex.toString()}]`);
+  }
+  get(name, withUnknown, knownTypeDef) {
+    return this.getUnsafe(name, withUnknown, knownTypeDef);
+  }
+  getUnsafe(name, withUnknown, knownTypeDef) {
+    let Type = this.__internal__classes.get(name) || this.__internal__knownDefaults[name];
+    // we have not already created the type, attempt it
+    if (!Type) {
+      const definition = this.__internal__definitions.get(name);
+      let BaseType;
+      // we have a definition, so create the class now (lazily)
+      if (definition) {
+        BaseType = _class.createClassUnsafe(this, definition);
+      } else if (knownTypeDef) {
+        BaseType = _class.constructTypeClass(this, knownTypeDef);
+      } else if (withUnknown) {
+        l.warn(`Unable to resolve type ${name}, it will fail on construction`);
+        this.__internal__unknownTypes.set(name, true);
+        BaseType = DoNotConstruct.DoNotConstruct.with(name);
+      }
+      if (BaseType) {
+        // NOTE If we didn't extend here, we would have strange artifacts. An example is
+        // Balance, with this, new Balance() instanceof u128 is true, but Balance !== u128
+        // Additionally, we now pass through the registry, which is a link to ourselves
+        Type = class extends BaseType {};
+        this.__internal__classes.set(name, Type);
+        // In the case of lookups, we also want to store the actual class against
+        // the lookup name, instad of having to traverse again
+        if (knownTypeDef && number.isNumber(knownTypeDef.lookupIndex)) {
+          this.__internal__classes.set(this.createLookupType(knownTypeDef.lookupIndex), Type);
+        }
+      }
+    }
+    return Type;
+  }
+  getChainProperties() {
+    return this.__internal__chainProperties;
+  }
+  getClassName(Type) {
+    // we cannot rely on export order (anymore, since babel/core 7.15.8), so in the case of
+    // items such as u32 & U32, we get the lowercase versions here... not quite as optimal
+    // (previously this used to be a simple find & return)
+    const names = [];
+    for (const [name, Clazz] of this.__internal__knownDefaultsEntries) {
+      if (Type === Clazz) {
+        names.push(name);
+      }
+    }
+    for (const [name, Clazz] of this.__internal__classes.entries()) {
+      if (Type === Clazz) {
+        names.push(name);
+      }
+    }
+    return names.length
+    // both sort and reverse are done in-place
+    // ['U32', 'u32'] -> ['u32', 'U32']
+    ? names.sort().reverse()[0] : undefined;
+  }
+  getDefinition(typeName) {
+    return this.__internal__definitions.get(typeName);
+  }
+  getModuleInstances(specName, moduleName) {
+    return this.__internal__knownTypes?.typesBundle?.spec?.[specName.toString()]?.instances?.[moduleName] || this.__internal__moduleMap[moduleName];
+  }
+  getOrThrow(name) {
+    const Clazz = this.get(name);
+    if (!Clazz) {
+      throw new Error(`type ${name} not found`);
+    }
+    return Clazz;
+  }
+  getOrUnknown(name) {
+    return this.get(name, true);
+  }
+  getSignedExtensionExtra() {
+    return index.expandExtensionTypes(this.__internal__signedExtensions, 'payload', this.__internal__userExtensions);
+  }
+  getSignedExtensionTypes() {
+    return index.expandExtensionTypes(this.__internal__signedExtensions, 'extrinsic', this.__internal__userExtensions);
+  }
+  hasClass(name) {
+    return this.__internal__classes.has(name) || !!this.__internal__knownDefaults[name];
+  }
+  hasDef(name) {
+    return this.__internal__definitions.has(name);
+  }
+  hasType(name) {
+    return !this.__internal__unknownTypes.get(name) && (this.hasClass(name) || this.hasDef(name));
+  }
+  hash(data) {
+    return this.createType('CodecHash', this.__internal__hasher(data));
+  }
+  // eslint-disable-next-line no-dupe-class-members
+  register(arg1, arg2) {
+    // NOTE Constructors appear as functions here
+    if (_function.isFunction(arg1)) {
+      this.__internal__classes.set(arg1.name, arg1);
+    } else if (string.isString(arg1)) {
+      if (!_function.isFunction(arg2)) {
+        throw new Error(`Expected class definition passed to '${arg1}' registration`);
+      } else if (arg1 === arg2.toString()) {
+        throw new Error(`Unable to register circular ${arg1} === ${arg1}`);
+      }
+      this.__internal__classes.set(arg1, arg2);
+    } else {
+      this.__internal__registerObject(arg1);
+    }
+  }
+  __internal__registerObject = obj => {
+    const entries = Object.entries(obj);
+    for (let e = 0, count = entries.length; e < count; e++) {
+      const [name, type] = entries[e];
+      if (_function.isFunction(type)) {
+        // This _looks_ a bit funny, but `typeof Clazz === 'function'
+        this.__internal__classes.set(name, type);
+      } else {
+        const def = string.isString(type) ? type : stringify.stringify(type);
+        if (name === def) {
+          throw new Error(`Unable to register circular ${name} === ${def}`);
+        }
+        // we already have this type, remove the classes registered for it
+        if (this.__internal__classes.has(name)) {
+          this.__internal__classes.delete(name);
+        }
+        this.__internal__definitions.set(name, def);
+      }
+    }
+  };
+  // sets the chain properties
+  setChainProperties(properties) {
+    if (properties) {
+      this.__internal__chainProperties = properties;
+    }
+  }
+  setHasher(hasher) {
+    this.__internal__hasher = hasher || asU8a.blake2AsU8a;
+  }
+  setKnownTypes(knownTypes) {
+    this.__internal__knownTypes = knownTypes;
+  }
+  setLookup(lookup) {
+    this.__internal__lookup = lookup;
+    // register all applicable types found
+    lookup.register();
+  }
+  // register alias types alongside the portable/lookup setup
+  // (we don't combine this into setLookup since that would/could
+  // affect stand-along lookups, such as ABIs which don't have
+  // actual on-chain metadata)
+  __internal__registerLookup = lookup => {
+    // attach the lookup before we register any types
+    this.setLookup(lookup);
+    // we detect based on runtime configuration
+    let Weight = null;
+    if (this.hasType('SpWeightsWeightV2Weight')) {
+      // detection for WeightV2 type based on latest naming
+      const weightv2 = this.createType('SpWeightsWeightV2Weight');
+      Weight = weightv2.refTime && weightv2.proofSize
+      // with both refTime & proofSize we use as-is (WeightV2)
+      ? 'SpWeightsWeightV2Weight'
+      // fallback to WeightV1 (WeightV1.5 is a struct, single field)
+      : 'WeightV1';
+    } else if (!bn.isBn(this.createType('Weight'))) {
+      // where we have an already-supplied BN override, we don't clobber
+      // it with our detected value (This protects against pre-defines
+      // where Weight may be aliassed to WeightV0, e.g. in early Kusama chains)
+      Weight = 'WeightV1';
+    }
+    if (Weight) {
+      // we have detected a version, adjust the definition
+      this.register({
+        Weight
+      });
+    }
+  };
+  // sets the metadata
+  setMetadata(metadata, signedExtensions, userExtensions, noInitWarn) {
+    this.__internal__metadata = metadata.asLatest;
+    this.__internal__metadataVersion = metadata.version;
+    this.__internal__firstCallIndex = null;
+    // attach the lookup at this point and register relevant types (before injecting)
+    this.__internal__registerLookup(this.__internal__metadata.lookup);
+    injectExtrinsics(this, this.__internal__metadata, this.__internal__metadataVersion, this.__internal__metadataCalls, this.__internal__moduleMap);
+    injectErrors(this, this.__internal__metadata, this.__internal__metadataVersion, this.__internal__metadataErrors);
+    injectEvents(this, this.__internal__metadata, this.__internal__metadataVersion, this.__internal__metadataEvents);
+    // set the default call index (the lowest section, the lowest method)
+    // in most chains this should be 0,0
+    const [defSection] = Object.keys(this.__internal__metadataCalls).sort(sortDecimalStrings);
+    if (defSection) {
+      const [defMethod] = Object.keys(this.__internal__metadataCalls[defSection]).sort(sortDecimalStrings);
+      if (defMethod) {
+        this.__internal__firstCallIndex = new Uint8Array([parseInt(defSection, 10), parseInt(defMethod, 10)]);
+      }
+    }
+    // setup the available extensions
+    this.setSignedExtensions(signedExtensions || (this.__internal__metadata.extrinsic.version.gt(consts.BN_ZERO)
+    // FIXME Use the extension and their injected types
+    ? this.__internal__metadata.extrinsic.signedExtensions.map(_ref6 => {
+      let {
+        identifier
+      } = _ref6;
+      return identifier.toString();
+    }) : index.fallbackExtensions), userExtensions, noInitWarn);
+    // setup the chain properties with format overrides
+    this.setChainProperties(extractProperties(this, metadata));
+  }
+  // sets the available signed extensions
+  setSignedExtensions() {
+    let signedExtensions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : index.fallbackExtensions;
+    let userExtensions = arguments.length > 1 ? arguments[1] : undefined;
+    let noInitWarn = arguments.length > 2 ? arguments[2] : undefined;
+    this.__internal__signedExtensions = signedExtensions;
+    this.__internal__userExtensions = userExtensions;
+    if (!noInitWarn) {
+      const unknown = index.findUnknownExtensions(this.__internal__signedExtensions, this.__internal__userExtensions);
+      if (unknown.length) {
+        l.warn(`Unknown signed extensions ${unknown.join(', ')} found, treating them as no-effect`);
+      }
+    }
+  }
+}
+
+exports.TypeRegistry = TypeRegistry;

package/dist/cjs/node_modules/@polkadot/types/ethereum/AccountId.js

@@ -0,0 +1,73 @@
+'use strict';
+
+var isAddress = require('../../util-crypto/ethereum/isAddress.js');
+var U8aFixed = require('../../types-codec/extended/U8aFixed.js');
+var encode = require('../../util-crypto/ethereum/encode.js');
+var u8a = require('../../util/is/u8a.js');
+var toU8a = require('../../util/u8a/toU8a.js');
+var hex = require('../../util/is/hex.js');
+var toU8a$1 = require('../../util/hex/toU8a.js');
+var string = require('../../util/is/string.js');
+
+/** @internal */
+function decodeAccountId(value) {
+  if (u8a.isU8a(value) || Array.isArray(value)) {
+    return toU8a.u8aToU8a(value);
+  } else if (hex.isHex(value) || isAddress.isEthereumAddress(value.toString())) {
+    return toU8a$1.hexToU8a(value.toString());
+  } else if (string.isString(value)) {
+    return toU8a.u8aToU8a(value);
+  }
+  return value;
+}
+/**
+ * @name GenericEthereumAccountId
+ * @description
+ * A wrapper around an Ethereum-compatible AccountId. Since we are dealing with
+ * underlying addresses (20 bytes in length), we extend from U8aFixed which is
+ * just a Uint8Array wrapper with a fixed length.
+ */
+class GenericEthereumAccountId extends U8aFixed.U8aFixed {
+  constructor(registry) {
+    let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Uint8Array();
+    super(registry, decodeAccountId(value), 160);
+  }
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+  eq(other) {
+    return !!other && super.eq(decodeAccountId(other));
+  }
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+  toHuman() {
+    return this.toJSON();
+  }
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+  toJSON() {
+    return this.toString();
+  }
+  /**
+   * @description Converts the value in a best-fit primitive form
+   */
+  toPrimitive() {
+    return this.toJSON();
+  }
+  /**
+   * @description Returns the string representation of the value
+   */
+  toString() {
+    return encode.ethereumEncode(this);
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+  toRawType() {
+    return 'AccountId';
+  }
+}
+
+exports.GenericEthereumAccountId = GenericEthereumAccountId;

package/dist/cjs/node_modules/@polkadot/types/ethereum/LookupSource.js

@@ -0,0 +1,89 @@
+'use strict';
+
+var AccountIndex = require('../generic/AccountIndex.js');
+var AccountId = require('./AccountId.js');
+var Base = require('../../types-codec/abstract/Base.js');
+var toHex = require('../../util/u8a/toHex.js');
+var concat = require('../../util/u8a/concat.js');
+var u8a = require('../../util/is/u8a.js');
+var hex = require('../../util/is/hex.js');
+var toU8a = require('../../util/u8a/toU8a.js');
+var bn = require('../../util/is/bn.js');
+var number = require('../../util/is/number.js');
+var bigInt = require('../../util/is/bigInt.js');
+var toBn = require('../../util/u8a/toBn.js');
+var decode = require('../../util-crypto/address/decode.js');
+
+const ACCOUNT_ID_PREFIX = new Uint8Array([0xff]);
+/** @internal */
+function decodeString(registry, value) {
+  const decoded = decode.decodeAddress(value);
+  return decoded.length === 20 ? registry.createTypeUnsafe('EthereumAccountId', [decoded]) : registry.createTypeUnsafe('AccountIndex', [toBn.u8aToBn(decoded)]);
+}
+/** @internal */
+function decodeU8a(registry, value) {
+  // This allows us to instantiate an address with a raw publicKey. Do this first before
+  // we checking the first byte, otherwise we may split an already-existent valid address
+  if (value.length === 20) {
+    return registry.createTypeUnsafe('EthereumAccountId', [value]);
+  } else if (value[0] === 0xff) {
+    return registry.createTypeUnsafe('EthereumAccountId', [value.subarray(1)]);
+  }
+  const [offset, length] = AccountIndex.GenericAccountIndex.readLength(value);
+  return registry.createTypeUnsafe('AccountIndex', [toBn.u8aToBn(value.subarray(offset, offset + length))]);
+}
+function decodeAddressOrIndex(registry, value) {
+  return value instanceof GenericEthereumLookupSource ? value.inner : value instanceof AccountId.GenericEthereumAccountId || value instanceof AccountIndex.GenericAccountIndex ? value : u8a.isU8a(value) || Array.isArray(value) || hex.isHex(value) ? decodeU8a(registry, toU8a.u8aToU8a(value)) : bn.isBn(value) || number.isNumber(value) || bigInt.isBigInt(value) ? registry.createTypeUnsafe('AccountIndex', [value]) : decodeString(registry, value);
+}
+/**
+ * @name GenericEthereumLookupSource
+ * @description
+ * A wrapper around an EthereumAccountId and/or AccountIndex that is encoded with a prefix.
+ * Since we are dealing with underlying publicKeys (or shorter encoded addresses),
+ * we extend from Base with an AccountId/AccountIndex wrapper. Basically the Address
+ * is encoded as `[ <prefix-byte>, ...publicKey/...bytes ]` as per spec
+ */
+class GenericEthereumLookupSource extends Base.AbstractBase {
+  constructor(registry) {
+    let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Uint8Array();
+    super(registry, decodeAddressOrIndex(registry, value));
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+  get encodedLength() {
+    const rawLength = this._rawLength;
+    return rawLength + (
+    // for 1 byte AccountIndexes, we are not adding a specific prefix
+    rawLength > 1 ? 1 : 0);
+  }
+  /**
+   * @description The length of the raw value, either AccountIndex or AccountId
+   */
+  get _rawLength() {
+    return this.inner instanceof AccountIndex.GenericAccountIndex ? AccountIndex.GenericAccountIndex.calcLength(this.inner) : this.inner.encodedLength;
+  }
+  /**
+   * @description Returns a hex string representation of the value
+   */
+  toHex() {
+    return toHex.u8aToHex(this.toU8a());
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+  toRawType() {
+    return 'Address';
+  }
+  /**
+   * @description Encodes the value as a Uint8Array as per the SCALE specifications
+   * @param isBare true when the value has none of the type-specific prefixes (internal)
+   */
+  toU8a(isBare) {
+    const encoded = this.inner.toU8a().subarray(0, this._rawLength);
+    return isBare ? encoded : concat.u8aConcat(this.inner instanceof AccountIndex.GenericAccountIndex ? AccountIndex.GenericAccountIndex.writeLength(encoded) : ACCOUNT_ID_PREFIX, encoded);
+  }
+}
+
+exports.ACCOUNT_ID_PREFIX = ACCOUNT_ID_PREFIX;
+exports.GenericEthereumLookupSource = GenericEthereumLookupSource;