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

package/dist/vendor.cjs

@@ -10,6 +10,8 @@ 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');
+var msgpack = require('@msgpack/msgpack');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -34,6 +36,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");
@@ -29190,6 +29193,358 @@ function makeUpdateJupLendRate({ lendingState }) {
     lendingState.rewardsRateModel
   );
 }
+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 msgpack.Encoder({ useBigInt64: true });
+var decoder = new msgpack.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";
+      const onOpen = () => {
+        ws.off("error", onError);
+        ws.off("close", onClose);
+        resolve(new _V1Client(ws));
+      };
+      const onError = (err) => {
+        ws.off("open", onOpen);
+        ws.off("close", onClose);
+        reject(err);
+      };
+      const onClose = (code, reason) => {
+        ws.off("open", onOpen);
+        ws.off("error", onError);
+        reject(
+          new Error(
+            `WebSocket closed before open (code=${code}${reason.length ? `, reason=${reason.toString()}` : ""})`
+          )
+        );
+      };
+      ws.once("open", onOpen);
+      ws.once("error", onError);
+      ws.once("close", onClose);
+    });
+  }
+  // --- 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;
@@ -29197,11 +29552,13 @@ 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 +29626,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 +29647,11 @@ 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;
@@ -29365,6 +29727,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 +29802,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;