@toon-protocol/core 3.3.0 → 3.5.0

package/dist/chunk-K72H36Y4.js

@@ -0,0 +1,591 @@
+// src/wire/oer.ts
+var OerErrorKind = /* @__PURE__ */ ((OerErrorKind2) => {
+  OerErrorKind2["BufferUnderflow"] = "buffer_underflow";
+  OerErrorKind2["NonCanonicalLength"] = "non_canonical_length";
+  OerErrorKind2["LengthDeterminantOverflow"] = "length_determinant_overflow";
+  return OerErrorKind2;
+})(OerErrorKind || {});
+var OerError = class extends Error {
+  constructor(kind) {
+    super(OER_ERROR_MESSAGES[kind]);
+    this.kind = kind;
+    this.name = "OerError";
+  }
+};
+var OER_ERROR_MESSAGES = {
+  ["buffer_underflow" /* BufferUnderflow */]: "buffer underflow: the value is truncated",
+  ["non_canonical_length" /* NonCanonicalLength */]: "non-canonical OER length determinant: not the minimal encoding of its value",
+  ["length_determinant_overflow" /* LengthDeterminantOverflow */]: "OER length determinant wider than 8 bytes"
+};
+var MAX_DETERMINANT_BYTES = 8;
+function encodeVarUint(value) {
+  if (value < 0n)
+    throw new RangeError("VarUInt cannot encode a negative value");
+  if (value <= 127n) return Uint8Array.of(Number(value));
+  const body = [];
+  let remaining = value;
+  while (remaining > 0n) {
+    body.unshift(Number(remaining & 0xffn));
+    remaining >>= 8n;
+  }
+  if (body.length > MAX_DETERMINANT_BYTES) {
+    throw new RangeError("VarUInt cannot encode a value wider than 8 bytes");
+  }
+  return Uint8Array.from([128 | body.length, ...body]);
+}
+function decodeVarUint(buf, offset) {
+  const first = buf[offset];
+  if (first === void 0) throw new OerError("buffer_underflow" /* BufferUnderflow */);
+  if (first <= 127) return { value: BigInt(first), consumed: 1 };
+  const length = first & 127;
+  if (length > MAX_DETERMINANT_BYTES) {
+    throw new OerError("length_determinant_overflow" /* LengthDeterminantOverflow */);
+  }
+  const start = offset + 1;
+  const end = start + length;
+  if (end > buf.length) throw new OerError("buffer_underflow" /* BufferUnderflow */);
+  let value = 0n;
+  for (let i = start; i < end; i++) {
+    value = value << 8n | BigInt(buf[i]);
+  }
+  const consumed = 1 + length;
+  const canonical = encodeVarUint(value);
+  if (canonical.length !== consumed || !canonical.every((byte, i) => byte === buf[offset + i])) {
+    throw new OerError("non_canonical_length" /* NonCanonicalLength */);
+  }
+  return { value, consumed };
+}
+function encodeVarOctetString(data) {
+  const prefix = encodeVarUint(BigInt(data.length));
+  const out = new Uint8Array(prefix.length + data.length);
+  out.set(prefix, 0);
+  out.set(data, prefix.length);
+  return out;
+}
+function decodeVarOctetString(buf, offset) {
+  const { value: length, consumed: lengthBytes } = decodeVarUint(buf, offset);
+  if (length > BigInt(buf.length)) {
+    throw new OerError("buffer_underflow" /* BufferUnderflow */);
+  }
+  const start = offset + lengthBytes;
+  const end = start + Number(length);
+  if (end > buf.length) throw new OerError("buffer_underflow" /* BufferUnderflow */);
+  return {
+    value: buf.slice(start, end),
+    consumed: lengthBytes + Number(length)
+  };
+}
+
+// src/wire/envelope.ts
+var TYPE_ENVELOPE_REQUEST = 1;
+var TYPE_ENVELOPE_RESPONSE = 2;
+var EnvelopeErrorKind = /* @__PURE__ */ ((EnvelopeErrorKind2) => {
+  EnvelopeErrorKind2["BufferUnderflow"] = "buffer_underflow";
+  EnvelopeErrorKind2["NonCanonicalLength"] = "non_canonical_length";
+  EnvelopeErrorKind2["LengthDeterminantOverflow"] = "length_determinant_overflow";
+  EnvelopeErrorKind2["InvalidType"] = "invalid_type";
+  EnvelopeErrorKind2["InvalidUtf8"] = "invalid_utf8";
+  EnvelopeErrorKind2["TrailingBytes"] = "trailing_bytes";
+  return EnvelopeErrorKind2;
+})(EnvelopeErrorKind || {});
+var EnvelopeError = class extends Error {
+  constructor(kind, field) {
+    super(
+      field === void 0 ? ENVELOPE_ERROR_MESSAGES[kind] : `${ENVELOPE_ERROR_MESSAGES[kind]} (field '${field}')`
+    );
+    this.kind = kind;
+    this.field = field;
+    this.name = "EnvelopeError";
+  }
+};
+var ENVELOPE_ERROR_MESSAGES = {
+  ["buffer_underflow" /* BufferUnderflow */]: "buffer underflow: envelope is truncated",
+  ["non_canonical_length" /* NonCanonicalLength */]: "non-canonical OER length determinant: not the minimal encoding of its value",
+  ["length_determinant_overflow" /* LengthDeterminantOverflow */]: "OER length determinant wider than 8 bytes",
+  ["invalid_type" /* InvalidType */]: "invalid envelope type byte: expected 1 (REQUEST) or 2 (RESPONSE)",
+  ["invalid_utf8" /* InvalidUtf8 */]: "invalid UTF-8 in envelope field",
+  ["trailing_bytes" /* TrailingBytes */]: "trailing bytes after a fully decoded envelope"
+};
+var UTF8_ENCODER = new TextEncoder();
+var UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
+function fromOerError(error) {
+  if (error instanceof OerError) {
+    switch (error.kind) {
+      case "buffer_underflow" /* BufferUnderflow */:
+        return new EnvelopeError("buffer_underflow" /* BufferUnderflow */);
+      case "non_canonical_length" /* NonCanonicalLength */:
+        return new EnvelopeError("non_canonical_length" /* NonCanonicalLength */);
+      case "length_determinant_overflow" /* LengthDeterminantOverflow */:
+        return new EnvelopeError("length_determinant_overflow" /* LengthDeterminantOverflow */);
+    }
+  }
+  throw error;
+}
+function decodeOctets(buf, offset) {
+  try {
+    return decodeVarOctetString(buf, offset);
+  } catch (error) {
+    throw fromOerError(error);
+  }
+}
+function decodeCount(buf, offset) {
+  try {
+    return decodeVarUint(buf, offset);
+  } catch (error) {
+    throw fromOerError(error);
+  }
+}
+function decodeStringField(buf, offset, field) {
+  const { value: bytes, consumed } = decodeOctets(buf, offset);
+  try {
+    return { value: UTF8_DECODER.decode(bytes), consumed };
+  } catch {
+    throw new EnvelopeError("invalid_utf8" /* InvalidUtf8 */, field);
+  }
+}
+function checkTypeByte(buf, expected) {
+  const typeByte = buf[0];
+  if (typeByte === void 0) {
+    throw new EnvelopeError("buffer_underflow" /* BufferUnderflow */);
+  }
+  if (typeByte !== expected) {
+    throw new EnvelopeError("invalid_type" /* InvalidType */);
+  }
+  return 1;
+}
+function concat(parts) {
+  const total = parts.reduce((sum, part) => sum + part.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function encodeHeaders(headers) {
+  const parts = [encodeVarUint(BigInt(headers.length))];
+  for (const [name, value] of headers) {
+    parts.push(encodeVarOctetString(UTF8_ENCODER.encode(name)));
+    parts.push(encodeVarOctetString(UTF8_ENCODER.encode(value)));
+  }
+  return concat(parts);
+}
+function decodeHeaders(buf, offset) {
+  const { value: count, consumed: countBytes } = decodeCount(buf, offset);
+  if (count * 2n > BigInt(buf.length - offset - countBytes)) {
+    throw new EnvelopeError("buffer_underflow" /* BufferUnderflow */);
+  }
+  let consumed = countBytes;
+  const headers = [];
+  for (let i = 0n; i < count; i++) {
+    const name = decodeStringField(buf, offset + consumed, "header name");
+    consumed += name.consumed;
+    const value = decodeStringField(buf, offset + consumed, "header value");
+    consumed += value.consumed;
+    headers.push([name.value, value.value]);
+  }
+  return { value: headers, consumed };
+}
+function encodeEnvelopeRequest(request) {
+  return concat([
+    Uint8Array.of(TYPE_ENVELOPE_REQUEST),
+    encodeVarOctetString(UTF8_ENCODER.encode(request.method)),
+    encodeVarOctetString(UTF8_ENCODER.encode(request.target)),
+    encodeHeaders(request.headers),
+    encodeVarOctetString(request.body)
+  ]);
+}
+function decodeEnvelopeRequest(buf) {
+  let offset = checkTypeByte(buf, TYPE_ENVELOPE_REQUEST);
+  const method = decodeStringField(buf, offset, "method");
+  offset += method.consumed;
+  const target = decodeStringField(buf, offset, "target");
+  offset += target.consumed;
+  const headers = decodeHeaders(buf, offset);
+  offset += headers.consumed;
+  const body = decodeOctets(buf, offset);
+  offset += body.consumed;
+  if (offset !== buf.length) {
+    throw new EnvelopeError("trailing_bytes" /* TrailingBytes */);
+  }
+  return {
+    method: method.value,
+    target: target.value,
+    headers: headers.value,
+    body: body.value
+  };
+}
+function encodeEnvelopeResponse(response) {
+  if (!Number.isInteger(response.status) || response.status < 0 || response.status > 65535) {
+    throw new RangeError(
+      `envelope status must fit two bytes, got ${response.status}`
+    );
+  }
+  return concat([
+    Uint8Array.of(
+      TYPE_ENVELOPE_RESPONSE,
+      response.status >> 8 & 255,
+      response.status & 255
+    ),
+    encodeHeaders(response.headers),
+    encodeVarOctetString(response.body)
+  ]);
+}
+function decodeEnvelopeResponse(buf) {
+  let offset = checkTypeByte(buf, TYPE_ENVELOPE_RESPONSE);
+  const high = buf[offset];
+  const low = buf[offset + 1];
+  if (high === void 0 || low === void 0) {
+    throw new EnvelopeError("buffer_underflow" /* BufferUnderflow */);
+  }
+  const status = high << 8 | low;
+  offset += 2;
+  const headers = decodeHeaders(buf, offset);
+  offset += headers.consumed;
+  const body = decodeOctets(buf, offset);
+  offset += body.consumed;
+  if (offset !== buf.length) {
+    throw new EnvelopeError("trailing_bytes" /* TrailingBytes */);
+  }
+  return { status, headers: headers.value, body: body.value };
+}
+function encodeEnvelope(envelope) {
+  return envelope.direction === "request" ? encodeEnvelopeRequest(envelope) : encodeEnvelopeResponse(envelope);
+}
+function decodeEnvelope(buf, direction) {
+  return direction === "request" ? { direction, ...decodeEnvelopeRequest(buf) } : { direction, ...decodeEnvelopeResponse(buf) };
+}
+
+// src/wire/giftwrap.ts
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { chacha20poly1305 } from "@noble/ciphers/chacha.js";
+import { hkdf } from "@noble/hashes/hkdf.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { randomBytes } from "@noble/hashes/utils.js";
+var GIFTWRAP_NONCE_LENGTH = 12;
+var GIFTWRAP_SECRET_LENGTH = 32;
+var GIFTWRAP_PUBLIC_KEY_LENGTH = 65;
+var REQUEST_INFO = "toon-giftwrap-request";
+var RESPONSE_INFO = "toon-giftwrap-response";
+var FULFILLMENT_INFO = "toon-giftwrap-fulfillment";
+var GIFTWRAP_TYPE_REQUEST = 1;
+var GIFTWRAP_TYPE_RESPONSE = 2;
+var TAG_LENGTH = 16;
+var GiftWrapErrorKind = /* @__PURE__ */ ((GiftWrapErrorKind2) => {
+  GiftWrapErrorKind2["InvalidType"] = "invalid_type";
+  GiftWrapErrorKind2["Truncated"] = "truncated";
+  GiftWrapErrorKind2["InvalidKey"] = "invalid_key";
+  GiftWrapErrorKind2["OpenFailed"] = "open_failed";
+  return GiftWrapErrorKind2;
+})(GiftWrapErrorKind || {});
+var GIFTWRAP_ERROR_MESSAGES = {
+  ["invalid_type" /* InvalidType */]: "invalid gift wrap type byte",
+  ["truncated" /* Truncated */]: "gift wrap is truncated",
+  ["invalid_key" /* InvalidKey */]: "invalid ephemeral or peer public key",
+  ["open_failed" /* OpenFailed */]: "gift wrap failed to decrypt"
+};
+var GiftWrapError = class extends Error {
+  constructor(kind, expectedType) {
+    super(
+      expectedType === void 0 ? GIFTWRAP_ERROR_MESSAGES[kind] : `${GIFTWRAP_ERROR_MESSAGES[kind]}: expected ${expectedType}`
+    );
+    this.kind = kind;
+    this.expectedType = expectedType;
+    this.name = "GiftWrapError";
+  }
+};
+function concat2(parts) {
+  const total = parts.reduce((sum, part) => sum + part.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+var UTF8_ENCODER2 = new TextEncoder();
+function hkdfKey(ikm, info) {
+  return hkdf(sha256, ikm, void 0, UTF8_ENCODER2.encode(info), 32);
+}
+function encryptWithNonce(key, plaintext, nonce) {
+  return concat2([nonce, chacha20poly1305(key, nonce).encrypt(plaintext)]);
+}
+function decrypt(key, nonceAndCiphertext) {
+  if (nonceAndCiphertext.length < GIFTWRAP_NONCE_LENGTH) {
+    throw new GiftWrapError("truncated" /* Truncated */);
+  }
+  const nonce = nonceAndCiphertext.subarray(0, GIFTWRAP_NONCE_LENGTH);
+  const ciphertext = nonceAndCiphertext.subarray(GIFTWRAP_NONCE_LENGTH);
+  if (ciphertext.length < TAG_LENGTH) {
+    throw new GiftWrapError("truncated" /* Truncated */);
+  }
+  try {
+    return chacha20poly1305(key, nonce).decrypt(ciphertext);
+  } catch {
+    throw new GiftWrapError("open_failed" /* OpenFailed */);
+  }
+}
+function ecdhXCoordinate(secretKey, publicKey) {
+  let compressed;
+  try {
+    compressed = secp256k1.getSharedSecret(secretKey, publicKey, true);
+  } catch {
+    throw new GiftWrapError("invalid_key" /* InvalidKey */);
+  }
+  return compressed.slice(1);
+}
+function localGiftWrapEcdh(secretKey) {
+  return {
+    ecdh: (ephemeralPublicKey) => ecdhXCoordinate(secretKey, ephemeralPublicKey)
+  };
+}
+function giftWrapPublicKey(secretKey) {
+  try {
+    return secp256k1.getPublicKey(secretKey, false);
+  } catch {
+    throw new GiftWrapError("invalid_key" /* InvalidKey */);
+  }
+}
+function sealRequestWithRandomness(plaintext, receiverPublicKey, ephemeralSecretKey, sharedSecret, nonce) {
+  if (sharedSecret.length !== GIFTWRAP_SECRET_LENGTH) {
+    throw new GiftWrapError("truncated" /* Truncated */);
+  }
+  if (nonce.length !== GIFTWRAP_NONCE_LENGTH) {
+    throw new GiftWrapError("truncated" /* Truncated */);
+  }
+  let ephemeralPublicKey;
+  try {
+    ephemeralPublicKey = secp256k1.getPublicKey(ephemeralSecretKey, false);
+  } catch {
+    throw new GiftWrapError("invalid_key" /* InvalidKey */);
+  }
+  const aeadKey = hkdfKey(
+    ecdhXCoordinate(ephemeralSecretKey, receiverPublicKey),
+    REQUEST_INFO
+  );
+  const inner = concat2([sharedSecret, plaintext]);
+  return concat2([
+    Uint8Array.of(GIFTWRAP_TYPE_REQUEST),
+    ephemeralPublicKey,
+    encryptWithNonce(aeadKey, inner, nonce)
+  ]);
+}
+function sealRequest(plaintext, receiverPublicKey) {
+  const ephemeralSecretKey = secp256k1.utils.randomSecretKey();
+  const sharedSecret = randomBytes(GIFTWRAP_SECRET_LENGTH);
+  const nonce = randomBytes(GIFTWRAP_NONCE_LENGTH);
+  return {
+    wrapped: sealRequestWithRandomness(
+      plaintext,
+      receiverPublicKey,
+      ephemeralSecretKey,
+      sharedSecret,
+      nonce
+    ),
+    sharedSecret
+  };
+}
+function openRequest(bytes, identity) {
+  if (bytes.length === 0) {
+    throw new GiftWrapError("truncated" /* Truncated */);
+  }
+  if (bytes[0] !== GIFTWRAP_TYPE_REQUEST) {
+    throw new GiftWrapError(
+      "invalid_type" /* InvalidType */,
+      GIFTWRAP_TYPE_REQUEST
+    );
+  }
+  if (bytes.length < 1 + GIFTWRAP_PUBLIC_KEY_LENGTH) {
+    throw new GiftWrapError("truncated" /* Truncated */);
+  }
+  const ephemeralPublicKey = bytes.slice(1, 1 + GIFTWRAP_PUBLIC_KEY_LENGTH);
+  const ciphertext = bytes.subarray(1 + GIFTWRAP_PUBLIC_KEY_LENGTH);
+  const agreement = identity instanceof Uint8Array ? localGiftWrapEcdh(identity) : identity;
+  let ecdhSecret;
+  try {
+    ecdhSecret = agreement.ecdh(ephemeralPublicKey);
+  } catch (error) {
+    throw error instanceof GiftWrapError ? error : new GiftWrapError("invalid_key" /* InvalidKey */);
+  }
+  const plaintext = decrypt(hkdfKey(ecdhSecret, REQUEST_INFO), ciphertext);
+  if (plaintext.length < GIFTWRAP_SECRET_LENGTH) {
+    throw new GiftWrapError("truncated" /* Truncated */);
+  }
+  return {
+    envelopeBytes: plaintext.slice(GIFTWRAP_SECRET_LENGTH),
+    sharedSecret: plaintext.slice(0, GIFTWRAP_SECRET_LENGTH)
+  };
+}
+function sealResponseWithRandomness(sharedSecret, plaintext, nonce) {
+  if (sharedSecret.length !== GIFTWRAP_SECRET_LENGTH) {
+    throw new GiftWrapError("truncated" /* Truncated */);
+  }
+  if (nonce.length !== GIFTWRAP_NONCE_LENGTH) {
+    throw new GiftWrapError("truncated" /* Truncated */);
+  }
+  return concat2([
+    Uint8Array.of(GIFTWRAP_TYPE_RESPONSE),
+    encryptWithNonce(hkdfKey(sharedSecret, RESPONSE_INFO), plaintext, nonce)
+  ]);
+}
+function sealResponse(sharedSecret, plaintext) {
+  return sealResponseWithRandomness(
+    sharedSecret,
+    plaintext,
+    randomBytes(GIFTWRAP_NONCE_LENGTH)
+  );
+}
+function openResponse(sharedSecret, bytes) {
+  if (bytes.length === 0) {
+    throw new GiftWrapError("truncated" /* Truncated */);
+  }
+  if (bytes[0] !== GIFTWRAP_TYPE_RESPONSE) {
+    throw new GiftWrapError(
+      "invalid_type" /* InvalidType */,
+      GIFTWRAP_TYPE_RESPONSE
+    );
+  }
+  if (sharedSecret.length !== GIFTWRAP_SECRET_LENGTH) {
+    throw new GiftWrapError("truncated" /* Truncated */);
+  }
+  return decrypt(hkdfKey(sharedSecret, RESPONSE_INFO), bytes.subarray(1));
+}
+function looksLikeSealedResponse(bytes) {
+  return bytes.length > 0 && bytes[0] === GIFTWRAP_TYPE_RESPONSE;
+}
+function deriveFulfillment(sharedSecret) {
+  if (sharedSecret.length !== GIFTWRAP_SECRET_LENGTH) {
+    throw new GiftWrapError("truncated" /* Truncated */);
+  }
+  return hkdfKey(sharedSecret, FULFILLMENT_INFO);
+}
+function deriveCondition(fulfillment) {
+  return sha256(fulfillment);
+}
+
+// src/wire/sealed-exchange.ts
+var SealedResponseError = class extends Error {
+  constructor(kind, message, cause) {
+    super(message);
+    this.kind = kind;
+    this.cause = cause;
+    this.name = "SealedResponseError";
+  }
+};
+function sealExchange(request, connectorPublicKey) {
+  const { wrapped, sharedSecret } = sealRequest(
+    encodeEnvelopeRequest(request),
+    connectorPublicKey
+  );
+  const fulfillment = deriveFulfillment(sharedSecret);
+  return {
+    data: wrapped,
+    condition: deriveCondition(fulfillment),
+    sharedSecret,
+    fulfillment
+  };
+}
+function readExchangeOutcome(result, data, sharedSecret) {
+  if (result.accepted) {
+    return { kind: "answered", response: openAnswer(data, sharedSecret) };
+  }
+  const code = result.code ?? "F00";
+  const message = result.message ?? "";
+  if (data !== void 0 && looksLikeSealedResponse(data)) {
+    try {
+      return {
+        kind: "destination-refused",
+        code,
+        message,
+        detail: openResponse(sharedSecret, data)
+      };
+    } catch (error) {
+      if (!(error instanceof GiftWrapError)) throw error;
+    }
+  }
+  return { kind: "path-refused", code, message };
+}
+function openAnswer(data, sharedSecret) {
+  if (data === void 0 || data.length === 0) {
+    throw new SealedResponseError(
+      "not-sealed",
+      "FULFILL carried no data; a terminated route always seals a response envelope"
+    );
+  }
+  if (!looksLikeSealedResponse(data)) {
+    throw new SealedResponseError(
+      "not-sealed",
+      `FULFILL data is not a sealed response (leading byte 0x${(data[0] ?? 0).toString(16).padStart(2, "0")}, expected 0x02)`
+    );
+  }
+  let opened;
+  try {
+    opened = openResponse(sharedSecret, data);
+  } catch (error) {
+    if (!(error instanceof GiftWrapError)) throw error;
+    throw new SealedResponseError(
+      "unopenable",
+      "FULFILL data did not open under this packet's shared secret",
+      error
+    );
+  }
+  try {
+    return decodeEnvelopeResponse(opened);
+  } catch (error) {
+    if (!(error instanceof EnvelopeError)) throw error;
+    throw new SealedResponseError(
+      "malformed-envelope",
+      `sealed answer opened but did not decode as a response envelope: ${error.message}`,
+      error
+    );
+  }
+}
+function envelopeHeader(response, name) {
+  const wanted = name.toLowerCase();
+  for (const [header, value] of response.headers) {
+    if (header.toLowerCase() === wanted) return value;
+  }
+  return void 0;
+}
+
+export {
+  OerErrorKind,
+  OerError,
+  encodeVarUint,
+  decodeVarUint,
+  encodeVarOctetString,
+  decodeVarOctetString,
+  EnvelopeErrorKind,
+  EnvelopeError,
+  encodeEnvelopeRequest,
+  decodeEnvelopeRequest,
+  encodeEnvelopeResponse,
+  decodeEnvelopeResponse,
+  encodeEnvelope,
+  decodeEnvelope,
+  GIFTWRAP_NONCE_LENGTH,
+  GIFTWRAP_SECRET_LENGTH,
+  GIFTWRAP_PUBLIC_KEY_LENGTH,
+  GIFTWRAP_TYPE_REQUEST,
+  GIFTWRAP_TYPE_RESPONSE,
+  GiftWrapErrorKind,
+  GiftWrapError,
+  localGiftWrapEcdh,
+  giftWrapPublicKey,
+  sealRequestWithRandomness,
+  sealRequest,
+  openRequest,
+  sealResponseWithRandomness,
+  sealResponse,
+  openResponse,
+  looksLikeSealedResponse,
+  deriveFulfillment,
+  deriveCondition,
+  SealedResponseError,
+  sealExchange,
+  readExchangeOutcome,
+  envelopeHeader
+};
+//# sourceMappingURL=chunk-K72H36Y4.js.map