@hashgraphonline/standards-sdk 0.0.101 → 0.0.103

package/dist/es/standards-sdk.es47.js

@@ -9,433 +9,1284 @@ var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read fr
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _names, _data, _dataLength, _Writer_instances, writeData_fn, _data2, _offset, _bytesRead, _parent, _maxInflation, _Reader_instances, incrementBytesRead_fn, peekBytes_fn;
-import { getNumber, toBigInt, toNumber, toBeArray } from "./standards-sdk.es60.js";
-import { assert, assertArgument } from "./standards-sdk.es44.js";
-import { concat, getBytesCopy, hexlify } from "./standards-sdk.es45.js";
-import { defineProperties } from "./standards-sdk.es58.js";
-const WordSize = 32;
-const Padding = new Uint8Array(WordSize);
-const passProperties = ["then"];
-const _guard = {};
-const resultNames = /* @__PURE__ */ new WeakMap();
-function getNames(result) {
-  return resultNames.get(result);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var _offset, _tokens, _TokenString_instances, subTokenString_fn, _ParamType_instances, walkAsync_fn;
+import { assertPrivate, assert, assertArgument } from "./standards-sdk.es48.js";
+import { defineProperties } from "./standards-sdk.es51.js";
+import { id } from "./standards-sdk.es52.js";
+import { getNumber, getBigInt } from "./standards-sdk.es53.js";
+function setify(items) {
+  const result = /* @__PURE__ */ new Set();
+  items.forEach((k) => result.add(k));
+  return Object.freeze(result);
+}
+const _kwVisibDeploy = "external public payable override";
+const KwVisibDeploy = setify(_kwVisibDeploy.split(" "));
+const _kwVisib = "constant external internal payable private public pure view override";
+const KwVisib = setify(_kwVisib.split(" "));
+const _kwTypes = "constructor error event fallback function receive struct";
+const KwTypes = setify(_kwTypes.split(" "));
+const _kwModifiers = "calldata memory storage payable indexed";
+const KwModifiers = setify(_kwModifiers.split(" "));
+const _kwOther = "tuple returns";
+const _keywords = [_kwTypes, _kwModifiers, _kwOther, _kwVisib].join(" ");
+const Keywords = setify(_keywords.split(" "));
+const SimpleTokens = {
+  "(": "OPEN_PAREN",
+  ")": "CLOSE_PAREN",
+  "[": "OPEN_BRACKET",
+  "]": "CLOSE_BRACKET",
+  ",": "COMMA",
+  "@": "AT"
+};
+const regexWhitespacePrefix = new RegExp("^(\\s*)");
+const regexNumberPrefix = new RegExp("^([0-9]+)");
+const regexIdPrefix = new RegExp("^([a-zA-Z$_][a-zA-Z0-9$_]*)");
+const regexId = new RegExp("^([a-zA-Z$_][a-zA-Z0-9$_]*)$");
+const regexType = new RegExp("^(address|bool|bytes([0-9]*)|string|u?int([0-9]*))$");
+const _TokenString = class _TokenString {
+  constructor(tokens) {
+    __privateAdd(this, _TokenString_instances);
+    __privateAdd(this, _offset);
+    __privateAdd(this, _tokens);
+    __privateSet(this, _offset, 0);
+    __privateSet(this, _tokens, tokens.slice());
+  }
+  get offset() {
+    return __privateGet(this, _offset);
+  }
+  get length() {
+    return __privateGet(this, _tokens).length - __privateGet(this, _offset);
+  }
+  clone() {
+    return new _TokenString(__privateGet(this, _tokens));
+  }
+  reset() {
+    __privateSet(this, _offset, 0);
+  }
+  // Pops and returns the value of the next token, if it is a keyword in allowed; throws if out of tokens
+  popKeyword(allowed) {
+    const top = this.peek();
+    if (top.type !== "KEYWORD" || !allowed.has(top.text)) {
+      throw new Error(`expected keyword ${top.text}`);
+    }
+    return this.pop().text;
+  }
+  // Pops and returns the value of the next token if it is `type`; throws if out of tokens
+  popType(type) {
+    if (this.peek().type !== type) {
+      const top = this.peek();
+      throw new Error(`expected ${type}; got ${top.type} ${JSON.stringify(top.text)}`);
+    }
+    return this.pop().text;
+  }
+  // Pops and returns a "(" TOKENS ")"
+  popParen() {
+    const top = this.peek();
+    if (top.type !== "OPEN_PAREN") {
+      throw new Error("bad start");
+    }
+    const result = __privateMethod(this, _TokenString_instances, subTokenString_fn).call(this, __privateGet(this, _offset) + 1, top.match + 1);
+    __privateSet(this, _offset, top.match + 1);
+    return result;
+  }
+  // Pops and returns the items within "(" ITEM1 "," ITEM2 "," ... ")"
+  popParams() {
+    const top = this.peek();
+    if (top.type !== "OPEN_PAREN") {
+      throw new Error("bad start");
+    }
+    const result = [];
+    while (__privateGet(this, _offset) < top.match - 1) {
+      const link = this.peek().linkNext;
+      result.push(__privateMethod(this, _TokenString_instances, subTokenString_fn).call(this, __privateGet(this, _offset) + 1, link));
+      __privateSet(this, _offset, link);
+    }
+    __privateSet(this, _offset, top.match + 1);
+    return result;
+  }
+  // Returns the top Token, throwing if out of tokens
+  peek() {
+    if (__privateGet(this, _offset) >= __privateGet(this, _tokens).length) {
+      throw new Error("out-of-bounds");
+    }
+    return __privateGet(this, _tokens)[__privateGet(this, _offset)];
+  }
+  // Returns the next value, if it is a keyword in `allowed`
+  peekKeyword(allowed) {
+    const top = this.peekType("KEYWORD");
+    return top != null && allowed.has(top) ? top : null;
+  }
+  // Returns the value of the next token if it is `type`
+  peekType(type) {
+    if (this.length === 0) {
+      return null;
+    }
+    const top = this.peek();
+    return top.type === type ? top.text : null;
+  }
+  // Returns the next token; throws if out of tokens
+  pop() {
+    const result = this.peek();
+    __privateWrapper(this, _offset)._++;
+    return result;
+  }
+  toString() {
+    const tokens = [];
+    for (let i = __privateGet(this, _offset); i < __privateGet(this, _tokens).length; i++) {
+      const token = __privateGet(this, _tokens)[i];
+      tokens.push(`${token.type}:${token.text}`);
+    }
+    return `<TokenString ${tokens.join(" ")}>`;
+  }
+};
+_offset = new WeakMap();
+_tokens = new WeakMap();
+_TokenString_instances = new WeakSet();
+subTokenString_fn = function(from = 0, to = 0) {
+  return new _TokenString(__privateGet(this, _tokens).slice(from, to).map((t) => {
+    return Object.freeze(Object.assign({}, t, {
+      match: t.match - from,
+      linkBack: t.linkBack - from,
+      linkNext: t.linkNext - from
+    }));
+  }));
+};
+let TokenString = _TokenString;
+function lex(text) {
+  const tokens = [];
+  const throwError = (message) => {
+    const token = offset < text.length ? JSON.stringify(text[offset]) : "$EOI";
+    throw new Error(`invalid token ${token} at ${offset}: ${message}`);
+  };
+  let brackets = [];
+  let commas = [];
+  let offset = 0;
+  while (offset < text.length) {
+    let cur = text.substring(offset);
+    let match = cur.match(regexWhitespacePrefix);
+    if (match) {
+      offset += match[1].length;
+      cur = text.substring(offset);
+    }
+    const token = { depth: brackets.length, linkBack: -1, linkNext: -1, match: -1, type: "", text: "", offset, value: -1 };
+    tokens.push(token);
+    let type = SimpleTokens[cur[0]] || "";
+    if (type) {
+      token.type = type;
+      token.text = cur[0];
+      offset++;
+      if (type === "OPEN_PAREN") {
+        brackets.push(tokens.length - 1);
+        commas.push(tokens.length - 1);
+      } else if (type == "CLOSE_PAREN") {
+        if (brackets.length === 0) {
+          throwError("no matching open bracket");
+        }
+        token.match = brackets.pop();
+        tokens[token.match].match = tokens.length - 1;
+        token.depth--;
+        token.linkBack = commas.pop();
+        tokens[token.linkBack].linkNext = tokens.length - 1;
+      } else if (type === "COMMA") {
+        token.linkBack = commas.pop();
+        tokens[token.linkBack].linkNext = tokens.length - 1;
+        commas.push(tokens.length - 1);
+      } else if (type === "OPEN_BRACKET") {
+        token.type = "BRACKET";
+      } else if (type === "CLOSE_BRACKET") {
+        let suffix = tokens.pop().text;
+        if (tokens.length > 0 && tokens[tokens.length - 1].type === "NUMBER") {
+          const value = tokens.pop().text;
+          suffix = value + suffix;
+          tokens[tokens.length - 1].value = getNumber(value);
+        }
+        if (tokens.length === 0 || tokens[tokens.length - 1].type !== "BRACKET") {
+          throw new Error("missing opening bracket");
+        }
+        tokens[tokens.length - 1].text += suffix;
+      }
+      continue;
+    }
+    match = cur.match(regexIdPrefix);
+    if (match) {
+      token.text = match[1];
+      offset += token.text.length;
+      if (Keywords.has(token.text)) {
+        token.type = "KEYWORD";
+        continue;
+      }
+      if (token.text.match(regexType)) {
+        token.type = "TYPE";
+        continue;
+      }
+      token.type = "ID";
+      continue;
+    }
+    match = cur.match(regexNumberPrefix);
+    if (match) {
+      token.text = match[1];
+      token.type = "NUMBER";
+      offset += token.text.length;
+      continue;
+    }
+    throw new Error(`unexpected token ${JSON.stringify(cur[0])} at position ${offset}`);
+  }
+  return new TokenString(tokens.map((t) => Object.freeze(t)));
 }
-function setNames(result, names) {
-  resultNames.set(result, names);
+function allowSingle(set, allowed) {
+  let included = [];
+  for (const key in allowed.keys()) {
+    if (set.has(key)) {
+      included.push(key);
+    }
+  }
+  if (included.length > 1) {
+    throw new Error(`conflicting types: ${included.join(", ")}`);
+  }
 }
-function throwError(name, error) {
-  const wrapped = new Error(`deferred error during ABI decoding triggered accessing ${name}`);
-  wrapped.error = error;
-  throw wrapped;
+function consumeName(type, tokens) {
+  if (tokens.peekKeyword(KwTypes)) {
+    const keyword = tokens.pop().text;
+    if (keyword !== type) {
+      throw new Error(`expected ${type}, got ${keyword}`);
+    }
+  }
+  return tokens.popType("ID");
 }
-function toObject(names, items, deep) {
-  if (names.indexOf(null) >= 0) {
-    return items.map((item, index) => {
-      if (item instanceof Result) {
-        return toObject(getNames(item), item, deep);
-      }
-      return item;
-    });
+function consumeKeywords(tokens, allowed) {
+  const keywords = /* @__PURE__ */ new Set();
+  while (true) {
+    const keyword = tokens.peekType("KEYWORD");
+    if (keyword == null || allowed && !allowed.has(keyword)) {
+      break;
+    }
+    tokens.pop();
+    if (keywords.has(keyword)) {
+      throw new Error(`duplicate keywords: ${JSON.stringify(keyword)}`);
+    }
+    keywords.add(keyword);
   }
-  return names.reduce((accum, name, index) => {
-    let item = items.getValue(name);
-    if (!(name in accum)) {
-      if (deep && item instanceof Result) {
-        item = toObject(getNames(item), item, deep);
-      }
-      accum[name] = item;
+  return Object.freeze(keywords);
+}
+function consumeMutability(tokens) {
+  let modifiers = consumeKeywords(tokens, KwVisib);
+  allowSingle(modifiers, setify("constant payable nonpayable".split(" ")));
+  allowSingle(modifiers, setify("pure view payable nonpayable".split(" ")));
+  if (modifiers.has("view")) {
+    return "view";
+  }
+  if (modifiers.has("pure")) {
+    return "pure";
+  }
+  if (modifiers.has("payable")) {
+    return "payable";
+  }
+  if (modifiers.has("nonpayable")) {
+    return "nonpayable";
+  }
+  if (modifiers.has("constant")) {
+    return "view";
+  }
+  return "nonpayable";
+}
+function consumeParams(tokens, allowIndexed) {
+  return tokens.popParams().map((t) => ParamType.from(t, allowIndexed));
+}
+function consumeGas(tokens) {
+  if (tokens.peekType("AT")) {
+    tokens.pop();
+    if (tokens.peekType("NUMBER")) {
+      return getBigInt(tokens.pop().text);
     }
-    return accum;
-  }, {});
+    throw new Error("invalid gas");
+  }
+  return null;
+}
+function consumeEoi(tokens) {
+  if (tokens.length) {
+    throw new Error(`unexpected tokens at offset ${tokens.offset}: ${tokens.toString()}`);
+  }
+}
+const regexArrayType = new RegExp(/^(.*)\[([0-9]*)\]$/);
+function verifyBasicType(type) {
+  const match = type.match(regexType);
+  assertArgument(match, "invalid type", "type", type);
+  if (type === "uint") {
+    return "uint256";
+  }
+  if (type === "int") {
+    return "int256";
+  }
+  if (match[2]) {
+    const length = parseInt(match[2]);
+    assertArgument(length !== 0 && length <= 32, "invalid bytes length", "type", type);
+  } else if (match[3]) {
+    const size = parseInt(match[3]);
+    assertArgument(size !== 0 && size <= 256 && size % 8 === 0, "invalid numeric width", "type", type);
+  }
+  return type;
 }
-const _Result = class _Result extends Array {
+const _guard = {};
+const internal = Symbol.for("_ethers_internal");
+const ParamTypeInternal = "_ParamTypeInternal";
+const ErrorFragmentInternal = "_ErrorInternal";
+const EventFragmentInternal = "_EventInternal";
+const ConstructorFragmentInternal = "_ConstructorInternal";
+const FallbackFragmentInternal = "_FallbackInternal";
+const FunctionFragmentInternal = "_FunctionInternal";
+const StructFragmentInternal = "_StructInternal";
+const _ParamType = class _ParamType {
   /**
    *  @private
    */
-  constructor(...args) {
-    const guard = args[0];
-    let items = args[1];
-    let names = (args[2] || []).slice();
-    let wrap = true;
-    if (guard !== _guard) {
-      items = args;
-      names = [];
-      wrap = false;
-    }
-    super(items.length);
-    // No longer used; but cannot be removed as it will remove the
-    // #private field from the .d.ts which may break backwards
-    // compatibility
-    __privateAdd(this, _names);
-    items.forEach((item, index) => {
-      this[index] = item;
-    });
-    const nameCounts = names.reduce((accum, name) => {
-      if (typeof name === "string") {
-        accum.set(name, (accum.get(name) || 0) + 1);
-      }
-      return accum;
-    }, /* @__PURE__ */ new Map());
-    setNames(this, Object.freeze(items.map((item, index) => {
-      const name = names[index];
-      if (name != null && nameCounts.get(name) === 1) {
-        return name;
+  constructor(guard, name, type, baseType, indexed, components, arrayLength, arrayChildren) {
+    __privateAdd(this, _ParamType_instances);
+    /**
+     *  The local name of the parameter (or ``""`` if unbound)
+     */
+    __publicField(this, "name");
+    /**
+     *  The fully qualified type (e.g. ``"address"``, ``"tuple(address)"``,
+     *  ``"uint256[3][]"``)
+     */
+    __publicField(this, "type");
+    /**
+     *  The base type (e.g. ``"address"``, ``"tuple"``, ``"array"``)
+     */
+    __publicField(this, "baseType");
+    /**
+     *  True if the parameters is indexed.
+     *
+     *  For non-indexable types this is ``null``.
+     */
+    __publicField(this, "indexed");
+    /**
+     *  The components for the tuple.
+     *
+     *  For non-tuple types this is ``null``.
+     */
+    __publicField(this, "components");
+    /**
+     *  The array length, or ``-1`` for dynamic-lengthed arrays.
+     *
+     *  For non-array types this is ``null``.
+     */
+    __publicField(this, "arrayLength");
+    /**
+     *  The type of each child in the array.
+     *
+     *  For non-array types this is ``null``.
+     */
+    __publicField(this, "arrayChildren");
+    assertPrivate(guard, _guard, "ParamType");
+    Object.defineProperty(this, internal, { value: ParamTypeInternal });
+    if (components) {
+      components = Object.freeze(components.slice());
+    }
+    if (baseType === "array") {
+      if (arrayLength == null || arrayChildren == null) {
+        throw new Error("");
       }
-      return null;
-    })));
-    __privateSet(this, _names, []);
-    if (__privateGet(this, _names) == null) {
-      void __privateGet(this, _names);
-    }
-    if (!wrap) {
-      return;
-    }
-    Object.freeze(this);
-    const proxy = new Proxy(this, {
-      get: (target, prop, receiver) => {
-        if (typeof prop === "string") {
-          if (prop.match(/^[0-9]+$/)) {
-            const index = getNumber(prop, "%index");
-            if (index < 0 || index >= this.length) {
-              throw new RangeError("out of result range");
-            }
-            const item = target[index];
-            if (item instanceof Error) {
-              throwError(`index ${index}`, item);
-            }
-            return item;
-          }
-          if (passProperties.indexOf(prop) >= 0) {
-            return Reflect.get(target, prop, receiver);
-          }
-          const value = target[prop];
-          if (value instanceof Function) {
-            return function(...args2) {
-              return value.apply(this === receiver ? target : this, args2);
-            };
-          } else if (!(prop in target)) {
-            return target.getValue.apply(this === receiver ? target : this, [prop]);
-          }
-        }
-        return Reflect.get(target, prop, receiver);
+    } else if (arrayLength != null || arrayChildren != null) {
+      throw new Error("");
+    }
+    if (baseType === "tuple") {
+      if (components == null) {
+        throw new Error("");
       }
+    } else if (components != null) {
+      throw new Error("");
+    }
+    defineProperties(this, {
+      name,
+      type,
+      baseType,
+      indexed,
+      components,
+      arrayLength,
+      arrayChildren
     });
-    setNames(proxy, getNames(this));
-    return proxy;
   }
   /**
-   *  Returns the Result as a normal Array. If %%deep%%, any children
-   *  which are Result objects are also converted to a normal Array.
+   *  Return a string representation of this type.
+   *
+   *  For example,
+   *
+   *  ``sighash" => "(uint256,address)"``
    *
-   *  This will throw if there are any outstanding deferred
-   *  errors.
+   *  ``"minimal" => "tuple(uint256,address) indexed"``
+   *
+   *  ``"full" => "tuple(uint256 foo, address bar) indexed baz"``
    */
-  toArray(deep) {
-    const result = [];
-    this.forEach((item, index) => {
-      if (item instanceof Error) {
-        throwError(`index ${index}`, item);
+  format(format) {
+    if (format == null) {
+      format = "sighash";
+    }
+    if (format === "json") {
+      const name = this.name || "";
+      if (this.isArray()) {
+        const result3 = JSON.parse(this.arrayChildren.format("json"));
+        result3.name = name;
+        result3.type += `[${this.arrayLength < 0 ? "" : String(this.arrayLength)}]`;
+        return JSON.stringify(result3);
       }
-      if (deep && item instanceof _Result) {
-        item = item.toArray(deep);
+      const result2 = {
+        type: this.baseType === "tuple" ? "tuple" : this.type,
+        name
+      };
+      if (typeof this.indexed === "boolean") {
+        result2.indexed = this.indexed;
       }
-      result.push(item);
-    });
+      if (this.isTuple()) {
+        result2.components = this.components.map((c) => JSON.parse(c.format(format)));
+      }
+      return JSON.stringify(result2);
+    }
+    let result = "";
+    if (this.isArray()) {
+      result += this.arrayChildren.format(format);
+      result += `[${this.arrayLength < 0 ? "" : String(this.arrayLength)}]`;
+    } else {
+      if (this.isTuple()) {
+        result += "(" + this.components.map((comp) => comp.format(format)).join(format === "full" ? ", " : ",") + ")";
+      } else {
+        result += this.type;
+      }
+    }
+    if (format !== "sighash") {
+      if (this.indexed === true) {
+        result += " indexed";
+      }
+      if (format === "full" && this.name) {
+        result += " " + this.name;
+      }
+    }
     return result;
   }
   /**
-   *  Returns the Result as an Object with each name-value pair. If
-   *  %%deep%%, any children which are Result objects are also
-   *  converted to an Object.
+   *  Returns true if %%this%% is an Array type.
    *
-   *  This will throw if any value is unnamed, or if there are
-   *  any outstanding deferred errors.
-   */
-  toObject(deep) {
-    const names = getNames(this);
-    return names.reduce((accum, name, index) => {
-      assert(name != null, `value at index ${index} unnamed`, "UNSUPPORTED_OPERATION", {
-        operation: "toObject()"
-      });
-      return toObject(names, this, deep);
-    }, {});
+   *  This provides a type gaurd ensuring that [[arrayChildren]]
+   *  and [[arrayLength]] are non-null.
+   */
+  isArray() {
+    return this.baseType === "array";
+  }
+  /**
+   *  Returns true if %%this%% is a Tuple type.
+   *
+   *  This provides a type gaurd ensuring that [[components]]
+   *  is non-null.
+   */
+  isTuple() {
+    return this.baseType === "tuple";
+  }
+  /**
+   *  Returns true if %%this%% is an Indexable type.
+   *
+   *  This provides a type gaurd ensuring that [[indexed]]
+   *  is non-null.
+   */
+  isIndexable() {
+    return this.indexed != null;
   }
   /**
-   *  @_ignore
+   *  Walks the **ParamType** with %%value%%, calling %%process%%
+   *  on each type, destructing the %%value%% recursively.
    */
-  slice(start, end) {
-    if (start == null) {
-      start = 0;
+  walk(value, process) {
+    if (this.isArray()) {
+      if (!Array.isArray(value)) {
+        throw new Error("invalid array value");
+      }
+      if (this.arrayLength !== -1 && value.length !== this.arrayLength) {
+        throw new Error("array is wrong length");
+      }
+      const _this = this;
+      return value.map((v) => _this.arrayChildren.walk(v, process));
     }
-    if (start < 0) {
-      start += this.length;
-      if (start < 0) {
-        start = 0;
+    if (this.isTuple()) {
+      if (!Array.isArray(value)) {
+        throw new Error("invalid tuple value");
+      }
+      if (value.length !== this.components.length) {
+        throw new Error("array is wrong length");
       }
+      const _this = this;
+      return value.map((v, i) => _this.components[i].walk(v, process));
     }
-    if (end == null) {
-      end = this.length;
+    return process(this.type, value);
+  }
+  /**
+   *  Walks the **ParamType** with %%value%%, asynchronously calling
+   *  %%process%% on each type, destructing the %%value%% recursively.
+   *
+   *  This can be used to resolve ENS names by walking and resolving each
+   *  ``"address"`` type.
+   */
+  async walkAsync(value, process) {
+    const promises = [];
+    const result = [value];
+    __privateMethod(this, _ParamType_instances, walkAsync_fn).call(this, promises, value, process, (value2) => {
+      result[0] = value2;
+    });
+    if (promises.length) {
+      await Promise.all(promises);
     }
-    if (end < 0) {
-      end += this.length;
-      if (end < 0) {
-        end = 0;
+    return result[0];
+  }
+  /**
+   *  Creates a new **ParamType** for %%obj%%.
+   *
+   *  If %%allowIndexed%% then the ``indexed`` keyword is permitted,
+   *  otherwise the ``indexed`` keyword will throw an error.
+   */
+  static from(obj, allowIndexed) {
+    if (_ParamType.isParamType(obj)) {
+      return obj;
+    }
+    if (typeof obj === "string") {
+      try {
+        return _ParamType.from(lex(obj), allowIndexed);
+      } catch (error) {
+        assertArgument(false, "invalid param type", "obj", obj);
+      }
+    } else if (obj instanceof TokenString) {
+      let type2 = "", baseType = "";
+      let comps = null;
+      if (consumeKeywords(obj, setify(["tuple"])).has("tuple") || obj.peekType("OPEN_PAREN")) {
+        baseType = "tuple";
+        comps = obj.popParams().map((t) => _ParamType.from(t));
+        type2 = `tuple(${comps.map((c) => c.format()).join(",")})`;
+      } else {
+        type2 = verifyBasicType(obj.popType("TYPE"));
+        baseType = type2;
+      }
+      let arrayChildren = null;
+      let arrayLength = null;
+      while (obj.length && obj.peekType("BRACKET")) {
+        const bracket = obj.pop();
+        arrayChildren = new _ParamType(_guard, "", type2, baseType, null, comps, arrayLength, arrayChildren);
+        arrayLength = bracket.value;
+        type2 += bracket.text;
+        baseType = "array";
+        comps = null;
+      }
+      let indexed2 = null;
+      const keywords = consumeKeywords(obj, KwModifiers);
+      if (keywords.has("indexed")) {
+        if (!allowIndexed) {
+          throw new Error("");
+        }
+        indexed2 = true;
+      }
+      const name2 = obj.peekType("ID") ? obj.pop().text : "";
+      if (obj.length) {
+        throw new Error("leftover tokens");
       }
+      return new _ParamType(_guard, name2, type2, baseType, indexed2, comps, arrayLength, arrayChildren);
     }
-    if (end > this.length) {
-      end = this.length;
+    const name = obj.name;
+    assertArgument(!name || typeof name === "string" && name.match(regexId), "invalid name", "obj.name", name);
+    let indexed = obj.indexed;
+    if (indexed != null) {
+      assertArgument(allowIndexed, "parameter cannot be indexed", "obj.indexed", obj.indexed);
+      indexed = !!indexed;
     }
-    const _names2 = getNames(this);
-    const result = [], names = [];
-    for (let i = start; i < end; i++) {
-      result.push(this[i]);
-      names.push(_names2[i]);
+    let type = obj.type;
+    let arrayMatch = type.match(regexArrayType);
+    if (arrayMatch) {
+      const arrayLength = parseInt(arrayMatch[2] || "-1");
+      const arrayChildren = _ParamType.from({
+        type: arrayMatch[1],
+        components: obj.components
+      });
+      return new _ParamType(_guard, name || "", type, "array", indexed, null, arrayLength, arrayChildren);
+    }
+    if (type === "tuple" || type.startsWith(
+      "tuple("
+      /* fix: ) */
+    ) || type.startsWith(
+      "("
+      /* fix: ) */
+    )) {
+      const comps = obj.components != null ? obj.components.map((c) => _ParamType.from(c)) : null;
+      const tuple = new _ParamType(_guard, name || "", type, "tuple", indexed, comps, null, null);
+      return tuple;
     }
-    return new _Result(_guard, result, names);
+    type = verifyBasicType(obj.type);
+    return new _ParamType(_guard, name || "", type, type, indexed, null, null, null);
   }
   /**
-   *  @_ignore
+   *  Returns true if %%value%% is a **ParamType**.
    */
-  filter(callback, thisArg) {
-    const _names2 = getNames(this);
-    const result = [], names = [];
-    for (let i = 0; i < this.length; i++) {
-      const item = this[i];
-      if (item instanceof Error) {
-        throwError(`index ${i}`, item);
+  static isParamType(value) {
+    return value && value[internal] === ParamTypeInternal;
+  }
+};
+_ParamType_instances = new WeakSet();
+walkAsync_fn = function(promises, value, process, setValue) {
+  if (this.isArray()) {
+    if (!Array.isArray(value)) {
+      throw new Error("invalid array value");
+    }
+    if (this.arrayLength !== -1 && value.length !== this.arrayLength) {
+      throw new Error("array is wrong length");
+    }
+    const childType = this.arrayChildren;
+    const result2 = value.slice();
+    result2.forEach((value2, index) => {
+      var _a;
+      __privateMethod(_a = childType, _ParamType_instances, walkAsync_fn).call(_a, promises, value2, process, (value3) => {
+        result2[index] = value3;
+      });
+    });
+    setValue(result2);
+    return;
+  }
+  if (this.isTuple()) {
+    const components = this.components;
+    let result2;
+    if (Array.isArray(value)) {
+      result2 = value.slice();
+    } else {
+      if (value == null || typeof value !== "object") {
+        throw new Error("invalid tuple value");
+      }
+      result2 = components.map((param) => {
+        if (!param.name) {
+          throw new Error("cannot use object value with unnamed components");
+        }
+        if (!(param.name in value)) {
+          throw new Error(`missing value for component ${param.name}`);
+        }
+        return value[param.name];
+      });
+    }
+    if (result2.length !== this.components.length) {
+      throw new Error("array is wrong length");
+    }
+    result2.forEach((value2, index) => {
+      var _a;
+      __privateMethod(_a = components[index], _ParamType_instances, walkAsync_fn).call(_a, promises, value2, process, (value3) => {
+        result2[index] = value3;
+      });
+    });
+    setValue(result2);
+    return;
+  }
+  const result = process(this.type, value);
+  if (result.then) {
+    promises.push(async function() {
+      setValue(await result);
+    }());
+  } else {
+    setValue(result);
+  }
+};
+let ParamType = _ParamType;
+class Fragment {
+  /**
+   *  @private
+   */
+  constructor(guard, type, inputs) {
+    /**
+     *  The type of the fragment.
+     */
+    __publicField(this, "type");
+    /**
+     *  The inputs for the fragment.
+     */
+    __publicField(this, "inputs");
+    assertPrivate(guard, _guard, "Fragment");
+    inputs = Object.freeze(inputs.slice());
+    defineProperties(this, { type, inputs });
+  }
+  /**
+   *  Creates a new **Fragment** for %%obj%%, wich can be any supported
+   *  ABI frgament type.
+   */
+  static from(obj) {
+    if (typeof obj === "string") {
+      try {
+        Fragment.from(JSON.parse(obj));
+      } catch (e) {
+      }
+      return Fragment.from(lex(obj));
+    }
+    if (obj instanceof TokenString) {
+      const type = obj.peekKeyword(KwTypes);
+      switch (type) {
+        case "constructor":
+          return ConstructorFragment.from(obj);
+        case "error":
+          return ErrorFragment.from(obj);
+        case "event":
+          return EventFragment.from(obj);
+        case "fallback":
+        case "receive":
+          return FallbackFragment.from(obj);
+        case "function":
+          return FunctionFragment.from(obj);
+        case "struct":
+          return StructFragment.from(obj);
       }
-      if (callback.call(thisArg, item, i, this)) {
-        result.push(item);
-        names.push(_names2[i]);
+    } else if (typeof obj === "object") {
+      switch (obj.type) {
+        case "constructor":
+          return ConstructorFragment.from(obj);
+        case "error":
+          return ErrorFragment.from(obj);
+        case "event":
+          return EventFragment.from(obj);
+        case "fallback":
+        case "receive":
+          return FallbackFragment.from(obj);
+        case "function":
+          return FunctionFragment.from(obj);
+        case "struct":
+          return StructFragment.from(obj);
       }
+      assert(false, `unsupported type: ${obj.type}`, "UNSUPPORTED_OPERATION", {
+        operation: "Fragment.from"
+      });
     }
-    return new _Result(_guard, result, names);
+    assertArgument(false, "unsupported frgament object", "obj", obj);
+  }
+  /**
+   *  Returns true if %%value%% is a [[ConstructorFragment]].
+   */
+  static isConstructor(value) {
+    return ConstructorFragment.isFragment(value);
+  }
+  /**
+   *  Returns true if %%value%% is an [[ErrorFragment]].
+   */
+  static isError(value) {
+    return ErrorFragment.isFragment(value);
+  }
+  /**
+   *  Returns true if %%value%% is an [[EventFragment]].
+   */
+  static isEvent(value) {
+    return EventFragment.isFragment(value);
+  }
+  /**
+   *  Returns true if %%value%% is a [[FunctionFragment]].
+   */
+  static isFunction(value) {
+    return FunctionFragment.isFragment(value);
+  }
+  /**
+   *  Returns true if %%value%% is a [[StructFragment]].
+   */
+  static isStruct(value) {
+    return StructFragment.isFragment(value);
+  }
+}
+class NamedFragment extends Fragment {
+  /**
+   *  @private
+   */
+  constructor(guard, type, name, inputs) {
+    super(guard, type, inputs);
+    /**
+     *  The name of the fragment.
+     */
+    __publicField(this, "name");
+    assertArgument(typeof name === "string" && name.match(regexId), "invalid identifier", "name", name);
+    inputs = Object.freeze(inputs.slice());
+    defineProperties(this, { name });
+  }
+}
+function joinParams(format, params) {
+  return "(" + params.map((p) => p.format(format)).join(format === "full" ? ", " : ",") + ")";
+}
+class ErrorFragment extends NamedFragment {
+  /**
+   *  @private
+   */
+  constructor(guard, name, inputs) {
+    super(guard, "error", name, inputs);
+    Object.defineProperty(this, internal, { value: ErrorFragmentInternal });
+  }
+  /**
+   *  The Custom Error selector.
+   */
+  get selector() {
+    return id(this.format("sighash")).substring(0, 10);
   }
   /**
-   *  @_ignore
+   *  Returns a string representation of this fragment as %%format%%.
    */
-  map(callback, thisArg) {
+  format(format) {
+    if (format == null) {
+      format = "sighash";
+    }
+    if (format === "json") {
+      return JSON.stringify({
+        type: "error",
+        name: this.name,
+        inputs: this.inputs.map((input) => JSON.parse(input.format(format)))
+      });
+    }
     const result = [];
-    for (let i = 0; i < this.length; i++) {
-      const item = this[i];
-      if (item instanceof Error) {
-        throwError(`index ${i}`, item);
-      }
-      result.push(callback.call(thisArg, item, i, this));
+    if (format !== "sighash") {
+      result.push("error");
     }
-    return result;
+    result.push(this.name + joinParams(format, this.inputs));
+    return result.join(" ");
   }
   /**
-   *  Returns the value for %%name%%.
-   *
-   *  Since it is possible to have a key whose name conflicts with
-   *  a method on a [[Result]] or its superclass Array, or any
-   *  JavaScript keyword, this ensures all named values are still
-   *  accessible by name.
+   *  Returns a new **ErrorFragment** for %%obj%%.
    */
-  getValue(name) {
-    const index = getNames(this).indexOf(name);
-    if (index === -1) {
-      return void 0;
+  static from(obj) {
+    if (ErrorFragment.isFragment(obj)) {
+      return obj;
     }
-    const value = this[index];
-    if (value instanceof Error) {
-      throwError(`property ${JSON.stringify(name)}`, value.error);
+    if (typeof obj === "string") {
+      return ErrorFragment.from(lex(obj));
+    } else if (obj instanceof TokenString) {
+      const name = consumeName("error", obj);
+      const inputs = consumeParams(obj);
+      consumeEoi(obj);
+      return new ErrorFragment(_guard, name, inputs);
     }
-    return value;
+    return new ErrorFragment(_guard, obj.name, obj.inputs ? obj.inputs.map(ParamType.from) : []);
   }
   /**
-   *  Creates a new [[Result]] for %%items%% with each entry
-   *  also accessible by its corresponding name in %%keys%%.
+   *  Returns ``true`` and provides a type guard if %%value%% is an
+   *  **ErrorFragment**.
    */
-  static fromItems(items, keys) {
-    return new _Result(_guard, items, keys);
+  static isFragment(value) {
+    return value && value[internal] === ErrorFragmentInternal;
   }
-};
-_names = new WeakMap();
-let Result = _Result;
-function getValue(value) {
-  let bytes = toBeArray(value);
-  assert(bytes.length <= WordSize, "value out-of-bounds", "BUFFER_OVERRUN", { buffer: bytes, length: WordSize, offset: bytes.length });
-  if (bytes.length !== WordSize) {
-    bytes = getBytesCopy(concat([Padding.slice(bytes.length % WordSize), bytes]));
-  }
-  return bytes;
 }
-class Coder {
-  constructor(name, type, localName, dynamic) {
-    // The coder name:
-    //   - address, uint256, tuple, array, etc.
-    __publicField(this, "name");
-    // The fully expanded type, including composite types:
-    //   - address, uint256, tuple(address,bytes), uint256[3][4][],  etc.
-    __publicField(this, "type");
-    // The localName bound in the signature, in this example it is "baz":
-    //   - tuple(address foo, uint bar) baz
-    __publicField(this, "localName");
-    // Whether this type is dynamic:
-    //  - Dynamic: bytes, string, address[], tuple(boolean[]), etc.
-    //  - Not Dynamic: address, uint256, boolean[3], tuple(address, uint8)
-    __publicField(this, "dynamic");
-    defineProperties(this, { name, type, localName, dynamic }, {
-      name: "string",
-      type: "string",
-      localName: "string",
-      dynamic: "boolean"
-    });
+class EventFragment extends NamedFragment {
+  /**
+   *  @private
+   */
+  constructor(guard, name, inputs, anonymous) {
+    super(guard, "event", name, inputs);
+    /**
+     *  Whether this event is anonymous.
+     */
+    __publicField(this, "anonymous");
+    Object.defineProperty(this, internal, { value: EventFragmentInternal });
+    defineProperties(this, { anonymous });
   }
-  _throwError(message, value) {
-    assertArgument(false, message, this.localName, value);
+  /**
+   *  The Event topic hash.
+   */
+  get topicHash() {
+    return id(this.format("sighash"));
   }
-}
-class Writer {
-  constructor() {
-    __privateAdd(this, _Writer_instances);
-    // An array of WordSize lengthed objects to concatenation
-    __privateAdd(this, _data);
-    __privateAdd(this, _dataLength);
-    __privateSet(this, _data, []);
-    __privateSet(this, _dataLength, 0);
-  }
-  get data() {
-    return concat(__privateGet(this, _data));
+  /**
+   *  Returns a string representation of this event as %%format%%.
+   */
+  format(format) {
+    if (format == null) {
+      format = "sighash";
+    }
+    if (format === "json") {
+      return JSON.stringify({
+        type: "event",
+        anonymous: this.anonymous,
+        name: this.name,
+        inputs: this.inputs.map((i) => JSON.parse(i.format(format)))
+      });
+    }
+    const result = [];
+    if (format !== "sighash") {
+      result.push("event");
+    }
+    result.push(this.name + joinParams(format, this.inputs));
+    if (format !== "sighash" && this.anonymous) {
+      result.push("anonymous");
+    }
+    return result.join(" ");
   }
-  get length() {
-    return __privateGet(this, _dataLength);
-  }
-  appendWriter(writer) {
-    return __privateMethod(this, _Writer_instances, writeData_fn).call(this, getBytesCopy(writer.data));
-  }
-  // Arrayish item; pad on the right to *nearest* WordSize
-  writeBytes(value) {
-    let bytes = getBytesCopy(value);
-    const paddingOffset = bytes.length % WordSize;
-    if (paddingOffset) {
-      bytes = getBytesCopy(concat([bytes, Padding.slice(paddingOffset)]));
-    }
-    return __privateMethod(this, _Writer_instances, writeData_fn).call(this, bytes);
-  }
-  // Numeric item; pad on the left *to* WordSize
-  writeValue(value) {
-    return __privateMethod(this, _Writer_instances, writeData_fn).call(this, getValue(value));
-  }
-  // Inserts a numeric place-holder, returning a callback that can
-  // be used to asjust the value later
-  writeUpdatableValue() {
-    const offset = __privateGet(this, _data).length;
-    __privateGet(this, _data).push(Padding);
-    __privateSet(this, _dataLength, __privateGet(this, _dataLength) + WordSize);
-    return (value) => {
-      __privateGet(this, _data)[offset] = getValue(value);
-    };
+  /**
+   *  Return the topic hash for an event with %%name%% and %%params%%.
+   */
+  static getTopicHash(name, params) {
+    params = (params || []).map((p) => ParamType.from(p));
+    const fragment = new EventFragment(_guard, name, params, false);
+    return fragment.topicHash;
+  }
+  /**
+   *  Returns a new **EventFragment** for %%obj%%.
+   */
+  static from(obj) {
+    if (EventFragment.isFragment(obj)) {
+      return obj;
+    }
+    if (typeof obj === "string") {
+      try {
+        return EventFragment.from(lex(obj));
+      } catch (error) {
+        assertArgument(false, "invalid event fragment", "obj", obj);
+      }
+    } else if (obj instanceof TokenString) {
+      const name = consumeName("event", obj);
+      const inputs = consumeParams(obj, true);
+      const anonymous = !!consumeKeywords(obj, setify(["anonymous"])).has("anonymous");
+      consumeEoi(obj);
+      return new EventFragment(_guard, name, inputs, anonymous);
+    }
+    return new EventFragment(_guard, obj.name, obj.inputs ? obj.inputs.map((p) => ParamType.from(p, true)) : [], !!obj.anonymous);
+  }
+  /**
+   *  Returns ``true`` and provides a type guard if %%value%% is an
+   *  **EventFragment**.
+   */
+  static isFragment(value) {
+    return value && value[internal] === EventFragmentInternal;
   }
 }
-_data = new WeakMap();
-_dataLength = new WeakMap();
-_Writer_instances = new WeakSet();
-writeData_fn = function(data) {
-  __privateGet(this, _data).push(data);
-  __privateSet(this, _dataLength, __privateGet(this, _dataLength) + data.length);
-  return data.length;
-};
-const _Reader = class _Reader {
-  constructor(data, allowLoose, maxInflation) {
-    __privateAdd(this, _Reader_instances);
-    // Allows incomplete unpadded data to be read; otherwise an error
-    // is raised if attempting to overrun the buffer. This is required
-    // to deal with an old Solidity bug, in which event data for
-    // external (not public thoguh) was tightly packed.
-    __publicField(this, "allowLoose");
-    __privateAdd(this, _data2);
-    __privateAdd(this, _offset);
-    __privateAdd(this, _bytesRead);
-    __privateAdd(this, _parent);
-    __privateAdd(this, _maxInflation);
-    defineProperties(this, { allowLoose: !!allowLoose });
-    __privateSet(this, _data2, getBytesCopy(data));
-    __privateSet(this, _bytesRead, 0);
-    __privateSet(this, _parent, null);
-    __privateSet(this, _maxInflation, maxInflation != null ? maxInflation : 1024);
-    __privateSet(this, _offset, 0);
+class ConstructorFragment extends Fragment {
+  /**
+   *  @private
+   */
+  constructor(guard, type, inputs, payable, gas) {
+    super(guard, type, inputs);
+    /**
+     *  Whether the constructor can receive an endowment.
+     */
+    __publicField(this, "payable");
+    /**
+     *  The recommended gas limit for deployment or ``null``.
+     */
+    __publicField(this, "gas");
+    Object.defineProperty(this, internal, { value: ConstructorFragmentInternal });
+    defineProperties(this, { payable, gas });
   }
-  get data() {
-    return hexlify(__privateGet(this, _data2));
+  /**
+   *  Returns a string representation of this constructor as %%format%%.
+   */
+  format(format) {
+    assert(format != null && format !== "sighash", "cannot format a constructor for sighash", "UNSUPPORTED_OPERATION", { operation: "format(sighash)" });
+    if (format === "json") {
+      return JSON.stringify({
+        type: "constructor",
+        stateMutability: this.payable ? "payable" : "undefined",
+        payable: this.payable,
+        gas: this.gas != null ? this.gas : void 0,
+        inputs: this.inputs.map((i) => JSON.parse(i.format(format)))
+      });
+    }
+    const result = [`constructor${joinParams(format, this.inputs)}`];
+    if (this.payable) {
+      result.push("payable");
+    }
+    if (this.gas != null) {
+      result.push(`@${this.gas.toString()}`);
+    }
+    return result.join(" ");
   }
-  get dataLength() {
-    return __privateGet(this, _data2).length;
+  /**
+   *  Returns a new **ConstructorFragment** for %%obj%%.
+   */
+  static from(obj) {
+    if (ConstructorFragment.isFragment(obj)) {
+      return obj;
+    }
+    if (typeof obj === "string") {
+      try {
+        return ConstructorFragment.from(lex(obj));
+      } catch (error) {
+        assertArgument(false, "invalid constuctor fragment", "obj", obj);
+      }
+    } else if (obj instanceof TokenString) {
+      consumeKeywords(obj, setify(["constructor"]));
+      const inputs = consumeParams(obj);
+      const payable = !!consumeKeywords(obj, KwVisibDeploy).has("payable");
+      const gas = consumeGas(obj);
+      consumeEoi(obj);
+      return new ConstructorFragment(_guard, "constructor", inputs, payable, gas);
+    }
+    return new ConstructorFragment(_guard, "constructor", obj.inputs ? obj.inputs.map(ParamType.from) : [], !!obj.payable, obj.gas != null ? obj.gas : null);
   }
-  get consumed() {
-    return __privateGet(this, _offset);
+  /**
+   *  Returns ``true`` and provides a type guard if %%value%% is a
+   *  **ConstructorFragment**.
+   */
+  static isFragment(value) {
+    return value && value[internal] === ConstructorFragmentInternal;
+  }
+}
+class FallbackFragment extends Fragment {
+  constructor(guard, inputs, payable) {
+    super(guard, "fallback", inputs);
+    /**
+     *  If the function can be sent value during invocation.
+     */
+    __publicField(this, "payable");
+    Object.defineProperty(this, internal, { value: FallbackFragmentInternal });
+    defineProperties(this, { payable });
   }
-  get bytes() {
-    return new Uint8Array(__privateGet(this, _data2));
+  /**
+   *  Returns a string representation of this fallback as %%format%%.
+   */
+  format(format) {
+    const type = this.inputs.length === 0 ? "receive" : "fallback";
+    if (format === "json") {
+      const stateMutability = this.payable ? "payable" : "nonpayable";
+      return JSON.stringify({ type, stateMutability });
+    }
+    return `${type}()${this.payable ? " payable" : ""}`;
   }
-  // Create a sub-reader with the same underlying data, but offset
-  subReader(offset) {
-    const reader = new _Reader(__privateGet(this, _data2).slice(__privateGet(this, _offset) + offset), this.allowLoose, __privateGet(this, _maxInflation));
-    __privateSet(reader, _parent, this);
-    return reader;
+  /**
+   *  Returns a new **FallbackFragment** for %%obj%%.
+   */
+  static from(obj) {
+    if (FallbackFragment.isFragment(obj)) {
+      return obj;
+    }
+    if (typeof obj === "string") {
+      try {
+        return FallbackFragment.from(lex(obj));
+      } catch (error) {
+        assertArgument(false, "invalid fallback fragment", "obj", obj);
+      }
+    } else if (obj instanceof TokenString) {
+      const errorObj = obj.toString();
+      const topIsValid = obj.peekKeyword(setify(["fallback", "receive"]));
+      assertArgument(topIsValid, "type must be fallback or receive", "obj", errorObj);
+      const type = obj.popKeyword(setify(["fallback", "receive"]));
+      if (type === "receive") {
+        const inputs2 = consumeParams(obj);
+        assertArgument(inputs2.length === 0, `receive cannot have arguments`, "obj.inputs", inputs2);
+        consumeKeywords(obj, setify(["payable"]));
+        consumeEoi(obj);
+        return new FallbackFragment(_guard, [], true);
+      }
+      let inputs = consumeParams(obj);
+      if (inputs.length) {
+        assertArgument(inputs.length === 1 && inputs[0].type === "bytes", "invalid fallback inputs", "obj.inputs", inputs.map((i) => i.format("minimal")).join(", "));
+      } else {
+        inputs = [ParamType.from("bytes")];
+      }
+      const mutability = consumeMutability(obj);
+      assertArgument(mutability === "nonpayable" || mutability === "payable", "fallback cannot be constants", "obj.stateMutability", mutability);
+      if (consumeKeywords(obj, setify(["returns"])).has("returns")) {
+        const outputs = consumeParams(obj);
+        assertArgument(outputs.length === 1 && outputs[0].type === "bytes", "invalid fallback outputs", "obj.outputs", outputs.map((i) => i.format("minimal")).join(", "));
+      }
+      consumeEoi(obj);
+      return new FallbackFragment(_guard, inputs, mutability === "payable");
+    }
+    if (obj.type === "receive") {
+      return new FallbackFragment(_guard, [], true);
+    }
+    if (obj.type === "fallback") {
+      const inputs = [ParamType.from("bytes")];
+      const payable = obj.stateMutability === "payable";
+      return new FallbackFragment(_guard, inputs, payable);
+    }
+    assertArgument(false, "invalid fallback description", "obj", obj);
   }
-  // Read bytes
-  readBytes(length, loose) {
-    let bytes = __privateMethod(this, _Reader_instances, peekBytes_fn).call(this, 0, length, !!loose);
-    __privateMethod(this, _Reader_instances, incrementBytesRead_fn).call(this, length);
-    __privateSet(this, _offset, __privateGet(this, _offset) + bytes.length);
-    return bytes.slice(0, length);
+  /**
+   *  Returns ``true`` and provides a type guard if %%value%% is a
+   *  **FallbackFragment**.
+   */
+  static isFragment(value) {
+    return value && value[internal] === FallbackFragmentInternal;
   }
-  // Read a numeric values
-  readValue() {
-    return toBigInt(this.readBytes(WordSize));
+}
+class FunctionFragment extends NamedFragment {
+  /**
+   *  @private
+   */
+  constructor(guard, name, stateMutability, inputs, outputs, gas) {
+    super(guard, "function", name, inputs);
+    /**
+     *  If the function is constant (e.g. ``pure`` or ``view`` functions).
+     */
+    __publicField(this, "constant");
+    /**
+     *  The returned types for the result of calling this function.
+     */
+    __publicField(this, "outputs");
+    /**
+     *  The state mutability (e.g. ``payable``, ``nonpayable``, ``view``
+     *  or ``pure``)
+     */
+    __publicField(this, "stateMutability");
+    /**
+     *  If the function can be sent value during invocation.
+     */
+    __publicField(this, "payable");
+    /**
+     *  The recommended gas limit to send when calling this function.
+     */
+    __publicField(this, "gas");
+    Object.defineProperty(this, internal, { value: FunctionFragmentInternal });
+    outputs = Object.freeze(outputs.slice());
+    const constant = stateMutability === "view" || stateMutability === "pure";
+    const payable = stateMutability === "payable";
+    defineProperties(this, { constant, gas, outputs, payable, stateMutability });
   }
-  readIndex() {
-    return toNumber(this.readBytes(WordSize));
+  /**
+   *  The Function selector.
+   */
+  get selector() {
+    return id(this.format("sighash")).substring(0, 10);
   }
-};
-_data2 = new WeakMap();
-_offset = new WeakMap();
-_bytesRead = new WeakMap();
-_parent = new WeakMap();
-_maxInflation = new WeakMap();
-_Reader_instances = new WeakSet();
-incrementBytesRead_fn = function(count) {
-  var _a;
-  if (__privateGet(this, _parent)) {
-    return __privateMethod(_a = __privateGet(this, _parent), _Reader_instances, incrementBytesRead_fn).call(_a, count);
-  }
-  __privateSet(this, _bytesRead, __privateGet(this, _bytesRead) + count);
-  assert(__privateGet(this, _maxInflation) < 1 || __privateGet(this, _bytesRead) <= __privateGet(this, _maxInflation) * this.dataLength, `compressed ABI data exceeds inflation ratio of ${__privateGet(this, _maxInflation)} ( see: https://github.com/ethers-io/ethers.js/issues/4537 )`, "BUFFER_OVERRUN", {
-    buffer: getBytesCopy(__privateGet(this, _data2)),
-    offset: __privateGet(this, _offset),
-    length: count,
-    info: {
-      bytesRead: __privateGet(this, _bytesRead),
-      dataLength: this.dataLength
-    }
-  });
-};
-peekBytes_fn = function(offset, length, loose) {
-  let alignedLength = Math.ceil(length / WordSize) * WordSize;
-  if (__privateGet(this, _offset) + alignedLength > __privateGet(this, _data2).length) {
-    if (this.allowLoose && loose && __privateGet(this, _offset) + length <= __privateGet(this, _data2).length) {
-      alignedLength = length;
-    } else {
-      assert(false, "data out-of-bounds", "BUFFER_OVERRUN", {
-        buffer: getBytesCopy(__privateGet(this, _data2)),
-        length: __privateGet(this, _data2).length,
-        offset: __privateGet(this, _offset) + alignedLength
+  /**
+   *  Returns a string representation of this function as %%format%%.
+   */
+  format(format) {
+    if (format == null) {
+      format = "sighash";
+    }
+    if (format === "json") {
+      return JSON.stringify({
+        type: "function",
+        name: this.name,
+        constant: this.constant,
+        stateMutability: this.stateMutability !== "nonpayable" ? this.stateMutability : void 0,
+        payable: this.payable,
+        gas: this.gas != null ? this.gas : void 0,
+        inputs: this.inputs.map((i) => JSON.parse(i.format(format))),
+        outputs: this.outputs.map((o) => JSON.parse(o.format(format)))
       });
     }
+    const result = [];
+    if (format !== "sighash") {
+      result.push("function");
+    }
+    result.push(this.name + joinParams(format, this.inputs));
+    if (format !== "sighash") {
+      if (this.stateMutability !== "nonpayable") {
+        result.push(this.stateMutability);
+      }
+      if (this.outputs && this.outputs.length) {
+        result.push("returns");
+        result.push(joinParams(format, this.outputs));
+      }
+      if (this.gas != null) {
+        result.push(`@${this.gas.toString()}`);
+      }
+    }
+    return result.join(" ");
   }
-  return __privateGet(this, _data2).slice(__privateGet(this, _offset), __privateGet(this, _offset) + alignedLength);
-};
-let Reader = _Reader;
+  /**
+   *  Return the selector for a function with %%name%% and %%params%%.
+   */
+  static getSelector(name, params) {
+    params = (params || []).map((p) => ParamType.from(p));
+    const fragment = new FunctionFragment(_guard, name, "view", params, [], null);
+    return fragment.selector;
+  }
+  /**
+   *  Returns a new **FunctionFragment** for %%obj%%.
+   */
+  static from(obj) {
+    if (FunctionFragment.isFragment(obj)) {
+      return obj;
+    }
+    if (typeof obj === "string") {
+      try {
+        return FunctionFragment.from(lex(obj));
+      } catch (error) {
+        assertArgument(false, "invalid function fragment", "obj", obj);
+      }
+    } else if (obj instanceof TokenString) {
+      const name = consumeName("function", obj);
+      const inputs = consumeParams(obj);
+      const mutability = consumeMutability(obj);
+      let outputs = [];
+      if (consumeKeywords(obj, setify(["returns"])).has("returns")) {
+        outputs = consumeParams(obj);
+      }
+      const gas = consumeGas(obj);
+      consumeEoi(obj);
+      return new FunctionFragment(_guard, name, mutability, inputs, outputs, gas);
+    }
+    let stateMutability = obj.stateMutability;
+    if (stateMutability == null) {
+      stateMutability = "payable";
+      if (typeof obj.constant === "boolean") {
+        stateMutability = "view";
+        if (!obj.constant) {
+          stateMutability = "payable";
+          if (typeof obj.payable === "boolean" && !obj.payable) {
+            stateMutability = "nonpayable";
+          }
+        }
+      } else if (typeof obj.payable === "boolean" && !obj.payable) {
+        stateMutability = "nonpayable";
+      }
+    }
+    return new FunctionFragment(_guard, obj.name, stateMutability, obj.inputs ? obj.inputs.map(ParamType.from) : [], obj.outputs ? obj.outputs.map(ParamType.from) : [], obj.gas != null ? obj.gas : null);
+  }
+  /**
+   *  Returns ``true`` and provides a type guard if %%value%% is a
+   *  **FunctionFragment**.
+   */
+  static isFragment(value) {
+    return value && value[internal] === FunctionFragmentInternal;
+  }
+}
+class StructFragment extends NamedFragment {
+  /**
+   *  @private
+   */
+  constructor(guard, name, inputs) {
+    super(guard, "struct", name, inputs);
+    Object.defineProperty(this, internal, { value: StructFragmentInternal });
+  }
+  /**
+   *  Returns a string representation of this struct as %%format%%.
+   */
+  format() {
+    throw new Error("@TODO");
+  }
+  /**
+   *  Returns a new **StructFragment** for %%obj%%.
+   */
+  static from(obj) {
+    if (typeof obj === "string") {
+      try {
+        return StructFragment.from(lex(obj));
+      } catch (error) {
+        assertArgument(false, "invalid struct fragment", "obj", obj);
+      }
+    } else if (obj instanceof TokenString) {
+      const name = consumeName("struct", obj);
+      const inputs = consumeParams(obj);
+      consumeEoi(obj);
+      return new StructFragment(_guard, name, inputs);
+    }
+    return new StructFragment(_guard, obj.name, obj.inputs ? obj.inputs.map(ParamType.from) : []);
+  }
+  // @TODO: fix this return type
+  /**
+   *  Returns ``true`` and provides a type guard if %%value%% is a
+   *  **StructFragment**.
+   */
+  static isFragment(value) {
+    return value && value[internal] === StructFragmentInternal;
+  }
+}
 export {
-  Coder,
-  Reader,
-  Result,
-  WordSize,
-  Writer
+  ConstructorFragment,
+  ErrorFragment,
+  EventFragment,
+  FallbackFragment,
+  Fragment,
+  FunctionFragment,
+  NamedFragment,
+  ParamType,
+  StructFragment
 };
 //# sourceMappingURL=standards-sdk.es47.js.map