@hashgraphonline/standards-sdk 0.0.105 → 0.0.107

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

@@ -1,47 +1,142 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { Typed } from "./standards-sdk.es55.js";
-import { Coder, WordSize } from "./standards-sdk.es41.js";
-import { defineProperties } from "./standards-sdk.es52.js";
-import { getBigInt, mask, toTwos, fromTwos } from "./standards-sdk.es54.js";
-const BN_0 = BigInt(0);
-const BN_1 = BigInt(1);
-const BN_MAX_UINT256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-class NumberCoder extends Coder {
-  constructor(size, signed, localName) {
-    const name = (signed ? "int" : "uint") + size * 8;
-    super(name, name, localName, false);
-    __publicField(this, "size");
-    __publicField(this, "signed");
-    defineProperties(this, { size, signed }, { size: "number", signed: "boolean" });
+import { Typed } from "./standards-sdk.es62.js";
+import { Coder, WordSize, Writer, Result } from "./standards-sdk.es46.js";
+import { AnonymousCoder } from "./standards-sdk.es67.js";
+import { defineProperties } from "./standards-sdk.es59.js";
+import { assertArgumentCount, assert, assertArgument, isError } from "./standards-sdk.es57.js";
+function pack(writer, coders, values) {
+  let arrayValues = [];
+  if (Array.isArray(values)) {
+    arrayValues = values;
+  } else if (values && typeof values === "object") {
+    let unique = {};
+    arrayValues = coders.map((coder) => {
+      const name = coder.localName;
+      assert(name, "cannot encode object for signature with missing names", "INVALID_ARGUMENT", { argument: "values", info: { coder }, value: values });
+      assert(!unique[name], "cannot encode object for signature with duplicate names", "INVALID_ARGUMENT", { argument: "values", info: { coder }, value: values });
+      unique[name] = true;
+      return values[name];
+    });
+  } else {
+    assertArgument(false, "invalid tuple value", "tuple", values);
+  }
+  assertArgument(coders.length === arrayValues.length, "types/value length mismatch", "tuple", values);
+  let staticWriter = new Writer();
+  let dynamicWriter = new Writer();
+  let updateFuncs = [];
+  coders.forEach((coder, index) => {
+    let value = arrayValues[index];
+    if (coder.dynamic) {
+      let dynamicOffset = dynamicWriter.length;
+      coder.encode(dynamicWriter, value);
+      let updateFunc = staticWriter.writeUpdatableValue();
+      updateFuncs.push((baseOffset) => {
+        updateFunc(baseOffset + dynamicOffset);
+      });
+    } else {
+      coder.encode(staticWriter, value);
+    }
+  });
+  updateFuncs.forEach((func) => {
+    func(staticWriter.length);
+  });
+  let length = writer.appendWriter(staticWriter);
+  length += writer.appendWriter(dynamicWriter);
+  return length;
+}
+function unpack(reader, coders) {
+  let values = [];
+  let keys = [];
+  let baseReader = reader.subReader(0);
+  coders.forEach((coder) => {
+    let value = null;
+    if (coder.dynamic) {
+      let offset = reader.readIndex();
+      let offsetReader = baseReader.subReader(offset);
+      try {
+        value = coder.decode(offsetReader);
+      } catch (error) {
+        if (isError(error, "BUFFER_OVERRUN")) {
+          throw error;
+        }
+        value = error;
+        value.baseType = coder.name;
+        value.name = coder.localName;
+        value.type = coder.type;
+      }
+    } else {
+      try {
+        value = coder.decode(reader);
+      } catch (error) {
+        if (isError(error, "BUFFER_OVERRUN")) {
+          throw error;
+        }
+        value = error;
+        value.baseType = coder.name;
+        value.name = coder.localName;
+        value.type = coder.type;
+      }
+    }
+    if (value == void 0) {
+      throw new Error("investigate");
+    }
+    values.push(value);
+    keys.push(coder.localName || null);
+  });
+  return Result.fromItems(values, keys);
+}
+class ArrayCoder extends Coder {
+  constructor(coder, length, localName) {
+    const type = coder.type + "[" + (length >= 0 ? length : "") + "]";
+    const dynamic = length === -1 || coder.dynamic;
+    super("array", type, localName, dynamic);
+    __publicField(this, "coder");
+    __publicField(this, "length");
+    defineProperties(this, { coder, length });
   }
   defaultValue() {
-    return 0;
+    const defaultChild = this.coder.defaultValue();
+    const result = [];
+    for (let i = 0; i < this.length; i++) {
+      result.push(defaultChild);
+    }
+    return result;
   }
   encode(writer, _value) {
-    let value = getBigInt(Typed.dereference(_value, this.type));
-    let maxUintValue = mask(BN_MAX_UINT256, WordSize * 8);
-    if (this.signed) {
-      let bounds = mask(maxUintValue, this.size * 8 - 1);
-      if (value > bounds || value < -(bounds + BN_1)) {
-        this._throwError("value out-of-bounds", _value);
-      }
-      value = toTwos(value, 8 * WordSize);
-    } else if (value < BN_0 || value > mask(maxUintValue, this.size * 8)) {
-      this._throwError("value out-of-bounds", _value);
+    const value = Typed.dereference(_value, "array");
+    if (!Array.isArray(value)) {
+      this._throwError("expected array value", value);
     }
-    return writer.writeValue(value);
+    let count = this.length;
+    if (count === -1) {
+      count = value.length;
+      writer.writeValue(value.length);
+    }
+    assertArgumentCount(value.length, count, "coder array" + (this.localName ? " " + this.localName : ""));
+    let coders = [];
+    for (let i = 0; i < value.length; i++) {
+      coders.push(this.coder);
+    }
+    return pack(writer, coders, value);
   }
   decode(reader) {
-    let value = mask(reader.readValue(), this.size * 8);
-    if (this.signed) {
-      value = fromTwos(value, this.size * 8);
+    let count = this.length;
+    if (count === -1) {
+      count = reader.readIndex();
+      assert(count * WordSize <= reader.dataLength, "insufficient data length", "BUFFER_OVERRUN", { buffer: reader.bytes, offset: count * WordSize, length: reader.dataLength });
+    }
+    let coders = [];
+    for (let i = 0; i < count; i++) {
+      coders.push(new AnonymousCoder(this.coder));
     }
-    return value;
+    return unpack(reader, coders);
   }
 }
 export {
-  NumberCoder
+  ArrayCoder,
+  pack,
+  unpack
 };
 //# sourceMappingURL=standards-sdk.es48.js.map

package/dist/es/standards-sdk.es48.js.map

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es48.js","sources":["../../node_modules/ethers/lib.esm/abi/coders/number.js"],"sourcesContent":["import { defineProperties, fromTwos, getBigInt, mask, toTwos } from \"../../utils/index.js\";\nimport { Typed } from \"../typed.js\";\nimport { Coder, WordSize } from \"./abstract-coder.js\";\nconst BN_0 = BigInt(0);\nconst BN_1 = BigInt(1);\nconst BN_MAX_UINT256 = BigInt(\"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\");\n/**\n *  @_ignore\n */\nexport class NumberCoder extends Coder {\n    size;\n    signed;\n    constructor(size, signed, localName) {\n        const name = ((signed ? \"int\" : \"uint\") + (size * 8));\n        super(name, name, localName, false);\n        defineProperties(this, { size, signed }, { size: \"number\", signed: \"boolean\" });\n    }\n    defaultValue() {\n        return 0;\n    }\n    encode(writer, _value) {\n        let value = getBigInt(Typed.dereference(_value, this.type));\n        // Check bounds are safe for encoding\n        let maxUintValue = mask(BN_MAX_UINT256, WordSize * 8);\n        if (this.signed) {\n            let bounds = mask(maxUintValue, (this.size * 8) - 1);\n            if (value > bounds || value < -(bounds + BN_1)) {\n                this._throwError(\"value out-of-bounds\", _value);\n            }\n            value = toTwos(value, 8 * WordSize);\n        }\n        else if (value < BN_0 || value > mask(maxUintValue, this.size * 8)) {\n            this._throwError(\"value out-of-bounds\", _value);\n        }\n        return writer.writeValue(value);\n    }\n    decode(reader) {\n        let value = mask(reader.readValue(), this.size * 8);\n        if (this.signed) {\n            value = fromTwos(value, this.size * 8);\n        }\n        return value;\n    }\n}\n//# sourceMappingURL=number.js.map"],"names":[],"mappings":";;;;;;;AAGA,MAAM,OAAO,OAAO,CAAC;AACrB,MAAM,OAAO,OAAO,CAAC;AACrB,MAAM,iBAAiB,OAAO,oEAAoE;AAI3F,MAAM,oBAAoB,MAAM;AAAA,EAGnC,YAAY,MAAM,QAAQ,WAAW;AACjC,UAAM,QAAS,SAAS,QAAQ,UAAW,OAAO;AAClD,UAAM,MAAM,MAAM,WAAW,KAAK;AAJtC;AACA;AAII,qBAAiB,MAAM,EAAE,MAAM,OAAM,GAAI,EAAE,MAAM,UAAU,QAAQ,WAAW;AAAA,EACtF;AAAA,EACI,eAAe;AACX,WAAO;AAAA,EACf;AAAA,EACI,OAAO,QAAQ,QAAQ;AACnB,QAAI,QAAQ,UAAU,MAAM,YAAY,QAAQ,KAAK,IAAI,CAAC;AAE1D,QAAI,eAAe,KAAK,gBAAgB,WAAW,CAAC;AACpD,QAAI,KAAK,QAAQ;AACb,UAAI,SAAS,KAAK,cAAe,KAAK,OAAO,IAAK,CAAC;AACnD,UAAI,QAAQ,UAAU,QAAQ,EAAE,SAAS,OAAO;AAC5C,aAAK,YAAY,uBAAuB,MAAM;AAAA,MAC9D;AACY,cAAQ,OAAO,OAAO,IAAI,QAAQ;AAAA,IAC9C,WACiB,QAAQ,QAAQ,QAAQ,KAAK,cAAc,KAAK,OAAO,CAAC,GAAG;AAChE,WAAK,YAAY,uBAAuB,MAAM;AAAA,IAC1D;AACQ,WAAO,OAAO,WAAW,KAAK;AAAA,EACtC;AAAA,EACI,OAAO,QAAQ;AACX,QAAI,QAAQ,KAAK,OAAO,UAAS,GAAI,KAAK,OAAO,CAAC;AAClD,QAAI,KAAK,QAAQ;AACb,cAAQ,SAAS,OAAO,KAAK,OAAO,CAAC;AAAA,IACjD;AACQ,WAAO;AAAA,EACf;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es48.js","sources":["../../node_modules/ethers/lib.esm/abi/coders/array.js"],"sourcesContent":["import { defineProperties, isError, assert, assertArgument, assertArgumentCount } from \"../../utils/index.js\";\nimport { Typed } from \"../typed.js\";\nimport { Coder, Result, WordSize, Writer } from \"./abstract-coder.js\";\nimport { AnonymousCoder } from \"./anonymous.js\";\n/**\n *  @_ignore\n */\nexport function pack(writer, coders, values) {\n    let arrayValues = [];\n    if (Array.isArray(values)) {\n        arrayValues = values;\n    }\n    else if (values && typeof (values) === \"object\") {\n        let unique = {};\n        arrayValues = coders.map((coder) => {\n            const name = coder.localName;\n            assert(name, \"cannot encode object for signature with missing names\", \"INVALID_ARGUMENT\", { argument: \"values\", info: { coder }, value: values });\n            assert(!unique[name], \"cannot encode object for signature with duplicate names\", \"INVALID_ARGUMENT\", { argument: \"values\", info: { coder }, value: values });\n            unique[name] = true;\n            return values[name];\n        });\n    }\n    else {\n        assertArgument(false, \"invalid tuple value\", \"tuple\", values);\n    }\n    assertArgument(coders.length === arrayValues.length, \"types/value length mismatch\", \"tuple\", values);\n    let staticWriter = new Writer();\n    let dynamicWriter = new Writer();\n    let updateFuncs = [];\n    coders.forEach((coder, index) => {\n        let value = arrayValues[index];\n        if (coder.dynamic) {\n            // Get current dynamic offset (for the future pointer)\n            let dynamicOffset = dynamicWriter.length;\n            // Encode the dynamic value into the dynamicWriter\n            coder.encode(dynamicWriter, value);\n            // Prepare to populate the correct offset once we are done\n            let updateFunc = staticWriter.writeUpdatableValue();\n            updateFuncs.push((baseOffset) => {\n                updateFunc(baseOffset + dynamicOffset);\n            });\n        }\n        else {\n            coder.encode(staticWriter, value);\n        }\n    });\n    // Backfill all the dynamic offsets, now that we know the static length\n    updateFuncs.forEach((func) => { func(staticWriter.length); });\n    let length = writer.appendWriter(staticWriter);\n    length += writer.appendWriter(dynamicWriter);\n    return length;\n}\n/**\n *  @_ignore\n */\nexport function unpack(reader, coders) {\n    let values = [];\n    let keys = [];\n    // A reader anchored to this base\n    let baseReader = reader.subReader(0);\n    coders.forEach((coder) => {\n        let value = null;\n        if (coder.dynamic) {\n            let offset = reader.readIndex();\n            let offsetReader = baseReader.subReader(offset);\n            try {\n                value = coder.decode(offsetReader);\n            }\n            catch (error) {\n                // Cannot recover from this\n                if (isError(error, \"BUFFER_OVERRUN\")) {\n                    throw error;\n                }\n                value = error;\n                value.baseType = coder.name;\n                value.name = coder.localName;\n                value.type = coder.type;\n            }\n        }\n        else {\n            try {\n                value = coder.decode(reader);\n            }\n            catch (error) {\n                // Cannot recover from this\n                if (isError(error, \"BUFFER_OVERRUN\")) {\n                    throw error;\n                }\n                value = error;\n                value.baseType = coder.name;\n                value.name = coder.localName;\n                value.type = coder.type;\n            }\n        }\n        if (value == undefined) {\n            throw new Error(\"investigate\");\n        }\n        values.push(value);\n        keys.push(coder.localName || null);\n    });\n    return Result.fromItems(values, keys);\n}\n/**\n *  @_ignore\n */\nexport class ArrayCoder extends Coder {\n    coder;\n    length;\n    constructor(coder, length, localName) {\n        const type = (coder.type + \"[\" + (length >= 0 ? length : \"\") + \"]\");\n        const dynamic = (length === -1 || coder.dynamic);\n        super(\"array\", type, localName, dynamic);\n        defineProperties(this, { coder, length });\n    }\n    defaultValue() {\n        // Verifies the child coder is valid (even if the array is dynamic or 0-length)\n        const defaultChild = this.coder.defaultValue();\n        const result = [];\n        for (let i = 0; i < this.length; i++) {\n            result.push(defaultChild);\n        }\n        return result;\n    }\n    encode(writer, _value) {\n        const value = Typed.dereference(_value, \"array\");\n        if (!Array.isArray(value)) {\n            this._throwError(\"expected array value\", value);\n        }\n        let count = this.length;\n        if (count === -1) {\n            count = value.length;\n            writer.writeValue(value.length);\n        }\n        assertArgumentCount(value.length, count, \"coder array\" + (this.localName ? (\" \" + this.localName) : \"\"));\n        let coders = [];\n        for (let i = 0; i < value.length; i++) {\n            coders.push(this.coder);\n        }\n        return pack(writer, coders, value);\n    }\n    decode(reader) {\n        let count = this.length;\n        if (count === -1) {\n            count = reader.readIndex();\n            // Check that there is *roughly* enough data to ensure\n            // stray random data is not being read as a length. Each\n            // slot requires at least 32 bytes for their value (or 32\n            // bytes as a link to the data). This could use a much\n            // tighter bound, but we are erroring on the side of safety.\n            assert(count * WordSize <= reader.dataLength, \"insufficient data length\", \"BUFFER_OVERRUN\", { buffer: reader.bytes, offset: count * WordSize, length: reader.dataLength });\n        }\n        let coders = [];\n        for (let i = 0; i < count; i++) {\n            coders.push(new AnonymousCoder(this.coder));\n        }\n        return unpack(reader, coders);\n    }\n}\n//# sourceMappingURL=array.js.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -1,21 +1,21 @@
-import { toUtf8Bytes, toUtf8String } from "./standards-sdk.es57.js";
-import { Typed } from "./standards-sdk.es55.js";
-import { DynamicBytesCoder } from "./standards-sdk.es45.js";
-class StringCoder extends DynamicBytesCoder {
+import { Typed } from "./standards-sdk.es62.js";
+import { Coder } from "./standards-sdk.es46.js";
+class BooleanCoder extends Coder {
   constructor(localName) {
-    super("string", localName);
+    super("bool", "bool", localName, false);
   }
   defaultValue() {
-    return "";
+    return false;
   }
   encode(writer, _value) {
-    return super.encode(writer, toUtf8Bytes(Typed.dereference(_value, "string")));
+    const value = Typed.dereference(_value, "bool");
+    return writer.writeValue(value ? 1 : 0);
   }
   decode(reader) {
-    return toUtf8String(super.decode(reader));
+    return !!reader.readValue();
   }
 }
 export {
-  StringCoder
+  BooleanCoder
 };
 //# sourceMappingURL=standards-sdk.es49.js.map

package/dist/es/standards-sdk.es49.js.map

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es49.js","sources":["../../node_modules/ethers/lib.esm/abi/coders/string.js"],"sourcesContent":["import { toUtf8Bytes, toUtf8String } from \"../../utils/utf8.js\";\nimport { Typed } from \"../typed.js\";\nimport { DynamicBytesCoder } from \"./bytes.js\";\n/**\n *  @_ignore\n */\nexport class StringCoder extends DynamicBytesCoder {\n    constructor(localName) {\n        super(\"string\", localName);\n    }\n    defaultValue() {\n        return \"\";\n    }\n    encode(writer, _value) {\n        return super.encode(writer, toUtf8Bytes(Typed.dereference(_value, \"string\")));\n    }\n    decode(reader) {\n        return toUtf8String(super.decode(reader));\n    }\n}\n//# sourceMappingURL=string.js.map"],"names":[],"mappings":";;;AAMO,MAAM,oBAAoB,kBAAkB;AAAA,EAC/C,YAAY,WAAW;AACnB,UAAM,UAAU,SAAS;AAAA,EACjC;AAAA,EACI,eAAe;AACX,WAAO;AAAA,EACf;AAAA,EACI,OAAO,QAAQ,QAAQ;AACnB,WAAO,MAAM,OAAO,QAAQ,YAAY,MAAM,YAAY,QAAQ,QAAQ,CAAC,CAAC;AAAA,EACpF;AAAA,EACI,OAAO,QAAQ;AACX,WAAO,aAAa,MAAM,OAAO,MAAM,CAAC;AAAA,EAChD;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es49.js","sources":["../../node_modules/ethers/lib.esm/abi/coders/boolean.js"],"sourcesContent":["import { Typed } from \"../typed.js\";\nimport { Coder } from \"./abstract-coder.js\";\n/**\n *  @_ignore\n */\nexport class BooleanCoder extends Coder {\n    constructor(localName) {\n        super(\"bool\", \"bool\", localName, false);\n    }\n    defaultValue() {\n        return false;\n    }\n    encode(writer, _value) {\n        const value = Typed.dereference(_value, \"bool\");\n        return writer.writeValue(value ? 1 : 0);\n    }\n    decode(reader) {\n        return !!reader.readValue();\n    }\n}\n//# sourceMappingURL=boolean.js.map"],"names":[],"mappings":";;AAKO,MAAM,qBAAqB,MAAM;AAAA,EACpC,YAAY,WAAW;AACnB,UAAM,QAAQ,QAAQ,WAAW,KAAK;AAAA,EAC9C;AAAA,EACI,eAAe;AACX,WAAO;AAAA,EACf;AAAA,EACI,OAAO,QAAQ,QAAQ;AACnB,UAAM,QAAQ,MAAM,YAAY,QAAQ,MAAM;AAC9C,WAAO,OAAO,WAAW,QAAQ,IAAI,CAAC;AAAA,EAC9C;AAAA,EACI,OAAO,QAAQ;AACX,WAAO,CAAC,CAAC,OAAO,UAAW;AAAA,EACnC;AACA;","x_google_ignoreList":[0]}

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

@@ -1,64 +1,32 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { defineProperties } from "./standards-sdk.es52.js";
-import { Typed } from "./standards-sdk.es55.js";
-import { Coder } from "./standards-sdk.es41.js";
-import { pack, unpack } from "./standards-sdk.es43.js";
-class TupleCoder extends Coder {
-  constructor(coders, localName) {
-    let dynamic = false;
-    const types = [];
-    coders.forEach((coder) => {
-      if (coder.dynamic) {
-        dynamic = true;
-      }
-      types.push(coder.type);
-    });
-    const type = "tuple(" + types.join(",") + ")";
-    super("tuple", type, localName, dynamic);
-    __publicField(this, "coders");
-    defineProperties(this, { coders: Object.freeze(coders.slice()) });
+import { Coder } from "./standards-sdk.es46.js";
+import { hexlify, getBytesCopy } from "./standards-sdk.es44.js";
+class DynamicBytesCoder extends Coder {
+  constructor(type, localName) {
+    super(type, type, localName, true);
   }
   defaultValue() {
-    const values = [];
-    this.coders.forEach((coder) => {
-      values.push(coder.defaultValue());
-    });
-    const uniqueNames = this.coders.reduce((accum, coder) => {
-      const name = coder.localName;
-      if (name) {
-        if (!accum[name]) {
-          accum[name] = 0;
-        }
-        accum[name]++;
-      }
-      return accum;
-    }, {});
-    this.coders.forEach((coder, index) => {
-      let name = coder.localName;
-      if (!name || uniqueNames[name] !== 1) {
-        return;
-      }
-      if (name === "length") {
-        name = "_length";
-      }
-      if (values[name] != null) {
-        return;
-      }
-      values[name] = values[index];
-    });
-    return Object.freeze(values);
+    return "0x";
   }
-  encode(writer, _value) {
-    const value = Typed.dereference(_value, "tuple");
-    return pack(writer, this.coders, value);
+  encode(writer, value) {
+    value = getBytesCopy(value);
+    let length = writer.writeValue(value.length);
+    length += writer.writeBytes(value);
+    return length;
   }
   decode(reader) {
-    return unpack(reader, this.coders);
+    return reader.readBytes(reader.readIndex(), true);
+  }
+}
+class BytesCoder extends DynamicBytesCoder {
+  constructor(localName) {
+    super("bytes", localName);
+  }
+  decode(reader) {
+    return hexlify(super.decode(reader));
   }
 }
 export {
-  TupleCoder
+  BytesCoder,
+  DynamicBytesCoder
 };
 //# sourceMappingURL=standards-sdk.es50.js.map

package/dist/es/standards-sdk.es50.js.map

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es50.js","sources":["../../node_modules/ethers/lib.esm/abi/coders/tuple.js"],"sourcesContent":["import { defineProperties } from \"../../utils/properties.js\";\nimport { Typed } from \"../typed.js\";\nimport { Coder } from \"./abstract-coder.js\";\nimport { pack, unpack } from \"./array.js\";\n/**\n *  @_ignore\n */\nexport class TupleCoder extends Coder {\n    coders;\n    constructor(coders, localName) {\n        let dynamic = false;\n        const types = [];\n        coders.forEach((coder) => {\n            if (coder.dynamic) {\n                dynamic = true;\n            }\n            types.push(coder.type);\n        });\n        const type = (\"tuple(\" + types.join(\",\") + \")\");\n        super(\"tuple\", type, localName, dynamic);\n        defineProperties(this, { coders: Object.freeze(coders.slice()) });\n    }\n    defaultValue() {\n        const values = [];\n        this.coders.forEach((coder) => {\n            values.push(coder.defaultValue());\n        });\n        // We only output named properties for uniquely named coders\n        const uniqueNames = this.coders.reduce((accum, coder) => {\n            const name = coder.localName;\n            if (name) {\n                if (!accum[name]) {\n                    accum[name] = 0;\n                }\n                accum[name]++;\n            }\n            return accum;\n        }, {});\n        // Add named values\n        this.coders.forEach((coder, index) => {\n            let name = coder.localName;\n            if (!name || uniqueNames[name] !== 1) {\n                return;\n            }\n            if (name === \"length\") {\n                name = \"_length\";\n            }\n            if (values[name] != null) {\n                return;\n            }\n            values[name] = values[index];\n        });\n        return Object.freeze(values);\n    }\n    encode(writer, _value) {\n        const value = Typed.dereference(_value, \"tuple\");\n        return pack(writer, this.coders, value);\n    }\n    decode(reader) {\n        return unpack(reader, this.coders);\n    }\n}\n//# sourceMappingURL=tuple.js.map"],"names":[],"mappings":";;;;;;;AAOO,MAAM,mBAAmB,MAAM;AAAA,EAElC,YAAY,QAAQ,WAAW;AAC3B,QAAI,UAAU;AACd,UAAM,QAAQ,CAAE;AAChB,WAAO,QAAQ,CAAC,UAAU;AACtB,UAAI,MAAM,SAAS;AACf,kBAAU;AAAA,MAC1B;AACY,YAAM,KAAK,MAAM,IAAI;AAAA,IACjC,CAAS;AACD,UAAM,OAAQ,WAAW,MAAM,KAAK,GAAG,IAAI;AAC3C,UAAM,SAAS,MAAM,WAAW,OAAO;AAX3C;AAYI,qBAAiB,MAAM,EAAE,QAAQ,OAAO,OAAO,OAAO,MAAO,CAAA,GAAG;AAAA,EACxE;AAAA,EACI,eAAe;AACX,UAAM,SAAS,CAAE;AACjB,SAAK,OAAO,QAAQ,CAAC,UAAU;AAC3B,aAAO,KAAK,MAAM,cAAc;AAAA,IAC5C,CAAS;AAED,UAAM,cAAc,KAAK,OAAO,OAAO,CAAC,OAAO,UAAU;AACrD,YAAM,OAAO,MAAM;AACnB,UAAI,MAAM;AACN,YAAI,CAAC,MAAM,IAAI,GAAG;AACd,gBAAM,IAAI,IAAI;AAAA,QAClC;AACgB,cAAM,IAAI;AAAA,MAC1B;AACY,aAAO;AAAA,IACV,GAAE,EAAE;AAEL,SAAK,OAAO,QAAQ,CAAC,OAAO,UAAU;AAClC,UAAI,OAAO,MAAM;AACjB,UAAI,CAAC,QAAQ,YAAY,IAAI,MAAM,GAAG;AAClC;AAAA,MAChB;AACY,UAAI,SAAS,UAAU;AACnB,eAAO;AAAA,MACvB;AACY,UAAI,OAAO,IAAI,KAAK,MAAM;AACtB;AAAA,MAChB;AACY,aAAO,IAAI,IAAI,OAAO,KAAK;AAAA,IACvC,CAAS;AACD,WAAO,OAAO,OAAO,MAAM;AAAA,EACnC;AAAA,EACI,OAAO,QAAQ,QAAQ;AACnB,UAAM,QAAQ,MAAM,YAAY,QAAQ,OAAO;AAC/C,WAAO,KAAK,QAAQ,KAAK,QAAQ,KAAK;AAAA,EAC9C;AAAA,EACI,OAAO,QAAQ;AACX,WAAO,OAAO,QAAQ,KAAK,MAAM;AAAA,EACzC;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es50.js","sources":["../../node_modules/ethers/lib.esm/abi/coders/bytes.js"],"sourcesContent":["import { getBytesCopy, hexlify } from \"../../utils/index.js\";\nimport { Coder } from \"./abstract-coder.js\";\n/**\n *  @_ignore\n */\nexport class DynamicBytesCoder extends Coder {\n    constructor(type, localName) {\n        super(type, type, localName, true);\n    }\n    defaultValue() {\n        return \"0x\";\n    }\n    encode(writer, value) {\n        value = getBytesCopy(value);\n        let length = writer.writeValue(value.length);\n        length += writer.writeBytes(value);\n        return length;\n    }\n    decode(reader) {\n        return reader.readBytes(reader.readIndex(), true);\n    }\n}\n/**\n *  @_ignore\n */\nexport class BytesCoder extends DynamicBytesCoder {\n    constructor(localName) {\n        super(\"bytes\", localName);\n    }\n    decode(reader) {\n        return hexlify(super.decode(reader));\n    }\n}\n//# sourceMappingURL=bytes.js.map"],"names":[],"mappings":";;AAKO,MAAM,0BAA0B,MAAM;AAAA,EACzC,YAAY,MAAM,WAAW;AACzB,UAAM,MAAM,MAAM,WAAW,IAAI;AAAA,EACzC;AAAA,EACI,eAAe;AACX,WAAO;AAAA,EACf;AAAA,EACI,OAAO,QAAQ,OAAO;AAClB,YAAQ,aAAa,KAAK;AAC1B,QAAI,SAAS,OAAO,WAAW,MAAM,MAAM;AAC3C,cAAU,OAAO,WAAW,KAAK;AACjC,WAAO;AAAA,EACf;AAAA,EACI,OAAO,QAAQ;AACX,WAAO,OAAO,UAAU,OAAO,UAAS,GAAI,IAAI;AAAA,EACxD;AACA;AAIO,MAAM,mBAAmB,kBAAkB;AAAA,EAC9C,YAAY,WAAW;AACnB,UAAM,SAAS,SAAS;AAAA,EAChC;AAAA,EACI,OAAO,QAAQ;AACX,WAAO,QAAQ,MAAM,OAAO,MAAM,CAAC;AAAA,EAC3C;AACA;","x_google_ignoreList":[0]}