@leofcoin/chain 1.10.21 → 1.11.0

package/exports/browser/{browser-crypto-CH0ua22L.js → browser-crypto-B_UJguhk.js}

@@ -1,12 +1,6 @@
 import { a as index$3, b as base58$1, i as index$4, f as fromBase58, c as fromHex, d as fromArrayLike, e as toBase32, t as toBase58, g as toHex } from './index-CvKt4UDE.js';
 import { s as sha256 } from './sha2-BKcEJzgd.js';
 
-var isHex = string => /^[A-F0-9]+$/i.test(
-  string.startsWith('0x') ?
-  string.slice(2) :
-  string
-);
-
 const MAX_BIGINT = (1n << 256n) - 1n;
 function size(value) {
   if (!Number.isSafeInteger(value) || value < 0)
@@ -31,6 +25,10 @@ function varBigIntLength(value) {
   if (value < 0n || value > MAX_BIGINT)
     throw new RangeError("Expected an unsigned 256-bit integer");
   let length = 1;
+  while (value >= 0x100000000000000n) {
+    value >>= 56n;
+    length += 8;
+  }
   while (value >= 128n) {
     value >>= 7n;
     length++;
@@ -209,6 +207,280 @@ function decodeFrames(buffer, prefixLength = 0, options = {}) {
   return frames;
 }
 
+const MAGIC = new Uint8Array([76, 70, 67, 1]);
+const utf8 = new TextEncoder();
+const text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+const defaults = { maxBytes: 16 * 1024 * 1024, maxDepth: 64, maxNodes: 2e5 };
+const BIGINT_LIMB = 1n << 49n;
+const BIGINT_MASK = BIGINT_LIMB - 1n;
+const limitsFor = (options) => {
+  const limits = { ...defaults, ...options };
+  for (const value of Object.values(limits))
+    if (!Number.isSafeInteger(value) || value < 1)
+      throw new RangeError("Invalid binary limits");
+  return limits;
+};
+function stringLength(value, maximum) {
+  if (value.length > maximum)
+    throw new RangeError("Invalid binary string");
+  let length = value.length;
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code < 128)
+      continue;
+    if (code < 2048) {
+      length++;
+      continue;
+    }
+    if (code >= 55296 && code <= 56319) {
+      const low = value.charCodeAt(++index);
+      if (!(low >= 56320 && low <= 57343))
+        throw new RangeError("Invalid binary string");
+      length += 2;
+    } else {
+      if (code >= 56320 && code <= 57343)
+        throw new RangeError("Invalid binary string");
+      length += 2;
+    }
+  }
+  return length;
+}
+function encodeValue(value, options = {}) {
+  return encodeValueWithPrefix(value, EMPTY, options);
+}
+const EMPTY = new Uint8Array();
+function encodeValueWithPrefix(value, prefix, options = {}) {
+  if (!(prefix instanceof Uint8Array))
+    throw new TypeError("Expected Uint8Array prefix");
+  const limits = limitsFor(options);
+  const plan = [];
+  const ancestors = /* @__PURE__ */ new Set();
+  let size = MAGIC.length;
+  let nodes = 0;
+  const reserve = (length) => {
+    size += length;
+    if (size > limits.maxBytes)
+      throw new RangeError("Binary value exceeds byte limit");
+  };
+  const string = (value2, tag) => {
+    const length = stringLength(value2, limits.maxBytes);
+    reserve((tag === 7 ? 1 : 0) + varUintLength(length) + length);
+    plan.push(tag, value2, length);
+  };
+  const visit = (value2, depth) => {
+    if (++nodes > limits.maxNodes || depth > limits.maxDepth)
+      throw new RangeError("Binary value exceeds complexity limit");
+    if (value2 === void 0 || value2 === null || typeof value2 === "boolean") {
+      reserve(1);
+      plan.push(value2 === void 0 ? 0 : value2 === null ? 1 : value2 === false ? 2 : 3);
+      return;
+    }
+    if (typeof value2 === "number") {
+      if (!Number.isFinite(value2))
+        throw new TypeError("Binary numbers must be finite");
+      reserve(9);
+      plan.push(4, value2);
+      return;
+    }
+    if (typeof value2 === "bigint") {
+      const magnitude = value2 < 0n ? -value2 : value2;
+      reserve(1 + varBigIntLength(magnitude));
+      plan.push(value2 < 0n ? 6 : 5, magnitude);
+      return;
+    }
+    if (typeof value2 === "string")
+      return string(value2, 7);
+    if (value2 instanceof Uint8Array) {
+      reserve(1 + varUintLength(value2.length) + value2.length);
+      plan.push(8, value2, value2.length);
+      return;
+    }
+    if (typeof value2 !== "object")
+      throw new TypeError("Unsupported binary value");
+    if (ancestors.has(value2))
+      throw new TypeError("Cyclic binary value");
+    ancestors.add(value2);
+    try {
+      if (Array.isArray(value2)) {
+        if (value2.length > limits.maxNodes - nodes)
+          throw new RangeError("Binary array exceeds node limit");
+        if (Object.keys(value2).length !== value2.length || Object.getOwnPropertySymbols(value2).length)
+          throw new TypeError("Binary arrays cannot have extra properties or holes");
+        reserve(1 + varUintLength(value2.length));
+        plan.push(9, value2.length);
+        for (let index = 0; index < value2.length; index++) {
+          const entry = Object.getOwnPropertyDescriptor(value2, String(index));
+          if (!entry || !("value" in entry))
+            throw new TypeError("Sparse arrays and accessors are not binary values");
+          visit(entry.value, depth + 1);
+        }
+      } else {
+        const prototype = Object.getPrototypeOf(value2);
+        if (prototype !== Object.prototype && prototype !== null)
+          throw new TypeError("Binary maps must be plain objects");
+        const keys = Object.keys(value2).sort();
+        if (Object.getOwnPropertySymbols(value2).length)
+          throw new TypeError("Symbol keys are not binary values");
+        if (keys.length > limits.maxNodes - nodes)
+          throw new RangeError("Binary map exceeds node limit");
+        reserve(1 + varUintLength(keys.length));
+        plan.push(10, keys.length);
+        for (const key of keys) {
+          const entry = Object.getOwnPropertyDescriptor(value2, key);
+          if (!("value" in entry))
+            throw new TypeError("Accessors are not binary values");
+          string(key, 11);
+          visit(entry.value, depth + 1);
+        }
+      }
+    } finally {
+      ancestors.delete(value2);
+    }
+  };
+  visit(value, 0);
+  const capacity = prefix.length + size;
+  if (!Number.isSafeInteger(capacity))
+    throw new RangeError("Binary output is too large");
+  const output = new Uint8Array(capacity);
+  output.set(prefix);
+  output.set(MAGIC, prefix.length);
+  let position = prefix.length + MAGIC.length;
+  let view;
+  const uint = (value2) => {
+    while (value2 >= 128) {
+      output[position++] = value2 % 128 | 128;
+      value2 = Math.floor(value2 / 128);
+    }
+    output[position++] = value2;
+  };
+  for (let cursor = 0; cursor < plan.length; ) {
+    const tag = plan[cursor++];
+    if (tag !== 11)
+      output[position++] = tag;
+    if (tag < 4)
+      continue;
+    if (tag === 4) {
+      view ??= new DataView(output.buffer);
+      view.setFloat64(position, plan[cursor++], false);
+      position += 8;
+    } else if (tag === 5 || tag === 6) {
+      let value2 = plan[cursor++];
+      while (value2 >= BIGINT_LIMB) {
+        let limb = Number(value2 & BIGINT_MASK);
+        for (let index = 0; index < 7; index++) {
+          output[position++] = limb % 128 | 128;
+          limb = Math.floor(limb / 128);
+        }
+        value2 >>= 49n;
+      }
+      uint(Number(value2));
+    } else if (tag === 7 || tag === 11) {
+      const value2 = plan[cursor++];
+      const length = plan[cursor++];
+      uint(length);
+      if (length === value2.length) {
+        for (let index = 0; index < length; index++)
+          output[position++] = value2.charCodeAt(index);
+      } else {
+        const result = utf8.encodeInto(value2, output.subarray(position, position + length));
+        if (result.read !== value2.length || result.written !== length)
+          throw new Error("UTF-8 planning mismatch");
+        position += length;
+      }
+    } else if (tag === 8) {
+      const value2 = plan[cursor++];
+      const length = plan[cursor++];
+      if (value2.length !== length)
+        throw new RangeError("Byte input changed while encoding");
+      uint(length);
+      output.set(value2, position);
+      position += length;
+    } else {
+      uint(plan[cursor++]);
+    }
+  }
+  if (position !== capacity)
+    throw new Error("Binary planning mismatch");
+  return output;
+}
+function decodeValue(input, options = {}) {
+  const limits = limitsFor(options);
+  if (!(input instanceof Uint8Array))
+    throw new TypeError("Wire payload must be Uint8Array");
+  if (input.length > limits.maxBytes)
+    throw new RangeError("Binary value exceeds byte limit");
+  const reader = new BinaryReader(input);
+  if (reader.readBytes(MAGIC.length).some((byte, index) => byte !== MAGIC[index]))
+    throw new TypeError("Unsupported binary wire version");
+  let nodes = 0;
+  const string = () => text.decode(reader.readFrame());
+  const read = (depth) => {
+    if (++nodes > limits.maxNodes || depth > limits.maxDepth)
+      throw new RangeError("Binary value exceeds complexity limit");
+    const tag = reader.readBytes(1)[0];
+    if (tag === 0)
+      return void 0;
+    if (tag === 1)
+      return null;
+    if (tag === 2)
+      return false;
+    if (tag === 3)
+      return true;
+    if (tag === 4) {
+      const bytes = reader.readBytes(8);
+      const value2 = new DataView(bytes.buffer, bytes.byteOffset, 8).getFloat64(0, false);
+      if (!Number.isFinite(value2))
+        throw new TypeError("Binary numbers must be finite");
+      return value2;
+    }
+    if (tag === 5 || tag === 6) {
+      const value2 = reader.readVarBigInt();
+      if (tag === 6 && value2 === 0n)
+        throw new TypeError("Non-canonical negative zero");
+      return tag === 6 ? -value2 : value2;
+    }
+    if (tag === 7)
+      return string();
+    if (tag === 8)
+      return new Uint8Array(reader.readFrame());
+    if (tag === 9 || tag === 10) {
+      const count = reader.readVarUint();
+      if (count > limits.maxNodes - nodes || count > reader.remaining)
+        throw new RangeError("Invalid binary collection size");
+      if (tag === 9)
+        return Array.from({ length: count }, () => read(depth + 1));
+      const result = {};
+      let previous;
+      for (let index = 0; index < count; index++) {
+        const key = string();
+        if (previous !== void 0 && key <= previous)
+          throw new TypeError("Non-canonical binary map keys");
+        previous = key;
+        Object.defineProperty(result, key, { value: read(depth + 1), enumerable: true, writable: true, configurable: true });
+      }
+      return result;
+    }
+    throw new TypeError("Unknown binary value tag");
+  };
+  const value = read(0);
+  if (reader.remaining)
+    throw new TypeError("Trailing binary data");
+  return value;
+}
+const encodeWire = (channel, value, limits) => encodeValue([channel, value], limits);
+function decodeWire(channel, bytes, limits) {
+  const envelope = decodeValue(bytes, limits);
+  if (!Array.isArray(envelope) || envelope.length !== 2 || envelope[0] !== channel)
+    throw new TypeError("Wrong binary message channel");
+  return envelope[1];
+}
+
+var isHex = string => /^[A-F0-9]+$/i.test(
+  string.startsWith('0x') ?
+  string.slice(2) :
+  string
+);
+
 const asBytes = (source) => {
     if (source instanceof Uint8Array)
         return source;
@@ -8869,7 +9141,9 @@ const FormatInterface = FormatInterface$1;
  */
 const Codec = Codec$1;
 
-var proto$8 = {
+const defineSchema = (proto) => Object.freeze(proto);
+
+var proto$b = defineSchema({
   index: BigInt(0),
   previousHash: String(),
   timestamp: Number(),
@@ -8880,50 +9154,189 @@ var proto$8 = {
   producer: String(),
   producerProof: String(),
   protocolVersion: String()
-};
+});
+
+const schemas = /* @__PURE__ */ new WeakMap();
+const kindOf = (value) => value === void 0 ? "any" : value instanceof Uint8Array ? "bytes" : Array.isArray(value) ? "array" : typeof value;
+function schemaFor(proto) {
+  const cached = schemas.get(proto);
+  if (cached)
+    return cached;
+  const keys = Object.keys(proto);
+  const schema = {
+    fields: keys.map((key) => ({
+      key,
+      name: key.endsWith("?") ? key.slice(0, -1) : key,
+      kind: kindOf(proto[key])
+    })),
+    prefixes: /* @__PURE__ */ new Map()
+  };
+  if (Object.isFrozen(proto) && keys.every((key) => "value" in Object.getOwnPropertyDescriptor(proto, key)))
+    schemas.set(proto, schema);
+  return schema;
+}
+function codecPrefix(schema, name) {
+  let prefix = schema.prefixes.get(name);
+  if (!prefix) {
+    const codec = new Codec(name);
+    if (!codec.codecBuffer)
+      throw new Error("invalid codec");
+    prefix = new Uint8Array(codec.codecBuffer);
+    schema.prefixes.set(name, prefix);
+  }
+  return prefix;
+}
+class BinaryFormat extends FormatInterface {
+  field(key, value, kind) {
+    if (value === void 0)
+      return value;
+    kind ??= kindOf(this.proto[key]);
+    if (kind === "any")
+      return value;
+    if (kind === "bigint") {
+      if (typeof value === "number" && !Number.isSafeInteger(value))
+        throw new TypeError("Unsafe integer message field");
+      if (!["number", "string", "bigint"].includes(typeof value))
+        throw new TypeError("Invalid BigInt message field");
+      return BigInt(value);
+    }
+    if (kind === "bytes") {
+      if (!(value instanceof Uint8Array))
+        throw new TypeError("Message byte field must be Uint8Array");
+    } else if (kind === "array") {
+      if (!Array.isArray(value))
+        throw new TypeError("Message array field must be an array");
+    } else if (typeof value !== kind || value === null)
+      throw new TypeError("Message field type mismatch");
+    return value;
+  }
+  create(value) {
+    const { fields } = schemaFor(this.proto);
+    this.decoded = Object.fromEntries(fields.map((field) => {
+      const input = value?.[field.name];
+      return [field.name, field.kind === "bigint" ? this.field(field.key, input, field.kind) : input];
+    }));
+  }
+  tuple(value, fields) {
+    const tuple = new Array(fields.length);
+    for (let index = 0; index < fields.length; index++) {
+      const field = fields[index];
+      tuple[index] = this.field(field.key, value[field.name], field.kind);
+    }
+    return tuple;
+  }
+  protoEncode(value) {
+    return encodeValue(this.tuple(value, schemaFor(this.proto).fields));
+  }
+  encode(value) {
+    value = value || this.decoded;
+    const schema = schemaFor(this.proto);
+    const prefix = codecPrefix(schema, this.name);
+    if (value instanceof Uint8Array) {
+      const output = new Uint8Array(prefix.length + value.length);
+      output.set(prefix);
+      output.set(value, prefix.length);
+      this.encoded = output;
+    } else {
+      this.encoded = encodeValueWithPrefix(this.tuple(value, schema.fields), prefix);
+    }
+    return this.encoded;
+  }
+  protoDecode(bytes) {
+    const values = decodeValue(bytes);
+    const { fields } = schemaFor(this.proto);
+    if (!Array.isArray(values) || values.length !== fields.length)
+      throw new TypeError("Binary message schema mismatch");
+    return Object.fromEntries(fields.map((field, index) => {
+      const value = this.field(field.key, values[index], field.kind);
+      if (typeof value !== typeof values[index])
+        throw new TypeError("Non-canonical message field type");
+      return [field.name, value];
+    }));
+  }
+  decode(bytes) {
+    bytes ??= this.encoded;
+    if (!(bytes instanceof Uint8Array))
+      throw new TypeError("Message payload must be Uint8Array");
+    const codec = new Codec(bytes);
+    if (codec.name !== this.name)
+      throw new TypeError("Wrong binary message codec");
+    this.decoded = this.protoDecode(bytes.subarray(codec.codecBuffer.length));
+    return this.decoded;
+  }
+  fromUint8Array(bytes) {
+    this.encoded = bytes;
+    return this.decode(bytes);
+  }
+  fromArrayBuffer(buffer) {
+    return this.fromUint8Array(new Uint8Array(buffer));
+  }
+}
 
-var proto$7 = {
+var proto$a = defineSchema({
   address: String(),
   reward: BigInt(0)
-};
+});
 
-({
-  epoch: BigInt(0)});
+defineSchema({
+  epoch: BigInt(0),
+  configDigest: String(),
+  from: String(),
+  signature: String()
+});
 
-({
+defineSchema({
   epoch: BigInt(0),
   threshold: BigInt(0),
   participant: BigInt(0),
-  commitments: Array()});
+  from: String(),
+  commitments: Array(),
+  signature: String()
+});
 
-({
+defineSchema({
   epoch: BigInt(0),
   round: BigInt(0),
-  participant: BigInt(0)});
+  participant: BigInt(0),
+  from: String(),
+  signatureShare: String(),
+  signature: String()
+});
+
+var proto$9 = defineSchema({
+  up: Number(),
+  down: Number()
+});
+
+var proto$8 = defineSchema({});
 
-var proto$6 = {
+var proto$7 = defineSchema({
   creator: String(),
   contract: new Uint8Array(),
   constructorParameters: Array()
-};
+});
 
-class ContractMessage extends FormatInterface {
+class ContractMessage extends BinaryFormat {
   get messageName() {
     return "ContractMessage";
   }
   constructor(buffer) {
     if (buffer instanceof ContractMessage)
       return buffer;
-    super(buffer, proto$6, { name: "contract-message" });
+    if (buffer && typeof buffer === "object" && !(buffer instanceof Uint8Array) && typeof buffer.contract === "string")
+      buffer = { ...buffer, contract: new TextEncoder().encode(buffer.contract) };
+    super(buffer, proto$7, { name: "contract-message" });
   }
 }
 
-var proto$5 = {
+var proto$6 = defineSchema({
   hash: String(),
   index: BigInt(0)
-};
+});
+
+defineSchema({});
 
-var proto$4 = {
+var proto$5 = defineSchema({
   timestamp: Number(),
   from: String(),
   to: String(),
@@ -8933,9 +9346,9 @@ var proto$4 = {
   "nonce?": Number(),
   "dependsOn?": Array(),
   "priority?": Boolean()
-};
+});
 
-class TransactionMessage extends FormatInterface {
+class TransactionMessage extends BinaryFormat {
   get messageName() {
     return "TransactionMessage";
   }
@@ -8943,7 +9356,7 @@ class TransactionMessage extends FormatInterface {
     if (buffer instanceof TransactionMessage)
       return buffer;
     const name = "transaction-message";
-    super(buffer, proto$4, { name });
+    super(buffer, proto$5, { name });
   }
   beforeHashing(decoded) {
     decoded = super.beforeHashing(decoded);
@@ -8954,38 +9367,43 @@ class TransactionMessage extends FormatInterface {
   }
 }
 
-var proto$3 = {
+var proto$4 = defineSchema({
   timestamp: Number(),
   from: String(),
   to: String(),
   method: String(),
   params: Array(),
   "nonce?": Number()
-};
+});
 
-var proto$2 = {
+var proto$3 = defineSchema({
+  lastblock: Object(),
+  values: Object()
+});
+
+var proto$2 = defineSchema({
   blockHash: String(),
   index: BigInt(0),
   round: BigInt(0),
   from: String(),
   signature: String()
-};
+});
 
-var proto$1 = {
+var proto$1 = defineSchema({
   blockHash: String(),
   index: BigInt(0),
   round: BigInt(0),
   from: String(),
   signature: String()
-};
+});
 
-var proto = {
+var proto = defineSchema({
   blockHash: String(),
   index: BigInt(0),
   round: BigInt(0),
   from: String(),
   signature: String()
-};
+});
 
 const encoder = new TextEncoder();
 const normalizeInput = (value) => {
@@ -9015,4 +9433,4 @@ const createHash = (algorithm) => {
   };
 };
 
-export { BinaryWriter as B, ContractMessage as C, FormatInterface as F, TransactionMessage as T, proto$1 as a, proto as b, jsonParseBigInt$1 as c, Codec as d, proto$3 as e, index$1 as f, createRIPEMD160 as g, createHMAC as h, index$2 as i, jsonStringifyBigInt$1 as j, createSHA512 as k, createKeccak as l, BinaryReader as m, createHash as n, proto$7 as o, proto$2 as p, proto$8 as q, encodeFrames as r, decodeFrames as s, proto$5 as t, varUintLength as v };
+export { proto$3 as A, BinaryFormat as B, Codec as C, TransactionMessage as T, proto$1 as a, proto as b, jsonStringifyBigInt$1 as c, ContractMessage as d, decodeWire as e, encodeWire as f, proto$4 as g, index$1 as h, index$2 as i, jsonParseBigInt$1 as j, createRIPEMD160 as k, createHMAC as l, createSHA512 as m, createKeccak as n, BinaryWriter as o, proto$2 as p, BinaryReader as q, createHash as r, proto$8 as s, proto$a as t, proto$b as u, varUintLength as v, encodeFrames as w, decodeFrames as x, proto$9 as y, proto$6 as z };