@burnt-labs/xion-types 21.0.0-alpha.2 → 21.0.0-alpha.3

package/binary.js

@@ -0,0 +1,562 @@
+/* eslint-disable */ /**
+* This file and any referenced files were automatically generated by @hyperweb/telescope@2.0.1
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/ // Copyright (c) 2016, Daniel Wirtz  All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+// * Redistributions of source code must retain the above copyright
+//   notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+//   notice, this list of conditions and the following disclaimer in the
+//   documentation and/or other materials provided with the distribution.
+// * Neither the name of its author, nor the names of its contributors
+//   may be used to endorse or promote products derived from this software
+//   without specific prior written permission.
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// ---
+// Code generated by the command line utilities is owned by the owner
+// of the input file used when generating it. This code is not
+// standalone and requires a support library to be linked with it. This
+// support library is itself covered by the above license.
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+import { utf8Length, utf8Read, utf8Write } from "./utf8";
+import { int64ToString, readInt32, readUInt32, uInt64ToString, varint32read, varint64read, writeVarint32, writeVarint64, int64FromString, int64Length, writeFixed32, writeByte, zzDecode, zzEncode } from "./varint";
+export var WireType = /*#__PURE__*/ function(WireType) {
+    WireType[WireType["Varint"] = 0] = "Varint";
+    WireType[WireType["Fixed64"] = 1] = "Fixed64";
+    WireType[WireType["Bytes"] = 2] = "Bytes";
+    WireType[WireType["Fixed32"] = 5] = "Fixed32";
+    return WireType;
+}({});
+export var BinaryReader = /*#__PURE__*/ function() {
+    "use strict";
+    function BinaryReader(buf) {
+        _class_call_check(this, BinaryReader);
+        _define_property(this, "buf", void 0);
+        _define_property(this, "pos", void 0);
+        _define_property(this, "type", void 0);
+        _define_property(this, "len", void 0);
+        this.buf = buf ? new Uint8Array(buf) : new Uint8Array(0);
+        this.pos = 0;
+        this.type = 0;
+        this.len = this.buf.length;
+    }
+    _create_class(BinaryReader, [
+        {
+            key: "assertBounds",
+            value: function assertBounds() {
+                if (this.pos > this.len) throw new RangeError("premature EOF");
+            }
+        },
+        {
+            key: "tag",
+            value: function tag() {
+                var tag = this.uint32(), fieldNo = tag >>> 3, wireType = tag & 7;
+                if (fieldNo <= 0 || wireType < 0 || wireType > 5) throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType);
+                return [
+                    fieldNo,
+                    wireType,
+                    tag
+                ];
+            }
+        },
+        {
+            key: "skip",
+            value: function skip(length) {
+                if (typeof length === "number") {
+                    if (this.pos + length > this.len) throw indexOutOfRange(this, length);
+                    this.pos += length;
+                } else {
+                    do {
+                        if (this.pos >= this.len) throw indexOutOfRange(this);
+                    }while (this.buf[this.pos++] & 128);
+                }
+                return this;
+            }
+        },
+        {
+            key: "skipType",
+            value: function skipType(wireType) {
+                switch(wireType){
+                    case 0:
+                        this.skip();
+                        break;
+                    case 1:
+                        this.skip(8);
+                        break;
+                    case 2:
+                        this.skip(this.uint32());
+                        break;
+                    case 3:
+                        while((wireType = this.uint32() & 7) !== 4){
+                            this.skipType(wireType);
+                        }
+                        break;
+                    case 5:
+                        this.skip(4);
+                        break;
+                    /* istanbul ignore next */ default:
+                        throw Error("invalid wire type " + wireType + " at offset " + this.pos);
+                }
+                return this;
+            }
+        },
+        {
+            key: "uint32",
+            value: function uint32() {
+                return varint32read.bind(this)();
+            }
+        },
+        {
+            key: "int32",
+            value: function int32() {
+                return this.uint32() | 0;
+            }
+        },
+        {
+            key: "sint32",
+            value: function sint32() {
+                var num = this.uint32();
+                return num % 2 === 1 ? (num + 1) / -2 : num / 2; // zigzag encoding
+            }
+        },
+        {
+            key: "fixed32",
+            value: function fixed32() {
+                var val = readUInt32(this.buf, this.pos);
+                this.pos += 4;
+                return val;
+            }
+        },
+        {
+            key: "sfixed32",
+            value: function sfixed32() {
+                var val = readInt32(this.buf, this.pos);
+                this.pos += 4;
+                return val;
+            }
+        },
+        {
+            key: "int64",
+            value: function int64() {
+                var _varint64read_bind = _sliced_to_array(varint64read.bind(this)(), 2), lo = _varint64read_bind[0], hi = _varint64read_bind[1];
+                return BigInt(int64ToString(lo, hi));
+            }
+        },
+        {
+            key: "uint64",
+            value: function uint64() {
+                var _varint64read_bind = _sliced_to_array(varint64read.bind(this)(), 2), lo = _varint64read_bind[0], hi = _varint64read_bind[1];
+                return BigInt(uInt64ToString(lo, hi));
+            }
+        },
+        {
+            key: "sint64",
+            value: function sint64() {
+                var _varint64read_bind = _sliced_to_array(varint64read.bind(this)(), 2), lo = _varint64read_bind[0], hi = _varint64read_bind[1];
+                var ref;
+                // zig zag
+                ref = _sliced_to_array(zzDecode(lo, hi), 2), lo = ref[0], hi = ref[1], ref;
+                return BigInt(int64ToString(lo, hi));
+            }
+        },
+        {
+            key: "fixed64",
+            value: function fixed64() {
+                var lo = this.sfixed32();
+                var hi = this.sfixed32();
+                return BigInt(uInt64ToString(lo, hi));
+            }
+        },
+        {
+            key: "sfixed64",
+            value: function sfixed64() {
+                var lo = this.sfixed32();
+                var hi = this.sfixed32();
+                return BigInt(int64ToString(lo, hi));
+            }
+        },
+        {
+            key: "float",
+            value: function float() {
+                throw new Error("float not supported");
+            }
+        },
+        {
+            key: "double",
+            value: function double() {
+                throw new Error("double not supported");
+            }
+        },
+        {
+            key: "bool",
+            value: function bool() {
+                var _varint64read_bind = _sliced_to_array(varint64read.bind(this)(), 2), lo = _varint64read_bind[0], hi = _varint64read_bind[1];
+                return lo !== 0 || hi !== 0;
+            }
+        },
+        {
+            key: "bytes",
+            value: function bytes() {
+                var len = this.uint32(), start = this.pos;
+                this.pos += len;
+                this.assertBounds();
+                return this.buf.subarray(start, start + len);
+            }
+        },
+        {
+            key: "string",
+            value: function string() {
+                var bytes = this.bytes();
+                return utf8Read(bytes, 0, bytes.length);
+            }
+        }
+    ]);
+    return BinaryReader;
+}();
+var Op = /*#__PURE__*/ function() {
+    "use strict";
+    function Op(fn, len, val) {
+        _class_call_check(this, Op);
+        _define_property(this, "fn", void 0);
+        _define_property(this, "len", void 0);
+        _define_property(this, "val", void 0);
+        _define_property(this, "next", void 0);
+        this.fn = fn;
+        this.len = len;
+        this.val = val;
+    }
+    _create_class(Op, [
+        {
+            key: "proceed",
+            value: function proceed(buf, pos) {
+                if (this.fn) {
+                    this.fn(this.val, buf, pos);
+                }
+            }
+        }
+    ]);
+    return Op;
+}();
+var State = function State(writer) {
+    "use strict";
+    _class_call_check(this, State);
+    _define_property(this, "head", void 0);
+    _define_property(this, "tail", void 0);
+    _define_property(this, "len", void 0);
+    _define_property(this, "next", void 0);
+    this.head = writer.head;
+    this.tail = writer.tail;
+    this.len = writer.len;
+    this.next = writer.states;
+};
+export var BinaryWriter = /*#__PURE__*/ function() {
+    "use strict";
+    function BinaryWriter() {
+        _class_call_check(this, BinaryWriter);
+        _define_property(this, "len", 0);
+        _define_property(this, "head", void 0);
+        _define_property(this, "tail", void 0);
+        _define_property(this, "states", void 0);
+        // uint64 is the same with int64
+        _define_property(this, "uint64", BinaryWriter.prototype.int64);
+        // sfixed64 is the same with fixed64
+        _define_property(this, "sfixed64", BinaryWriter.prototype.fixed64);
+        // sfixed32 is the same with fixed32
+        _define_property(this, "sfixed32", BinaryWriter.prototype.fixed32);
+        this.head = new Op(null, 0, 0);
+        this.tail = this.head;
+        this.states = null;
+    }
+    _create_class(BinaryWriter, [
+        {
+            key: "_push",
+            value: function _push(fn, len, val) {
+                this.tail = this.tail.next = new Op(fn, len, val);
+                this.len += len;
+                return this;
+            }
+        },
+        {
+            key: "finish",
+            value: function finish() {
+                var head = this.head.next, pos = 0;
+                var buf = BinaryWriter.alloc(this.len);
+                while(head){
+                    head.proceed(buf, pos);
+                    pos += head.len;
+                    head = head.next;
+                }
+                return buf;
+            }
+        },
+        {
+            key: "fork",
+            value: function fork() {
+                this.states = new State(this);
+                this.head = this.tail = new Op(null, 0, 0);
+                this.len = 0;
+                return this;
+            }
+        },
+        {
+            key: "reset",
+            value: function reset() {
+                if (this.states) {
+                    this.head = this.states.head;
+                    this.tail = this.states.tail;
+                    this.len = this.states.len;
+                    this.states = this.states.next;
+                } else {
+                    this.head = this.tail = new Op(null, 0, 0);
+                    this.len = 0;
+                }
+                return this;
+            }
+        },
+        {
+            key: "ldelim",
+            value: function ldelim() {
+                var head = this.head, tail = this.tail, len = this.len;
+                this.reset().uint32(len);
+                if (len) {
+                    this.tail.next = head.next; // skip noop
+                    this.tail = tail;
+                    this.len += len;
+                }
+                return this;
+            }
+        },
+        {
+            key: "tag",
+            value: function tag(fieldNo, type) {
+                return this.uint32((fieldNo << 3 | type) >>> 0);
+            }
+        },
+        {
+            key: "uint32",
+            value: function uint32(value) {
+                this.len += (this.tail = this.tail.next = new Op(writeVarint32, (value = value >>> 0) < 128 ? 1 : value < 16384 ? 2 : value < 2097152 ? 3 : value < 268435456 ? 4 : 5, value)).len;
+                return this;
+            }
+        },
+        {
+            key: "int32",
+            value: function int32(value) {
+                return value < 0 ? this._push(writeVarint64, 10, int64FromString(value.toString())) // 10 bytes per spec
+                 : this.uint32(value);
+            }
+        },
+        {
+            key: "sint32",
+            value: function sint32(value) {
+                return this.uint32((value << 1 ^ value >> 31) >>> 0);
+            }
+        },
+        {
+            key: "int64",
+            value: function int64(value) {
+                var _int64FromString = int64FromString(value.toString()), lo = _int64FromString.lo, hi = _int64FromString.hi;
+                return this._push(writeVarint64, int64Length(lo, hi), {
+                    lo: lo,
+                    hi: hi
+                });
+            }
+        },
+        {
+            key: "sint64",
+            value: function sint64(value) {
+                var _int64FromString = int64FromString(value.toString()), lo = _int64FromString.lo, hi = _int64FromString.hi;
+                var ref;
+                // zig zag
+                ref = _sliced_to_array(zzEncode(lo, hi), 2), lo = ref[0], hi = ref[1], ref;
+                return this._push(writeVarint64, int64Length(lo, hi), {
+                    lo: lo,
+                    hi: hi
+                });
+            }
+        },
+        {
+            key: "fixed64",
+            value: function fixed64(value) {
+                var _int64FromString = int64FromString(value.toString()), lo = _int64FromString.lo, hi = _int64FromString.hi;
+                return this._push(writeFixed32, 4, lo)._push(writeFixed32, 4, hi);
+            }
+        },
+        {
+            key: "bool",
+            value: function bool(value) {
+                return this._push(writeByte, 1, value ? 1 : 0);
+            }
+        },
+        {
+            key: "fixed32",
+            value: function fixed32(value) {
+                return this._push(writeFixed32, 4, value >>> 0);
+            }
+        },
+        {
+            key: "float",
+            value: function float(value) {
+                throw new Error("float not supported" + value);
+            }
+        },
+        {
+            key: "double",
+            value: function double(value) {
+                throw new Error("double not supported" + value);
+            }
+        },
+        {
+            key: "bytes",
+            value: function bytes(value) {
+                var len = value.length >>> 0;
+                if (!len) return this._push(writeByte, 1, 0);
+                return this.uint32(len)._push(writeBytes, len, value);
+            }
+        },
+        {
+            key: "string",
+            value: function string(value) {
+                var len = utf8Length(value);
+                return len ? this.uint32(len)._push(utf8Write, len, value) : this._push(writeByte, 1, 0);
+            }
+        }
+    ], [
+        {
+            key: "create",
+            value: function create() {
+                return new BinaryWriter();
+            }
+        },
+        {
+            key: "alloc",
+            value: function alloc(size) {
+                if (typeof Uint8Array !== "undefined") {
+                    return pool(function(size) {
+                        return new Uint8Array(size);
+                    }, Uint8Array.prototype.subarray)(size);
+                } else {
+                    return new Array(size);
+                }
+            }
+        }
+    ]);
+    return BinaryWriter;
+}();
+function writeBytes(val, buf, pos) {
+    if (typeof Uint8Array !== "undefined") {
+        buf.set(val, pos);
+    } else {
+        for(var i = 0; i < val.length; ++i)buf[pos + i] = val[i];
+    }
+}
+function pool(alloc, slice, size) {
+    var SIZE = size || 8192;
+    var MAX = SIZE >>> 1;
+    var slab = null;
+    var offset = SIZE;
+    return function pool_alloc(size) {
+        if (size < 1 || size > MAX) return alloc(size);
+        if (offset + size > SIZE) {
+            slab = alloc(SIZE);
+            offset = 0;
+        }
+        var buf = slice.call(slab, offset, offset += size);
+        if (offset & 7) // align to 32 bit
+        offset = (offset | 7) + 1;
+        return buf;
+    };
+}
+function indexOutOfRange(reader, writeLength) {
+    return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len);
+}