@0dotxyz/p0-ts-sdk 2.2.0-alpha.4 → 2.2.0-beta.1

package/dist/vendor.cjs

@@ -10,6 +10,7 @@ var buffer = require('buffer');
 var anchor = require('@coral-xyz/anchor');
 var borsh = require('@coral-xyz/borsh');
 var Decimal3 = require('decimal.js');
+var WebSocket = require('ws');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -34,6 +35,7 @@ function _interopNamespace(e) {
 var BN2__default = /*#__PURE__*/_interopDefault(BN2);
 var borsh__namespace = /*#__PURE__*/_interopNamespace(borsh);
 var Decimal3__default = /*#__PURE__*/_interopDefault(Decimal3);
+var WebSocket__default = /*#__PURE__*/_interopDefault(WebSocket);
 
 // src/vendor/pyth_legacy/readBig.ts
 var ERR_BUFFER_OUT_OF_BOUNDS = () => new Error("Attempt to access memory outside buffer bounds");
@@ -510,36 +512,12 @@ function createMemoInstruction(memo, signerPubkeys) {
   });
 }
 var TokenInstruction = /* @__PURE__ */ ((TokenInstruction2) => {
-  TokenInstruction2[TokenInstruction2["Approve"] = 4] = "Approve";
   TokenInstruction2[TokenInstruction2["InitializeAccount"] = 1] = "InitializeAccount";
   TokenInstruction2[TokenInstruction2["TransferChecked"] = 12] = "TransferChecked";
   TokenInstruction2[TokenInstruction2["CloseAccount"] = 9] = "CloseAccount";
   TokenInstruction2[TokenInstruction2["SyncNative"] = 17] = "SyncNative";
   return TokenInstruction2;
 })(TokenInstruction || {});
-var approveInstructionData = bufferLayout.struct([
-  bufferLayout.u8("instruction"),
-  bufferLayoutUtils.u64("amount")
-]);
-function createApproveInstruction(account, delegate, owner, amount, multiSigners = [], programId = TOKEN_PROGRAM_ID) {
-  const keys = addSigners(
-    [
-      { pubkey: account, isSigner: false, isWritable: true },
-      { pubkey: delegate, isSigner: false, isWritable: false }
-    ],
-    owner,
-    multiSigners
-  );
-  const data = buffer.Buffer.alloc(approveInstructionData.span);
-  approveInstructionData.encode(
-    {
-      instruction: 4 /* Approve */,
-      amount: BigInt(amount)
-    },
-    data
-  );
-  return new web3_js.TransactionInstruction({ keys, programId, data });
-}
 var initializeAccountInstructionData = bufferLayout.struct([
   bufferLayout.u8("instruction")
 ]);
@@ -693,7 +671,6 @@ var SinglePoolInstruction = {
   },
   depositStake: async (pool, userStakeAccount, userTokenAccount, userLamportAccount) => {
     const stake = findPoolStakeAddress(pool);
-    const onRamp = findPoolOnRampAddress(pool);
     const mint = findPoolMintAddress(pool);
     const stakeAuthority = findPoolStakeAuthorityAddress(pool);
     const mintAuthority = findPoolMintAuthorityAddress(pool);
@@ -702,7 +679,6 @@ var SinglePoolInstruction = {
       [
         { pubkey: pool, isSigner: false, isWritable: false },
         { pubkey: stake, isSigner: false, isWritable: true },
-        { pubkey: onRamp, isSigner: false, isWritable: false },
         { pubkey: mint, isSigner: false, isWritable: true },
         { pubkey: stakeAuthority, isSigner: false, isWritable: false },
         { pubkey: mintAuthority, isSigner: false, isWritable: false },
@@ -719,7 +695,6 @@ var SinglePoolInstruction = {
   },
   withdrawStake: async (pool, userStakeAccount, userStakeAuthority, userTokenAccount, tokenAmount) => {
     const stake = findPoolStakeAddress(pool);
-    const onRamp = findPoolOnRampAddress(pool);
     const mint = findPoolMintAddress(pool);
     const stakeAuthority = findPoolStakeAuthorityAddress(pool);
     const mintAuthority = findPoolMintAuthorityAddress(pool);
@@ -734,7 +709,6 @@ var SinglePoolInstruction = {
       [
         { pubkey: pool, isSigner: false, isWritable: false },
         { pubkey: stake, isSigner: false, isWritable: true },
-        { pubkey: onRamp, isSigner: false, isWritable: false },
         { pubkey: mint, isSigner: false, isWritable: true },
         { pubkey: stakeAuthority, isSigner: false, isWritable: false },
         { pubkey: mintAuthority, isSigner: false, isWritable: false },
@@ -29191,17 +29165,1787 @@ function makeUpdateJupLendRate({ lendingState }) {
   );
 }
 
+// node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/utils/utf8.mjs
+function utf8Count(str) {
+  const strLength = str.length;
+  let byteLength = 0;
+  let pos = 0;
+  while (pos < strLength) {
+    let value = str.charCodeAt(pos++);
+    if ((value & 4294967168) === 0) {
+      byteLength++;
+      continue;
+    } else if ((value & 4294965248) === 0) {
+      byteLength += 2;
+    } else {
+      if (value >= 55296 && value <= 56319) {
+        if (pos < strLength) {
+          const extra = str.charCodeAt(pos);
+          if ((extra & 64512) === 56320) {
+            ++pos;
+            value = ((value & 1023) << 10) + (extra & 1023) + 65536;
+          }
+        }
+      }
+      if ((value & 4294901760) === 0) {
+        byteLength += 3;
+      } else {
+        byteLength += 4;
+      }
+    }
+  }
+  return byteLength;
+}
+function utf8EncodeJs(str, output, outputOffset) {
+  const strLength = str.length;
+  let offset = outputOffset;
+  let pos = 0;
+  while (pos < strLength) {
+    let value = str.charCodeAt(pos++);
+    if ((value & 4294967168) === 0) {
+      output[offset++] = value;
+      continue;
+    } else if ((value & 4294965248) === 0) {
+      output[offset++] = value >> 6 & 31 | 192;
+    } else {
+      if (value >= 55296 && value <= 56319) {
+        if (pos < strLength) {
+          const extra = str.charCodeAt(pos);
+          if ((extra & 64512) === 56320) {
+            ++pos;
+            value = ((value & 1023) << 10) + (extra & 1023) + 65536;
+          }
+        }
+      }
+      if ((value & 4294901760) === 0) {
+        output[offset++] = value >> 12 & 15 | 224;
+        output[offset++] = value >> 6 & 63 | 128;
+      } else {
+        output[offset++] = value >> 18 & 7 | 240;
+        output[offset++] = value >> 12 & 63 | 128;
+        output[offset++] = value >> 6 & 63 | 128;
+      }
+    }
+    output[offset++] = value & 63 | 128;
+  }
+}
+var sharedTextEncoder = new TextEncoder();
+var TEXT_ENCODER_THRESHOLD = 50;
+function utf8EncodeTE(str, output, outputOffset) {
+  sharedTextEncoder.encodeInto(str, output.subarray(outputOffset));
+}
+function utf8Encode(str, output, outputOffset) {
+  if (str.length > TEXT_ENCODER_THRESHOLD) {
+    utf8EncodeTE(str, output, outputOffset);
+  } else {
+    utf8EncodeJs(str, output, outputOffset);
+  }
+}
+var CHUNK_SIZE = 4096;
+function utf8DecodeJs(bytes, inputOffset, byteLength) {
+  let offset = inputOffset;
+  const end = offset + byteLength;
+  const units = [];
+  let result = "";
+  while (offset < end) {
+    const byte1 = bytes[offset++];
+    if ((byte1 & 128) === 0) {
+      units.push(byte1);
+    } else if ((byte1 & 224) === 192) {
+      const byte2 = bytes[offset++] & 63;
+      units.push((byte1 & 31) << 6 | byte2);
+    } else if ((byte1 & 240) === 224) {
+      const byte2 = bytes[offset++] & 63;
+      const byte3 = bytes[offset++] & 63;
+      units.push((byte1 & 31) << 12 | byte2 << 6 | byte3);
+    } else if ((byte1 & 248) === 240) {
+      const byte2 = bytes[offset++] & 63;
+      const byte3 = bytes[offset++] & 63;
+      const byte4 = bytes[offset++] & 63;
+      let unit = (byte1 & 7) << 18 | byte2 << 12 | byte3 << 6 | byte4;
+      if (unit > 65535) {
+        unit -= 65536;
+        units.push(unit >>> 10 & 1023 | 55296);
+        unit = 56320 | unit & 1023;
+      }
+      units.push(unit);
+    } else {
+      units.push(byte1);
+    }
+    if (units.length >= CHUNK_SIZE) {
+      result += String.fromCharCode(...units);
+      units.length = 0;
+    }
+  }
+  if (units.length > 0) {
+    result += String.fromCharCode(...units);
+  }
+  return result;
+}
+var sharedTextDecoder = new TextDecoder();
+var TEXT_DECODER_THRESHOLD = 200;
+function utf8DecodeTD(bytes, inputOffset, byteLength) {
+  const stringBytes = bytes.subarray(inputOffset, inputOffset + byteLength);
+  return sharedTextDecoder.decode(stringBytes);
+}
+function utf8Decode(bytes, inputOffset, byteLength) {
+  if (byteLength > TEXT_DECODER_THRESHOLD) {
+    return utf8DecodeTD(bytes, inputOffset, byteLength);
+  } else {
+    return utf8DecodeJs(bytes, inputOffset, byteLength);
+  }
+}
+
+// node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/ExtData.mjs
+var ExtData = class {
+  type;
+  data;
+  constructor(type, data) {
+    this.type = type;
+    this.data = data;
+  }
+};
+
+// node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/DecodeError.mjs
+var DecodeError = class _DecodeError extends Error {
+  constructor(message) {
+    super(message);
+    const proto = Object.create(_DecodeError.prototype);
+    Object.setPrototypeOf(this, proto);
+    Object.defineProperty(this, "name", {
+      configurable: true,
+      enumerable: false,
+      value: _DecodeError.name
+    });
+  }
+};
+
+// node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/utils/int.mjs
+var UINT32_MAX = 4294967295;
+function setUint64(view, offset, value) {
+  const high = value / 4294967296;
+  const low = value;
+  view.setUint32(offset, high);
+  view.setUint32(offset + 4, low);
+}
+function setInt64(view, offset, value) {
+  const high = Math.floor(value / 4294967296);
+  const low = value;
+  view.setUint32(offset, high);
+  view.setUint32(offset + 4, low);
+}
+function getInt64(view, offset) {
+  const high = view.getInt32(offset);
+  const low = view.getUint32(offset + 4);
+  return high * 4294967296 + low;
+}
+function getUint64(view, offset) {
+  const high = view.getUint32(offset);
+  const low = view.getUint32(offset + 4);
+  return high * 4294967296 + low;
+}
+
+// node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/timestamp.mjs
+var EXT_TIMESTAMP = -1;
+var TIMESTAMP32_MAX_SEC = 4294967296 - 1;
+var TIMESTAMP64_MAX_SEC = 17179869184 - 1;
+function encodeTimeSpecToTimestamp({ sec, nsec }) {
+  if (sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC) {
+    if (nsec === 0 && sec <= TIMESTAMP32_MAX_SEC) {
+      const rv = new Uint8Array(4);
+      const view = new DataView(rv.buffer);
+      view.setUint32(0, sec);
+      return rv;
+    } else {
+      const secHigh = sec / 4294967296;
+      const secLow = sec & 4294967295;
+      const rv = new Uint8Array(8);
+      const view = new DataView(rv.buffer);
+      view.setUint32(0, nsec << 2 | secHigh & 3);
+      view.setUint32(4, secLow);
+      return rv;
+    }
+  } else {
+    const rv = new Uint8Array(12);
+    const view = new DataView(rv.buffer);
+    view.setUint32(0, nsec);
+    setInt64(view, 4, sec);
+    return rv;
+  }
+}
+function encodeDateToTimeSpec(date) {
+  const msec = date.getTime();
+  const sec = Math.floor(msec / 1e3);
+  const nsec = (msec - sec * 1e3) * 1e6;
+  const nsecInSec = Math.floor(nsec / 1e9);
+  return {
+    sec: sec + nsecInSec,
+    nsec: nsec - nsecInSec * 1e9
+  };
+}
+function encodeTimestampExtension(object) {
+  if (object instanceof Date) {
+    const timeSpec = encodeDateToTimeSpec(object);
+    return encodeTimeSpecToTimestamp(timeSpec);
+  } else {
+    return null;
+  }
+}
+function decodeTimestampToTimeSpec(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  switch (data.byteLength) {
+    case 4: {
+      const sec = view.getUint32(0);
+      const nsec = 0;
+      return { sec, nsec };
+    }
+    case 8: {
+      const nsec30AndSecHigh2 = view.getUint32(0);
+      const secLow32 = view.getUint32(4);
+      const sec = (nsec30AndSecHigh2 & 3) * 4294967296 + secLow32;
+      const nsec = nsec30AndSecHigh2 >>> 2;
+      return { sec, nsec };
+    }
+    case 12: {
+      const sec = getInt64(view, 4);
+      const nsec = view.getUint32(0);
+      return { sec, nsec };
+    }
+    default:
+      throw new DecodeError(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${data.length}`);
+  }
+}
+function decodeTimestampExtension(data) {
+  const timeSpec = decodeTimestampToTimeSpec(data);
+  return new Date(timeSpec.sec * 1e3 + timeSpec.nsec / 1e6);
+}
+var timestampExtension = {
+  type: EXT_TIMESTAMP,
+  encode: encodeTimestampExtension,
+  decode: decodeTimestampExtension
+};
+
+// node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/ExtensionCodec.mjs
+var ExtensionCodec = class _ExtensionCodec {
+  static defaultCodec = new _ExtensionCodec();
+  // ensures ExtensionCodecType<X> matches ExtensionCodec<X>
+  // this will make type errors a lot more clear
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  __brand;
+  // built-in extensions
+  builtInEncoders = [];
+  builtInDecoders = [];
+  // custom extensions
+  encoders = [];
+  decoders = [];
+  constructor() {
+    this.register(timestampExtension);
+  }
+  register({ type, encode, decode }) {
+    if (type >= 0) {
+      this.encoders[type] = encode;
+      this.decoders[type] = decode;
+    } else {
+      const index = -1 - type;
+      this.builtInEncoders[index] = encode;
+      this.builtInDecoders[index] = decode;
+    }
+  }
+  tryToEncode(object, context) {
+    for (let i = 0; i < this.builtInEncoders.length; i++) {
+      const encodeExt = this.builtInEncoders[i];
+      if (encodeExt != null) {
+        const data = encodeExt(object, context);
+        if (data != null) {
+          const type = -1 - i;
+          return new ExtData(type, data);
+        }
+      }
+    }
+    for (let i = 0; i < this.encoders.length; i++) {
+      const encodeExt = this.encoders[i];
+      if (encodeExt != null) {
+        const data = encodeExt(object, context);
+        if (data != null) {
+          const type = i;
+          return new ExtData(type, data);
+        }
+      }
+    }
+    if (object instanceof ExtData) {
+      return object;
+    }
+    return null;
+  }
+  decode(data, type, context) {
+    const decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];
+    if (decodeExt) {
+      return decodeExt(data, type, context);
+    } else {
+      return new ExtData(type, data);
+    }
+  }
+};
+
+// node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/utils/typedArrays.mjs
+function isArrayBufferLike(buffer) {
+  return buffer instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer;
+}
+function ensureUint8Array(buffer) {
+  if (buffer instanceof Uint8Array) {
+    return buffer;
+  } else if (ArrayBuffer.isView(buffer)) {
+    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  } else if (isArrayBufferLike(buffer)) {
+    return new Uint8Array(buffer);
+  } else {
+    return Uint8Array.from(buffer);
+  }
+}
+
+// node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/Encoder.mjs
+var DEFAULT_MAX_DEPTH = 100;
+var DEFAULT_INITIAL_BUFFER_SIZE = 2048;
+var Encoder = class _Encoder {
+  extensionCodec;
+  context;
+  useBigInt64;
+  maxDepth;
+  initialBufferSize;
+  sortKeys;
+  forceFloat32;
+  ignoreUndefined;
+  forceIntegerToFloat;
+  pos;
+  view;
+  bytes;
+  entered = false;
+  constructor(options) {
+    this.extensionCodec = options?.extensionCodec ?? ExtensionCodec.defaultCodec;
+    this.context = options?.context;
+    this.useBigInt64 = options?.useBigInt64 ?? false;
+    this.maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+    this.initialBufferSize = options?.initialBufferSize ?? DEFAULT_INITIAL_BUFFER_SIZE;
+    this.sortKeys = options?.sortKeys ?? false;
+    this.forceFloat32 = options?.forceFloat32 ?? false;
+    this.ignoreUndefined = options?.ignoreUndefined ?? false;
+    this.forceIntegerToFloat = options?.forceIntegerToFloat ?? false;
+    this.pos = 0;
+    this.view = new DataView(new ArrayBuffer(this.initialBufferSize));
+    this.bytes = new Uint8Array(this.view.buffer);
+  }
+  clone() {
+    return new _Encoder({
+      extensionCodec: this.extensionCodec,
+      context: this.context,
+      useBigInt64: this.useBigInt64,
+      maxDepth: this.maxDepth,
+      initialBufferSize: this.initialBufferSize,
+      sortKeys: this.sortKeys,
+      forceFloat32: this.forceFloat32,
+      ignoreUndefined: this.ignoreUndefined,
+      forceIntegerToFloat: this.forceIntegerToFloat
+    });
+  }
+  reinitializeState() {
+    this.pos = 0;
+  }
+  /**
+   * This is almost equivalent to {@link Encoder#encode}, but it returns an reference of the encoder's internal buffer and thus much faster than {@link Encoder#encode}.
+   *
+   * @returns Encodes the object and returns a shared reference the encoder's internal buffer.
+   */
+  encodeSharedRef(object) {
+    if (this.entered) {
+      const instance = this.clone();
+      return instance.encodeSharedRef(object);
+    }
+    try {
+      this.entered = true;
+      this.reinitializeState();
+      this.doEncode(object, 1);
+      return this.bytes.subarray(0, this.pos);
+    } finally {
+      this.entered = false;
+    }
+  }
+  /**
+   * @returns Encodes the object and returns a copy of the encoder's internal buffer.
+   */
+  encode(object) {
+    if (this.entered) {
+      const instance = this.clone();
+      return instance.encode(object);
+    }
+    try {
+      this.entered = true;
+      this.reinitializeState();
+      this.doEncode(object, 1);
+      return this.bytes.slice(0, this.pos);
+    } finally {
+      this.entered = false;
+    }
+  }
+  doEncode(object, depth) {
+    if (depth > this.maxDepth) {
+      throw new Error(`Too deep objects in depth ${depth}`);
+    }
+    if (object == null) {
+      this.encodeNil();
+    } else if (typeof object === "boolean") {
+      this.encodeBoolean(object);
+    } else if (typeof object === "number") {
+      if (!this.forceIntegerToFloat) {
+        this.encodeNumber(object);
+      } else {
+        this.encodeNumberAsFloat(object);
+      }
+    } else if (typeof object === "string") {
+      this.encodeString(object);
+    } else if (this.useBigInt64 && typeof object === "bigint") {
+      this.encodeBigInt64(object);
+    } else {
+      this.encodeObject(object, depth);
+    }
+  }
+  ensureBufferSizeToWrite(sizeToWrite) {
+    const requiredSize = this.pos + sizeToWrite;
+    if (this.view.byteLength < requiredSize) {
+      this.resizeBuffer(requiredSize * 2);
+    }
+  }
+  resizeBuffer(newSize) {
+    const newBuffer = new ArrayBuffer(newSize);
+    const newBytes = new Uint8Array(newBuffer);
+    const newView = new DataView(newBuffer);
+    newBytes.set(this.bytes);
+    this.view = newView;
+    this.bytes = newBytes;
+  }
+  encodeNil() {
+    this.writeU8(192);
+  }
+  encodeBoolean(object) {
+    if (object === false) {
+      this.writeU8(194);
+    } else {
+      this.writeU8(195);
+    }
+  }
+  encodeNumber(object) {
+    if (!this.forceIntegerToFloat && Number.isSafeInteger(object)) {
+      if (object >= 0) {
+        if (object < 128) {
+          this.writeU8(object);
+        } else if (object < 256) {
+          this.writeU8(204);
+          this.writeU8(object);
+        } else if (object < 65536) {
+          this.writeU8(205);
+          this.writeU16(object);
+        } else if (object < 4294967296) {
+          this.writeU8(206);
+          this.writeU32(object);
+        } else if (!this.useBigInt64) {
+          this.writeU8(207);
+          this.writeU64(object);
+        } else {
+          this.encodeNumberAsFloat(object);
+        }
+      } else {
+        if (object >= -32) {
+          this.writeU8(224 | object + 32);
+        } else if (object >= -128) {
+          this.writeU8(208);
+          this.writeI8(object);
+        } else if (object >= -32768) {
+          this.writeU8(209);
+          this.writeI16(object);
+        } else if (object >= -2147483648) {
+          this.writeU8(210);
+          this.writeI32(object);
+        } else if (!this.useBigInt64) {
+          this.writeU8(211);
+          this.writeI64(object);
+        } else {
+          this.encodeNumberAsFloat(object);
+        }
+      }
+    } else {
+      this.encodeNumberAsFloat(object);
+    }
+  }
+  encodeNumberAsFloat(object) {
+    if (this.forceFloat32) {
+      this.writeU8(202);
+      this.writeF32(object);
+    } else {
+      this.writeU8(203);
+      this.writeF64(object);
+    }
+  }
+  encodeBigInt64(object) {
+    if (object >= BigInt(0)) {
+      this.writeU8(207);
+      this.writeBigUint64(object);
+    } else {
+      this.writeU8(211);
+      this.writeBigInt64(object);
+    }
+  }
+  writeStringHeader(byteLength) {
+    if (byteLength < 32) {
+      this.writeU8(160 + byteLength);
+    } else if (byteLength < 256) {
+      this.writeU8(217);
+      this.writeU8(byteLength);
+    } else if (byteLength < 65536) {
+      this.writeU8(218);
+      this.writeU16(byteLength);
+    } else if (byteLength < 4294967296) {
+      this.writeU8(219);
+      this.writeU32(byteLength);
+    } else {
+      throw new Error(`Too long string: ${byteLength} bytes in UTF-8`);
+    }
+  }
+  encodeString(object) {
+    const maxHeaderSize = 1 + 4;
+    const byteLength = utf8Count(object);
+    this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+    this.writeStringHeader(byteLength);
+    utf8Encode(object, this.bytes, this.pos);
+    this.pos += byteLength;
+  }
+  encodeObject(object, depth) {
+    const ext = this.extensionCodec.tryToEncode(object, this.context);
+    if (ext != null) {
+      this.encodeExtension(ext);
+    } else if (Array.isArray(object)) {
+      this.encodeArray(object, depth);
+    } else if (ArrayBuffer.isView(object)) {
+      this.encodeBinary(object);
+    } else if (typeof object === "object") {
+      this.encodeMap(object, depth);
+    } else {
+      throw new Error(`Unrecognized object: ${Object.prototype.toString.apply(object)}`);
+    }
+  }
+  encodeBinary(object) {
+    const size = object.byteLength;
+    if (size < 256) {
+      this.writeU8(196);
+      this.writeU8(size);
+    } else if (size < 65536) {
+      this.writeU8(197);
+      this.writeU16(size);
+    } else if (size < 4294967296) {
+      this.writeU8(198);
+      this.writeU32(size);
+    } else {
+      throw new Error(`Too large binary: ${size}`);
+    }
+    const bytes = ensureUint8Array(object);
+    this.writeU8a(bytes);
+  }
+  encodeArray(object, depth) {
+    const size = object.length;
+    if (size < 16) {
+      this.writeU8(144 + size);
+    } else if (size < 65536) {
+      this.writeU8(220);
+      this.writeU16(size);
+    } else if (size < 4294967296) {
+      this.writeU8(221);
+      this.writeU32(size);
+    } else {
+      throw new Error(`Too large array: ${size}`);
+    }
+    for (const item of object) {
+      this.doEncode(item, depth + 1);
+    }
+  }
+  countWithoutUndefined(object, keys) {
+    let count = 0;
+    for (const key of keys) {
+      if (object[key] !== void 0) {
+        count++;
+      }
+    }
+    return count;
+  }
+  encodeMap(object, depth) {
+    const keys = Object.keys(object);
+    if (this.sortKeys) {
+      keys.sort();
+    }
+    const size = this.ignoreUndefined ? this.countWithoutUndefined(object, keys) : keys.length;
+    if (size < 16) {
+      this.writeU8(128 + size);
+    } else if (size < 65536) {
+      this.writeU8(222);
+      this.writeU16(size);
+    } else if (size < 4294967296) {
+      this.writeU8(223);
+      this.writeU32(size);
+    } else {
+      throw new Error(`Too large map object: ${size}`);
+    }
+    for (const key of keys) {
+      const value = object[key];
+      if (!(this.ignoreUndefined && value === void 0)) {
+        this.encodeString(key);
+        this.doEncode(value, depth + 1);
+      }
+    }
+  }
+  encodeExtension(ext) {
+    if (typeof ext.data === "function") {
+      const data = ext.data(this.pos + 6);
+      const size2 = data.length;
+      if (size2 >= 4294967296) {
+        throw new Error(`Too large extension object: ${size2}`);
+      }
+      this.writeU8(201);
+      this.writeU32(size2);
+      this.writeI8(ext.type);
+      this.writeU8a(data);
+      return;
+    }
+    const size = ext.data.length;
+    if (size === 1) {
+      this.writeU8(212);
+    } else if (size === 2) {
+      this.writeU8(213);
+    } else if (size === 4) {
+      this.writeU8(214);
+    } else if (size === 8) {
+      this.writeU8(215);
+    } else if (size === 16) {
+      this.writeU8(216);
+    } else if (size < 256) {
+      this.writeU8(199);
+      this.writeU8(size);
+    } else if (size < 65536) {
+      this.writeU8(200);
+      this.writeU16(size);
+    } else if (size < 4294967296) {
+      this.writeU8(201);
+      this.writeU32(size);
+    } else {
+      throw new Error(`Too large extension object: ${size}`);
+    }
+    this.writeI8(ext.type);
+    this.writeU8a(ext.data);
+  }
+  writeU8(value) {
+    this.ensureBufferSizeToWrite(1);
+    this.view.setUint8(this.pos, value);
+    this.pos++;
+  }
+  writeU8a(values) {
+    const size = values.length;
+    this.ensureBufferSizeToWrite(size);
+    this.bytes.set(values, this.pos);
+    this.pos += size;
+  }
+  writeI8(value) {
+    this.ensureBufferSizeToWrite(1);
+    this.view.setInt8(this.pos, value);
+    this.pos++;
+  }
+  writeU16(value) {
+    this.ensureBufferSizeToWrite(2);
+    this.view.setUint16(this.pos, value);
+    this.pos += 2;
+  }
+  writeI16(value) {
+    this.ensureBufferSizeToWrite(2);
+    this.view.setInt16(this.pos, value);
+    this.pos += 2;
+  }
+  writeU32(value) {
+    this.ensureBufferSizeToWrite(4);
+    this.view.setUint32(this.pos, value);
+    this.pos += 4;
+  }
+  writeI32(value) {
+    this.ensureBufferSizeToWrite(4);
+    this.view.setInt32(this.pos, value);
+    this.pos += 4;
+  }
+  writeF32(value) {
+    this.ensureBufferSizeToWrite(4);
+    this.view.setFloat32(this.pos, value);
+    this.pos += 4;
+  }
+  writeF64(value) {
+    this.ensureBufferSizeToWrite(8);
+    this.view.setFloat64(this.pos, value);
+    this.pos += 8;
+  }
+  writeU64(value) {
+    this.ensureBufferSizeToWrite(8);
+    setUint64(this.view, this.pos, value);
+    this.pos += 8;
+  }
+  writeI64(value) {
+    this.ensureBufferSizeToWrite(8);
+    setInt64(this.view, this.pos, value);
+    this.pos += 8;
+  }
+  writeBigUint64(value) {
+    this.ensureBufferSizeToWrite(8);
+    this.view.setBigUint64(this.pos, value);
+    this.pos += 8;
+  }
+  writeBigInt64(value) {
+    this.ensureBufferSizeToWrite(8);
+    this.view.setBigInt64(this.pos, value);
+    this.pos += 8;
+  }
+};
+
+// node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/utils/prettyByte.mjs
+function prettyByte(byte) {
+  return `${byte < 0 ? "-" : ""}0x${Math.abs(byte).toString(16).padStart(2, "0")}`;
+}
+
+// node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/CachedKeyDecoder.mjs
+var DEFAULT_MAX_KEY_LENGTH = 16;
+var DEFAULT_MAX_LENGTH_PER_KEY = 16;
+var CachedKeyDecoder = class {
+  hit = 0;
+  miss = 0;
+  caches;
+  maxKeyLength;
+  maxLengthPerKey;
+  constructor(maxKeyLength = DEFAULT_MAX_KEY_LENGTH, maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY) {
+    this.maxKeyLength = maxKeyLength;
+    this.maxLengthPerKey = maxLengthPerKey;
+    this.caches = [];
+    for (let i = 0; i < this.maxKeyLength; i++) {
+      this.caches.push([]);
+    }
+  }
+  canBeCached(byteLength) {
+    return byteLength > 0 && byteLength <= this.maxKeyLength;
+  }
+  find(bytes, inputOffset, byteLength) {
+    const records = this.caches[byteLength - 1];
+    FIND_CHUNK: for (const record of records) {
+      const recordBytes = record.bytes;
+      for (let j = 0; j < byteLength; j++) {
+        if (recordBytes[j] !== bytes[inputOffset + j]) {
+          continue FIND_CHUNK;
+        }
+      }
+      return record.str;
+    }
+    return null;
+  }
+  store(bytes, value) {
+    const records = this.caches[bytes.length - 1];
+    const record = { bytes, str: value };
+    if (records.length >= this.maxLengthPerKey) {
+      records[Math.random() * records.length | 0] = record;
+    } else {
+      records.push(record);
+    }
+  }
+  decode(bytes, inputOffset, byteLength) {
+    const cachedValue = this.find(bytes, inputOffset, byteLength);
+    if (cachedValue != null) {
+      this.hit++;
+      return cachedValue;
+    }
+    this.miss++;
+    const str = utf8DecodeJs(bytes, inputOffset, byteLength);
+    const slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);
+    this.store(slicedCopyOfBytes, str);
+    return str;
+  }
+};
+
+// node_modules/.pnpm/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/Decoder.mjs
+var STATE_ARRAY = "array";
+var STATE_MAP_KEY = "map_key";
+var STATE_MAP_VALUE = "map_value";
+var mapKeyConverter = (key) => {
+  if (typeof key === "string" || typeof key === "number") {
+    return key;
+  }
+  throw new DecodeError("The type of key must be string or number but " + typeof key);
+};
+var StackPool = class {
+  stack = [];
+  stackHeadPosition = -1;
+  get length() {
+    return this.stackHeadPosition + 1;
+  }
+  top() {
+    return this.stack[this.stackHeadPosition];
+  }
+  pushArrayState(size) {
+    const state = this.getUninitializedStateFromPool();
+    state.type = STATE_ARRAY;
+    state.position = 0;
+    state.size = size;
+    state.array = new Array(size);
+  }
+  pushMapState(size) {
+    const state = this.getUninitializedStateFromPool();
+    state.type = STATE_MAP_KEY;
+    state.readCount = 0;
+    state.size = size;
+    state.map = {};
+  }
+  getUninitializedStateFromPool() {
+    this.stackHeadPosition++;
+    if (this.stackHeadPosition === this.stack.length) {
+      const partialState = {
+        type: void 0,
+        size: 0,
+        array: void 0,
+        position: 0,
+        readCount: 0,
+        map: void 0,
+        key: null
+      };
+      this.stack.push(partialState);
+    }
+    return this.stack[this.stackHeadPosition];
+  }
+  release(state) {
+    const topStackState = this.stack[this.stackHeadPosition];
+    if (topStackState !== state) {
+      throw new Error("Invalid stack state. Released state is not on top of the stack.");
+    }
+    if (state.type === STATE_ARRAY) {
+      const partialState = state;
+      partialState.size = 0;
+      partialState.array = void 0;
+      partialState.position = 0;
+      partialState.type = void 0;
+    }
+    if (state.type === STATE_MAP_KEY || state.type === STATE_MAP_VALUE) {
+      const partialState = state;
+      partialState.size = 0;
+      partialState.map = void 0;
+      partialState.readCount = 0;
+      partialState.type = void 0;
+    }
+    this.stackHeadPosition--;
+  }
+  reset() {
+    this.stack.length = 0;
+    this.stackHeadPosition = -1;
+  }
+};
+var HEAD_BYTE_REQUIRED = -1;
+var EMPTY_VIEW = new DataView(new ArrayBuffer(0));
+var EMPTY_BYTES = new Uint8Array(EMPTY_VIEW.buffer);
+try {
+  EMPTY_VIEW.getInt8(0);
+} catch (e) {
+  if (!(e instanceof RangeError)) {
+    throw new Error("This module is not supported in the current JavaScript engine because DataView does not throw RangeError on out-of-bounds access");
+  }
+}
+var MORE_DATA = new RangeError("Insufficient data");
+var sharedCachedKeyDecoder = new CachedKeyDecoder();
+var Decoder = class _Decoder {
+  extensionCodec;
+  context;
+  useBigInt64;
+  rawStrings;
+  maxStrLength;
+  maxBinLength;
+  maxArrayLength;
+  maxMapLength;
+  maxExtLength;
+  keyDecoder;
+  mapKeyConverter;
+  totalPos = 0;
+  pos = 0;
+  view = EMPTY_VIEW;
+  bytes = EMPTY_BYTES;
+  headByte = HEAD_BYTE_REQUIRED;
+  stack = new StackPool();
+  entered = false;
+  constructor(options) {
+    this.extensionCodec = options?.extensionCodec ?? ExtensionCodec.defaultCodec;
+    this.context = options?.context;
+    this.useBigInt64 = options?.useBigInt64 ?? false;
+    this.rawStrings = options?.rawStrings ?? false;
+    this.maxStrLength = options?.maxStrLength ?? UINT32_MAX;
+    this.maxBinLength = options?.maxBinLength ?? UINT32_MAX;
+    this.maxArrayLength = options?.maxArrayLength ?? UINT32_MAX;
+    this.maxMapLength = options?.maxMapLength ?? UINT32_MAX;
+    this.maxExtLength = options?.maxExtLength ?? UINT32_MAX;
+    this.keyDecoder = options?.keyDecoder !== void 0 ? options.keyDecoder : sharedCachedKeyDecoder;
+    this.mapKeyConverter = options?.mapKeyConverter ?? mapKeyConverter;
+  }
+  clone() {
+    return new _Decoder({
+      extensionCodec: this.extensionCodec,
+      context: this.context,
+      useBigInt64: this.useBigInt64,
+      rawStrings: this.rawStrings,
+      maxStrLength: this.maxStrLength,
+      maxBinLength: this.maxBinLength,
+      maxArrayLength: this.maxArrayLength,
+      maxMapLength: this.maxMapLength,
+      maxExtLength: this.maxExtLength,
+      keyDecoder: this.keyDecoder
+    });
+  }
+  reinitializeState() {
+    this.totalPos = 0;
+    this.headByte = HEAD_BYTE_REQUIRED;
+    this.stack.reset();
+  }
+  setBuffer(buffer) {
+    const bytes = ensureUint8Array(buffer);
+    this.bytes = bytes;
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    this.pos = 0;
+  }
+  appendBuffer(buffer) {
+    if (this.headByte === HEAD_BYTE_REQUIRED && !this.hasRemaining(1)) {
+      this.setBuffer(buffer);
+    } else {
+      const remainingData = this.bytes.subarray(this.pos);
+      const newData = ensureUint8Array(buffer);
+      const newBuffer = new Uint8Array(remainingData.length + newData.length);
+      newBuffer.set(remainingData);
+      newBuffer.set(newData, remainingData.length);
+      this.setBuffer(newBuffer);
+    }
+  }
+  hasRemaining(size) {
+    return this.view.byteLength - this.pos >= size;
+  }
+  createExtraByteError(posToShow) {
+    const { view, pos } = this;
+    return new RangeError(`Extra ${view.byteLength - pos} of ${view.byteLength} byte(s) found at buffer[${posToShow}]`);
+  }
+  /**
+   * @throws {@link DecodeError}
+   * @throws {@link RangeError}
+   */
+  decode(buffer) {
+    if (this.entered) {
+      const instance = this.clone();
+      return instance.decode(buffer);
+    }
+    try {
+      this.entered = true;
+      this.reinitializeState();
+      this.setBuffer(buffer);
+      const object = this.doDecodeSync();
+      if (this.hasRemaining(1)) {
+        throw this.createExtraByteError(this.pos);
+      }
+      return object;
+    } finally {
+      this.entered = false;
+    }
+  }
+  *decodeMulti(buffer) {
+    if (this.entered) {
+      const instance = this.clone();
+      yield* instance.decodeMulti(buffer);
+      return;
+    }
+    try {
+      this.entered = true;
+      this.reinitializeState();
+      this.setBuffer(buffer);
+      while (this.hasRemaining(1)) {
+        yield this.doDecodeSync();
+      }
+    } finally {
+      this.entered = false;
+    }
+  }
+  async decodeAsync(stream) {
+    if (this.entered) {
+      const instance = this.clone();
+      return instance.decodeAsync(stream);
+    }
+    try {
+      this.entered = true;
+      let decoded = false;
+      let object;
+      for await (const buffer of stream) {
+        if (decoded) {
+          this.entered = false;
+          throw this.createExtraByteError(this.totalPos);
+        }
+        this.appendBuffer(buffer);
+        try {
+          object = this.doDecodeSync();
+          decoded = true;
+        } catch (e) {
+          if (!(e instanceof RangeError)) {
+            throw e;
+          }
+        }
+        this.totalPos += this.pos;
+      }
+      if (decoded) {
+        if (this.hasRemaining(1)) {
+          throw this.createExtraByteError(this.totalPos);
+        }
+        return object;
+      }
+      const { headByte, pos, totalPos } = this;
+      throw new RangeError(`Insufficient data in parsing ${prettyByte(headByte)} at ${totalPos} (${pos} in the current buffer)`);
+    } finally {
+      this.entered = false;
+    }
+  }
+  decodeArrayStream(stream) {
+    return this.decodeMultiAsync(stream, true);
+  }
+  decodeStream(stream) {
+    return this.decodeMultiAsync(stream, false);
+  }
+  async *decodeMultiAsync(stream, isArray) {
+    if (this.entered) {
+      const instance = this.clone();
+      yield* instance.decodeMultiAsync(stream, isArray);
+      return;
+    }
+    try {
+      this.entered = true;
+      let isArrayHeaderRequired = isArray;
+      let arrayItemsLeft = -1;
+      for await (const buffer of stream) {
+        if (isArray && arrayItemsLeft === 0) {
+          throw this.createExtraByteError(this.totalPos);
+        }
+        this.appendBuffer(buffer);
+        if (isArrayHeaderRequired) {
+          arrayItemsLeft = this.readArraySize();
+          isArrayHeaderRequired = false;
+          this.complete();
+        }
+        try {
+          while (true) {
+            yield this.doDecodeSync();
+            if (--arrayItemsLeft === 0) {
+              break;
+            }
+          }
+        } catch (e) {
+          if (!(e instanceof RangeError)) {
+            throw e;
+          }
+        }
+        this.totalPos += this.pos;
+      }
+    } finally {
+      this.entered = false;
+    }
+  }
+  doDecodeSync() {
+    DECODE: while (true) {
+      const headByte = this.readHeadByte();
+      let object;
+      if (headByte >= 224) {
+        object = headByte - 256;
+      } else if (headByte < 192) {
+        if (headByte < 128) {
+          object = headByte;
+        } else if (headByte < 144) {
+          const size = headByte - 128;
+          if (size !== 0) {
+            this.pushMapState(size);
+            this.complete();
+            continue DECODE;
+          } else {
+            object = {};
+          }
+        } else if (headByte < 160) {
+          const size = headByte - 144;
+          if (size !== 0) {
+            this.pushArrayState(size);
+            this.complete();
+            continue DECODE;
+          } else {
+            object = [];
+          }
+        } else {
+          const byteLength = headByte - 160;
+          object = this.decodeString(byteLength, 0);
+        }
+      } else if (headByte === 192) {
+        object = null;
+      } else if (headByte === 194) {
+        object = false;
+      } else if (headByte === 195) {
+        object = true;
+      } else if (headByte === 202) {
+        object = this.readF32();
+      } else if (headByte === 203) {
+        object = this.readF64();
+      } else if (headByte === 204) {
+        object = this.readU8();
+      } else if (headByte === 205) {
+        object = this.readU16();
+      } else if (headByte === 206) {
+        object = this.readU32();
+      } else if (headByte === 207) {
+        if (this.useBigInt64) {
+          object = this.readU64AsBigInt();
+        } else {
+          object = this.readU64();
+        }
+      } else if (headByte === 208) {
+        object = this.readI8();
+      } else if (headByte === 209) {
+        object = this.readI16();
+      } else if (headByte === 210) {
+        object = this.readI32();
+      } else if (headByte === 211) {
+        if (this.useBigInt64) {
+          object = this.readI64AsBigInt();
+        } else {
+          object = this.readI64();
+        }
+      } else if (headByte === 217) {
+        const byteLength = this.lookU8();
+        object = this.decodeString(byteLength, 1);
+      } else if (headByte === 218) {
+        const byteLength = this.lookU16();
+        object = this.decodeString(byteLength, 2);
+      } else if (headByte === 219) {
+        const byteLength = this.lookU32();
+        object = this.decodeString(byteLength, 4);
+      } else if (headByte === 220) {
+        const size = this.readU16();
+        if (size !== 0) {
+          this.pushArrayState(size);
+          this.complete();
+          continue DECODE;
+        } else {
+          object = [];
+        }
+      } else if (headByte === 221) {
+        const size = this.readU32();
+        if (size !== 0) {
+          this.pushArrayState(size);
+          this.complete();
+          continue DECODE;
+        } else {
+          object = [];
+        }
+      } else if (headByte === 222) {
+        const size = this.readU16();
+        if (size !== 0) {
+          this.pushMapState(size);
+          this.complete();
+          continue DECODE;
+        } else {
+          object = {};
+        }
+      } else if (headByte === 223) {
+        const size = this.readU32();
+        if (size !== 0) {
+          this.pushMapState(size);
+          this.complete();
+          continue DECODE;
+        } else {
+          object = {};
+        }
+      } else if (headByte === 196) {
+        const size = this.lookU8();
+        object = this.decodeBinary(size, 1);
+      } else if (headByte === 197) {
+        const size = this.lookU16();
+        object = this.decodeBinary(size, 2);
+      } else if (headByte === 198) {
+        const size = this.lookU32();
+        object = this.decodeBinary(size, 4);
+      } else if (headByte === 212) {
+        object = this.decodeExtension(1, 0);
+      } else if (headByte === 213) {
+        object = this.decodeExtension(2, 0);
+      } else if (headByte === 214) {
+        object = this.decodeExtension(4, 0);
+      } else if (headByte === 215) {
+        object = this.decodeExtension(8, 0);
+      } else if (headByte === 216) {
+        object = this.decodeExtension(16, 0);
+      } else if (headByte === 199) {
+        const size = this.lookU8();
+        object = this.decodeExtension(size, 1);
+      } else if (headByte === 200) {
+        const size = this.lookU16();
+        object = this.decodeExtension(size, 2);
+      } else if (headByte === 201) {
+        const size = this.lookU32();
+        object = this.decodeExtension(size, 4);
+      } else {
+        throw new DecodeError(`Unrecognized type byte: ${prettyByte(headByte)}`);
+      }
+      this.complete();
+      const stack = this.stack;
+      while (stack.length > 0) {
+        const state = stack.top();
+        if (state.type === STATE_ARRAY) {
+          state.array[state.position] = object;
+          state.position++;
+          if (state.position === state.size) {
+            object = state.array;
+            stack.release(state);
+          } else {
+            continue DECODE;
+          }
+        } else if (state.type === STATE_MAP_KEY) {
+          if (object === "__proto__") {
+            throw new DecodeError("The key __proto__ is not allowed");
+          }
+          state.key = this.mapKeyConverter(object);
+          state.type = STATE_MAP_VALUE;
+          continue DECODE;
+        } else {
+          state.map[state.key] = object;
+          state.readCount++;
+          if (state.readCount === state.size) {
+            object = state.map;
+            stack.release(state);
+          } else {
+            state.key = null;
+            state.type = STATE_MAP_KEY;
+            continue DECODE;
+          }
+        }
+      }
+      return object;
+    }
+  }
+  readHeadByte() {
+    if (this.headByte === HEAD_BYTE_REQUIRED) {
+      this.headByte = this.readU8();
+    }
+    return this.headByte;
+  }
+  complete() {
+    this.headByte = HEAD_BYTE_REQUIRED;
+  }
+  readArraySize() {
+    const headByte = this.readHeadByte();
+    switch (headByte) {
+      case 220:
+        return this.readU16();
+      case 221:
+        return this.readU32();
+      default: {
+        if (headByte < 160) {
+          return headByte - 144;
+        } else {
+          throw new DecodeError(`Unrecognized array type byte: ${prettyByte(headByte)}`);
+        }
+      }
+    }
+  }
+  pushMapState(size) {
+    if (size > this.maxMapLength) {
+      throw new DecodeError(`Max length exceeded: map length (${size}) > maxMapLengthLength (${this.maxMapLength})`);
+    }
+    this.stack.pushMapState(size);
+  }
+  pushArrayState(size) {
+    if (size > this.maxArrayLength) {
+      throw new DecodeError(`Max length exceeded: array length (${size}) > maxArrayLength (${this.maxArrayLength})`);
+    }
+    this.stack.pushArrayState(size);
+  }
+  decodeString(byteLength, headerOffset) {
+    if (!this.rawStrings || this.stateIsMapKey()) {
+      return this.decodeUtf8String(byteLength, headerOffset);
+    }
+    return this.decodeBinary(byteLength, headerOffset);
+  }
+  /**
+   * @throws {@link RangeError}
+   */
+  decodeUtf8String(byteLength, headerOffset) {
+    if (byteLength > this.maxStrLength) {
+      throw new DecodeError(`Max length exceeded: UTF-8 byte length (${byteLength}) > maxStrLength (${this.maxStrLength})`);
+    }
+    if (this.bytes.byteLength < this.pos + headerOffset + byteLength) {
+      throw MORE_DATA;
+    }
+    const offset = this.pos + headerOffset;
+    let object;
+    if (this.stateIsMapKey() && this.keyDecoder?.canBeCached(byteLength)) {
+      object = this.keyDecoder.decode(this.bytes, offset, byteLength);
+    } else {
+      object = utf8Decode(this.bytes, offset, byteLength);
+    }
+    this.pos += headerOffset + byteLength;
+    return object;
+  }
+  stateIsMapKey() {
+    if (this.stack.length > 0) {
+      const state = this.stack.top();
+      return state.type === STATE_MAP_KEY;
+    }
+    return false;
+  }
+  /**
+   * @throws {@link RangeError}
+   */
+  decodeBinary(byteLength, headOffset) {
+    if (byteLength > this.maxBinLength) {
+      throw new DecodeError(`Max length exceeded: bin length (${byteLength}) > maxBinLength (${this.maxBinLength})`);
+    }
+    if (!this.hasRemaining(byteLength + headOffset)) {
+      throw MORE_DATA;
+    }
+    const offset = this.pos + headOffset;
+    const object = this.bytes.subarray(offset, offset + byteLength);
+    this.pos += headOffset + byteLength;
+    return object;
+  }
+  decodeExtension(size, headOffset) {
+    if (size > this.maxExtLength) {
+      throw new DecodeError(`Max length exceeded: ext length (${size}) > maxExtLength (${this.maxExtLength})`);
+    }
+    const extType = this.view.getInt8(this.pos + headOffset);
+    const data = this.decodeBinary(
+      size,
+      headOffset + 1
+      /* extType */
+    );
+    return this.extensionCodec.decode(data, extType, this.context);
+  }
+  lookU8() {
+    return this.view.getUint8(this.pos);
+  }
+  lookU16() {
+    return this.view.getUint16(this.pos);
+  }
+  lookU32() {
+    return this.view.getUint32(this.pos);
+  }
+  readU8() {
+    const value = this.view.getUint8(this.pos);
+    this.pos++;
+    return value;
+  }
+  readI8() {
+    const value = this.view.getInt8(this.pos);
+    this.pos++;
+    return value;
+  }
+  readU16() {
+    const value = this.view.getUint16(this.pos);
+    this.pos += 2;
+    return value;
+  }
+  readI16() {
+    const value = this.view.getInt16(this.pos);
+    this.pos += 2;
+    return value;
+  }
+  readU32() {
+    const value = this.view.getUint32(this.pos);
+    this.pos += 4;
+    return value;
+  }
+  readI32() {
+    const value = this.view.getInt32(this.pos);
+    this.pos += 4;
+    return value;
+  }
+  readU64() {
+    const value = getUint64(this.view, this.pos);
+    this.pos += 8;
+    return value;
+  }
+  readI64() {
+    const value = getInt64(this.view, this.pos);
+    this.pos += 8;
+    return value;
+  }
+  readU64AsBigInt() {
+    const value = this.view.getBigUint64(this.pos);
+    this.pos += 8;
+    return value;
+  }
+  readI64AsBigInt() {
+    const value = this.view.getBigInt64(this.pos);
+    this.pos += 8;
+    return value;
+  }
+  readF32() {
+    const value = this.view.getFloat32(this.pos);
+    this.pos += 4;
+    return value;
+  }
+  readF64() {
+    const value = this.view.getFloat64(this.pos);
+    this.pos += 8;
+    return value;
+  }
+};
+
+// src/vendor/titan/client.ts
+var SUBPROTOCOL = "v1.api.titan.ag";
+var UINT64_MAX = (1n << 64n) - 1n;
+function toBigInt(value) {
+  if (typeof value === "bigint") {
+    if (value < 0n || value > UINT64_MAX) {
+      throw new RangeError(`Amount out of uint64 range: ${value}`);
+    }
+    return value;
+  }
+  if (!Number.isInteger(value)) {
+    throw new TypeError(`Amount must be a whole number, got ${value}`);
+  }
+  if (value < 0) {
+    throw new RangeError(`Amount must be non-negative, got ${value}`);
+  }
+  return BigInt(value);
+}
+var ConnectionClosed = class _ConnectionClosed extends Error {
+  code;
+  reason;
+  constructor(code, reason) {
+    super(`Client WebSocket closed with code ${code}: ${reason}`);
+    this.name = "ConnectionClosed";
+    Object.setPrototypeOf(this, _ConnectionClosed.prototype);
+    this.code = code;
+    this.reason = reason;
+  }
+};
+var ErrorResponse = class _ErrorResponse extends Error {
+  response;
+  constructor(response) {
+    super(`Request ${response.requestId} failed with code ${response.code}: ${response.message}`);
+    this.name = "ErrorResponse";
+    Object.setPrototypeOf(this, _ErrorResponse.prototype);
+    this.response = response;
+  }
+};
+var StreamError = class _StreamError extends Error {
+  streamId;
+  errorCode;
+  errorMessage;
+  constructor(packet) {
+    const code = packet.errorCode ?? 0;
+    const message = packet.errorMessage ?? "";
+    super(`Stream ${packet.id} ended with error code ${code}: ${message}`);
+    this.name = "StreamError";
+    Object.setPrototypeOf(this, _StreamError.prototype);
+    this.streamId = packet.id;
+    this.errorCode = code;
+    this.errorMessage = message;
+  }
+};
+var encoder = new Encoder({ useBigInt64: true });
+var decoder = new Decoder({ useBigInt64: true });
+var V1Client = class _V1Client {
+  socket;
+  nextId = 0;
+  _closed = false;
+  _closing = false;
+  pending = /* @__PURE__ */ new Map();
+  streams = /* @__PURE__ */ new Map();
+  streamStopping = /* @__PURE__ */ new Map();
+  closeListeners = [];
+  // --- Static connect ---
+  static connect(url) {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket__default.default(url, [SUBPROTOCOL]);
+      ws.binaryType = "arraybuffer";
+      ws.on("open", () => {
+        resolve(new _V1Client(ws));
+      });
+      ws.on("error", (err) => {
+        reject(err);
+      });
+    });
+  }
+  // --- Constructor ---
+  constructor(socket) {
+    this.socket = socket;
+    this.socket.on("message", (data) => {
+      this.handleMessage(data);
+    });
+    this.socket.on("close", (code, reason) => {
+      this.handleClose(code, reason.toString());
+    });
+    this.socket.on("error", (err) => {
+      this.handleError(err);
+    });
+  }
+  nextRequestId() {
+    return this.nextId++;
+  }
+  // --- Public API ---
+  get closed() {
+    return this._closed;
+  }
+  close() {
+    if (this._closed) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      this.closeListeners.push({ resolve, reject });
+      if (!this._closing) {
+        this._closing = true;
+        this.socket.close();
+      }
+    });
+  }
+  newSwapQuoteStream(params) {
+    const requestId = this.nextRequestId();
+    const promise = new Promise(
+      (resolve, reject) => {
+        this.pending.set(requestId, {
+          resolve,
+          reject,
+          kind: "NewSwapQuoteStream"
+        });
+      }
+    );
+    const normalized = {
+      ...params,
+      swap: { ...params.swap, amount: toBigInt(params.swap.amount) }
+    };
+    const message = {
+      id: requestId,
+      data: { NewSwapQuoteStream: normalized }
+    };
+    this.send(message);
+    return promise;
+  }
+  stopStream(streamId) {
+    const requestId = this.nextRequestId();
+    const promise = new Promise((resolve, reject) => {
+      this.pending.set(requestId, {
+        resolve,
+        reject,
+        kind: "StopStream"
+      });
+    });
+    const message = {
+      id: requestId,
+      data: { StopStream: { id: streamId } }
+    };
+    this.send(message);
+    return promise;
+  }
+  // --- Send ---
+  send(message) {
+    try {
+      const encoded = encoder.encode(message);
+      this.socket.send(encoded);
+    } catch (err) {
+      const req = this.pending.get(message.id);
+      if (req) {
+        this.pending.delete(message.id);
+        req.reject(err);
+      }
+    }
+  }
+  // --- Message handling ---
+  handleMessage(raw) {
+    let buf;
+    if (raw instanceof ArrayBuffer) {
+      buf = new Uint8Array(raw);
+    } else if (Buffer.isBuffer(raw)) {
+      buf = new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength);
+    } else if (Array.isArray(raw)) {
+      buf = new Uint8Array(Buffer.concat(raw));
+    } else {
+      return;
+    }
+    let message;
+    try {
+      message = decoder.decode(buf);
+    } catch {
+      this.socket.close(3002, "failed to decode message");
+      return;
+    }
+    if ("Response" in message) {
+      this.handleResponse(message.Response);
+    } else if ("Error" in message) {
+      this.handleResponseError(message.Error);
+    } else if ("StreamData" in message) {
+      this.handleStreamData(message.StreamData);
+    } else if ("StreamEnd" in message) {
+      this.handleStreamEnd(message.StreamEnd);
+    }
+  }
+  handleResponse(msg) {
+    const req = this.pending.get(msg.requestId);
+    if (!req) return;
+    this.pending.delete(msg.requestId);
+    if ("NewSwapQuoteStream" in msg.data && req.kind === "NewSwapQuoteStream") {
+      const streamInfo = msg.stream;
+      if (!streamInfo) {
+        req.reject(new Error("No stream associated with NewSwapQuoteStream response"));
+        return;
+      }
+      const stream = new ReadableStream({
+        start: (controller) => {
+          this.streams.set(streamInfo.id, controller);
+        },
+        cancel: () => {
+          return this.cancelStream(streamInfo.id);
+        }
+      });
+      const result = {
+        response: msg.data.NewSwapQuoteStream,
+        stream,
+        streamId: streamInfo.id
+      };
+      req.resolve(result);
+    } else if ("StreamStopped" in msg.data && req.kind === "StopStream") {
+      req.resolve(msg.data.StreamStopped);
+    } else {
+      req.reject(new Error(`Unexpected response type for ${req.kind}`));
+    }
+  }
+  handleResponseError(error) {
+    const req = this.pending.get(error.requestId);
+    if (!req) return;
+    this.pending.delete(error.requestId);
+    req.reject(new ErrorResponse(error));
+  }
+  handleStreamData(packet) {
+    const controller = this.streams.get(packet.id);
+    if (!controller) return;
+    if (packet.payload.SwapQuotes !== void 0) {
+      controller.enqueue(packet.payload.SwapQuotes);
+    }
+  }
+  handleStreamEnd(packet) {
+    const controller = this.streams.get(packet.id);
+    if (!controller) return;
+    this.streams.delete(packet.id);
+    this.streamStopping.delete(packet.id);
+    if (packet.errorCode !== void 0) {
+      controller.error(new StreamError(packet));
+    } else {
+      controller.close();
+    }
+  }
+  async cancelStream(streamId) {
+    if (this.streamStopping.get(streamId) || !this.streams.has(streamId)) return;
+    this.streamStopping.set(streamId, true);
+    await this.stopStream(streamId);
+  }
+  // --- Connection lifecycle ---
+  rejectAll(error) {
+    for (const req of this.pending.values()) {
+      req.reject(error);
+    }
+    this.pending.clear();
+    for (const controller of this.streams.values()) {
+      controller.error(error);
+    }
+    this.streams.clear();
+    this.streamStopping.clear();
+  }
+  handleClose(code, reason) {
+    this._closed = true;
+    this.rejectAll(new ConnectionClosed(code, reason));
+    for (const listener of this.closeListeners) {
+      listener.resolve();
+    }
+    this.closeListeners = [];
+  }
+  handleError(err) {
+    this.rejectAll(err);
+    this.socket.close(3002);
+  }
+};
+
+// src/vendor/titan/types.ts
+var SwapMode = /* @__PURE__ */ ((SwapMode2) => {
+  SwapMode2["ExactIn"] = "ExactIn";
+  SwapMode2["ExactOut"] = "ExactOut";
+  return SwapMode2;
+})(SwapMode || {});
+var SwapVersion = /* @__PURE__ */ ((SwapVersion2) => {
+  SwapVersion2[SwapVersion2["V2"] = 2] = "V2";
+  SwapVersion2[SwapVersion2["V3"] = 3] = "V3";
+  return SwapVersion2;
+})(SwapVersion || {});
+function deserializeSerializedInstruction(ix) {
+  return new web3_js.TransactionInstruction({
+    programId: new web3_js.PublicKey(Buffer.from(ix.p, "base64")),
+    keys: ix.a.map((account) => ({
+      pubkey: new web3_js.PublicKey(Buffer.from(account.p, "base64")),
+      isSigner: account.s,
+      isWritable: account.w
+    })),
+    data: Buffer.from(ix.d, "base64")
+  });
+}
+function selectBestRoute(quotes, swapMode) {
+  const routes = Object.values(quotes);
+  if (routes.length === 0) return null;
+  return routes.reduce((best, route) => {
+    if (swapMode === "ExactIn") {
+      return route.outAmount > best.outAmount ? route : best;
+    } else {
+      return route.inAmount < best.inAmount ? route : best;
+    }
+  });
+}
+function buildSwapQuoteResult(route, swapMode) {
+  const slippageBps = route.slippageBps;
+  let otherAmountThreshold;
+  if (swapMode === "ExactIn") {
+    otherAmountThreshold = String(Math.floor(route.outAmount * (1 - slippageBps / 1e4)));
+  } else {
+    otherAmountThreshold = String(Math.ceil(route.inAmount * (1 + slippageBps / 1e4)));
+  }
+  return {
+    inAmount: String(route.inAmount),
+    outAmount: String(route.outAmount),
+    otherAmountThreshold,
+    slippageBps,
+    platformFee: route.platformFee ? {
+      amount: String(route.platformFee.amount),
+      feeBps: route.platformFee.fee_bps
+    } : void 0,
+    contextSlot: route.contextSlot,
+    timeTaken: route.timeTaken
+  };
+}
+async function resolveLookupTables(connection, lutPubkeys) {
+  if (lutPubkeys.length === 0) return [];
+  const lutAccountsRaw = await connection.getMultipleAccountsInfo(lutPubkeys);
+  return lutAccountsRaw.map((accountInfo, index) => {
+    if (!accountInfo) return null;
+    return new web3_js.AddressLookupTableAccount({
+      key: lutPubkeys[index],
+      state: web3_js.AddressLookupTableAccount.deserialize(accountInfo.data)
+    });
+  }).filter((account) => account !== null);
+}
+
 exports.ACCOUNT_SIZE = ACCOUNT_SIZE;
 exports.ACCOUNT_TYPE_SIZE = ACCOUNT_TYPE_SIZE;
 exports.ASSOCIATED_TOKEN_PROGRAM_ID = ASSOCIATED_TOKEN_PROGRAM_ID;
 exports.AccountLayout = AccountLayout;
 exports.AccountState = AccountState;
 exports.AccountType = AccountType;
+exports.ConnectionClosed = ConnectionClosed;
 exports.CorpAction = CorpAction;
 exports.DEFAULT_RECENT_SLOT_DURATION_MS = DEFAULT_RECENT_SLOT_DURATION_MS;
 exports.DRIFT_IDL = DRIFT_IDL;
 exports.DRIFT_PROGRAM_ID = DRIFT_PROGRAM_ID;
 exports.DriftSpotBalanceType = DriftSpotBalanceType;
+exports.ErrorResponse = ErrorResponse;
 exports.ExtensionType = ExtensionType;
 exports.FARMS_PROGRAM_ID = FARMS_PROGRAM_ID;
 exports.JUP_EXCHANGE_PRICES_PRECISION = JUP_EXCHANGE_PRICES_PRECISION;
@@ -29269,6 +31013,9 @@ exports.SWITCHBOARD_ONDEMANDE_PRICE_PRECISION = SWITCHBOARD_ONDEMANDE_PRICE_PREC
 exports.SinglePoolInstruction = SinglePoolInstruction;
 exports.SplAccountType = SplAccountType;
 exports.SpotBalanceType = SpotBalanceType;
+exports.StreamError = StreamError;
+exports.SwapMode = SwapMode;
+exports.SwapVersion = SwapVersion;
 exports.TEN = TEN;
 exports.TOKEN_2022_PROGRAM_ID = TOKEN_2022_PROGRAM_ID;
 exports.TOKEN_PROGRAM_ID = TOKEN_PROGRAM_ID;
@@ -29287,9 +31034,10 @@ exports.TokenInvalidMintError = TokenInvalidMintError;
 exports.TokenInvalidOwnerError = TokenInvalidOwnerError;
 exports.TokenOwnerOffCurveError = TokenOwnerOffCurveError;
 exports.TokenUnsupportedInstructionError = TokenUnsupportedInstructionError;
+exports.V1Client = V1Client;
 exports.ZERO = ZERO;
 exports.addSigners = addSigners;
-exports.approveInstructionData = approveInstructionData;
+exports.buildSwapQuoteResult = buildSwapQuoteResult;
 exports.calculateAPYFromAPR = calculateAPYFromAPR;
 exports.calculateDriftBorrowAPR = calculateDriftBorrowAPR;
 exports.calculateDriftBorrowAPY = calculateDriftBorrowAPY;
@@ -29315,7 +31063,6 @@ exports.calculateSlotAdjustmentFactor = calculateSlotAdjustmentFactor;
 exports.calculateUtilizationRatio = calculateUtilizationRatio;
 exports.closeAccountInstructionData = closeAccountInstructionData;
 exports.createAccountIx = createAccountIx;
-exports.createApproveInstruction = createApproveInstruction;
 exports.createAssociatedTokenAccountIdempotentInstruction = createAssociatedTokenAccountIdempotentInstruction;
 exports.createAssociatedTokenAccountInstruction = createAssociatedTokenAccountInstruction;
 exports.createCloseAccountInstruction = createCloseAccountInstruction;
@@ -29365,6 +31112,7 @@ exports.deriveReserveLiquiditySupply = deriveReserveLiquiditySupply;
 exports.deriveShortUrl = deriveShortUrl;
 exports.deriveUserMetadata = deriveUserMetadata;
 exports.deriveUserState = deriveUserState;
+exports.deserializeSerializedInstruction = deserializeSerializedInstruction;
 exports.driftRewardsRawToDto = driftRewardsRawToDto;
 exports.driftSpotMarketRawToDto = driftSpotMarketRawToDto;
 exports.driftStateRawToDto = driftStateRawToDto;
@@ -29439,7 +31187,9 @@ exports.parsePriceData = parsePriceData;
 exports.parsePriceInfo = parsePriceInfo2;
 exports.replenishPoolIx = replenishPoolIx;
 exports.reserveRawToDto = reserveRawToDto;
+exports.resolveLookupTables = resolveLookupTables;
 exports.scaledSupplies = scaledSupplies;
+exports.selectBestRoute = selectBestRoute;
 exports.slotAdjustmentFactor = slotAdjustmentFactor;
 exports.switchboardAccountCoder = switchboardAccountCoder;
 exports.syncNativeInstructionData = syncNativeInstructionData;