@decibeltrade/sdk 0.1.1

package/src/read/ws-subscription.ts

@@ -0,0 +1,200 @@
+import WebSocket, { ErrorEvent } from "isomorphic-ws";
+import { z } from "zod/v4";
+
+import { DecibelConfig } from "../constants";
+import { bigIntReviver, prettifyMaybeZodError } from "../utils";
+
+export class DecibelWsSubscription {
+  constructor(
+    readonly config: DecibelConfig,
+    readonly onError?: (error: ErrorEvent) => void,
+  ) {}
+
+  #ws: WebSocket | null = null;
+  #subscriptions = new Map<string, Set<(data: unknown) => void | Promise<void>>>();
+  #reconnectAttempts = 0;
+
+  #getSubscribeMessage(topic: string) {
+    return JSON.stringify({ Subscribe: { topic } });
+  }
+
+  #getUnsubscribeMessage(topic: string) {
+    return JSON.stringify({ Unsubscribe: { topic } });
+  }
+
+  #parseMessageData(data: WebSocket.Data): { topic: string; data: unknown } | null {
+    if (typeof data !== "string") {
+      return null;
+    }
+    try {
+      const jsonData: unknown = JSON.parse(data, bigIntReviver);
+      if (
+        jsonData &&
+        typeof jsonData === "object" &&
+        "topic" in jsonData &&
+        typeof jsonData.topic === "string"
+      ) {
+        const { topic, ...rest } = jsonData;
+        return { topic, data: rest };
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  #open() {
+    if (this.#ws) {
+      return;
+    }
+
+    const ws = new WebSocket(this.config.tradingWsUrl);
+
+    ws.addEventListener("open", () => {
+      this.#reconnectAttempts = 0;
+      this.#subscriptions.keys().forEach((topic) => {
+        ws.send(this.#getSubscribeMessage(topic));
+      });
+    });
+
+    ws.addEventListener("message", (event) => {
+      if (
+        typeof event.data === "string" &&
+        (event.data.includes("UnsubscribeResponse") || event.data.includes("SubscribeResponse"))
+      ) {
+        // Ignore response messages for now. Maybe we'll make use of them in the future.
+        return;
+      }
+
+      const parsedMessage = this.#parseMessageData(event.data);
+      if (!parsedMessage) {
+        throw new Error("Unhandled WebSocket message:", { cause: event.data });
+      }
+      const { topic, data } = parsedMessage;
+      const listeners = this.#subscriptions.get(topic);
+      if (listeners) {
+        listeners.forEach((listener) => {
+          try {
+            void listener(data);
+          } catch (e) {
+            // Log error but don't break other listeners
+            console.error(`Error in WebSocket listener for topic : `, topic, " with error : ", e);
+          }
+        });
+      }
+    });
+
+    ws.addEventListener("error", (event) => {
+      this.onError?.(event);
+      ws.close();
+    });
+
+    ws.addEventListener("close", () => {
+      this.#ws = null;
+
+      // If there are still subscriptions, reconnect.
+      if (this.#subscriptions.size > 0) {
+        setTimeout(() => this.#open(), Math.pow(1.5, this.#reconnectAttempts) * 1000);
+        this.#reconnectAttempts++;
+      }
+    });
+
+    this.#ws = ws;
+  }
+
+  subscribe<TMessageData>(
+    topic: string,
+    schema: z.ZodType<TMessageData>,
+    onData: (data: TMessageData) => void | Promise<void>,
+  ) {
+    const listeners = this.#subscriptions.get(topic) ?? new Set();
+
+    // If subscription arent found, subscribe to topic first
+    if (listeners.size === 0) {
+      if (this.#ws?.readyState === WebSocket.OPEN) {
+        this.#ws.send(this.#getSubscribeMessage(topic));
+      }
+    }
+
+    const listener = (data: unknown) => {
+      try {
+        const parsedData = schema.parse(data);
+        void onData(parsedData);
+      } catch (e) {
+        throw prettifyMaybeZodError(e);
+      }
+    };
+
+    listeners.add(listener);
+
+    this.#subscriptions.set(topic, listeners);
+
+    // Open the WebSocket. All subscription messages will be sent when the WebSocket is opened.
+    if (!this.#ws) {
+      this.#open();
+    }
+
+    return () => this.unsubscribeByListener(topic, listener);
+  }
+
+  private unsubscribe(topic: string) {
+    if (!this.#subscriptions.has(topic)) return;
+
+    this.#subscriptions.delete(topic);
+
+    if (this.#ws?.readyState === WebSocket.OPEN) {
+      this.#ws.send(this.#getUnsubscribeMessage(topic));
+    }
+
+    // Close the WebSocket if the last subscription was removed.
+    if (this.#subscriptions.size === 0) {
+      this.#ws?.close();
+    }
+  }
+
+  /**
+   * Removes the specified listener from the set of listeners for the given topic.
+   * If no listeners remain for the topic after removal, unsubscribes from the topic.
+   * If all subscriptions are removed, closes the WebSocket connection.
+   */
+  private unsubscribeByListener(topic: string, listener: (data: unknown) => void | Promise<void>) {
+    if (this.#subscriptions.has(topic)) {
+      const listeners = this.#subscriptions.get(topic);
+
+      if (!listeners) return;
+
+      // Remove the specified listener
+      listeners.delete(listener);
+
+      // If no listeners remain for the topic, unsubscribe from the topic
+      if (listeners.size === 0) {
+        this.unsubscribe(topic);
+      }
+      // Otherwise, update the listeners set for the topic
+      else {
+        this.#subscriptions.set(topic, listeners);
+      }
+    }
+  }
+
+  reset(topic: string) {
+    if (!this.#subscriptions.has(topic)) {
+      return;
+    }
+
+    if (this.#ws?.readyState === WebSocket.OPEN) {
+      this.#ws.send(this.#getUnsubscribeMessage(topic));
+      this.#ws.send(this.#getSubscribeMessage(topic));
+      return;
+    }
+  }
+
+  close() {
+    this.#subscriptions.clear();
+    this.#ws?.close();
+  }
+
+  readyState() {
+    return this.#ws?.readyState ?? WebSocket.CLOSED;
+  }
+}

package/src/subaccount-types.ts

@@ -0,0 +1,31 @@
+import z from "zod/v4";
+
+// TODO: put this in a separate folder and split up WRITE sdk
+
+export interface SubaccountCreatedEvent {
+  is_primary: boolean;
+  owner: string;
+  subaccount: string;
+}
+
+export interface SubaccountActiveChangedEvent {
+  is_active: boolean;
+  owner: string;
+  subaccount: string;
+}
+
+export interface CreateSubaccountResponse {
+  subaccountAddress: string | null;
+}
+
+export interface RenameSubaccountArgs {
+  subaccountAddress: string;
+  newName: string;
+}
+
+export const RenameSubaccountSchema = z.object({
+  subaccount_address: z.string(),
+  new_name: z.string(),
+});
+
+export type RenameSubaccount = z.infer<typeof RenameSubaccountSchema>;

package/src/transaction-builder.ts

@@ -0,0 +1,75 @@
+import {
+  AccountAddress,
+  AccountAddressInput,
+  AptosConfig,
+  ChainId,
+  convertPayloadToInnerPayload,
+  EntryFunctionABI,
+  findFirstNonSignerArg,
+  generateTransactionPayloadWithABI,
+  InputEntryFunctionData,
+  InputEntryFunctionDataWithABI,
+  MoveFunction,
+  parseTypeTag,
+  RawTransaction,
+  SimpleTransaction,
+  TypeTag,
+} from "@aptos-labs/ts-sdk";
+
+export function buildSimpleTransactionSync(args: {
+  aptosConfig: AptosConfig;
+  sender: AccountAddressInput;
+  data: InputEntryFunctionData;
+  chainId: number;
+  gasUnitPrice: number;
+  abi: MoveFunction;
+  withFeePayer: boolean;
+  replayProtectionNonce: bigint;
+  timeDeltaMs?: number;
+}) {
+  const txnPayload = generateTransactionPayloadWithABI({
+    aptosConfig: args.aptosConfig,
+    function: args.data.function,
+    functionArguments: args.data.functionArguments,
+    typeArguments: args.data.typeArguments,
+    abi: parseMoveFnAbiToEntryFnABI(args.abi),
+  } as InputEntryFunctionDataWithABI);
+
+  const expireTimestamp = generateExpireTimestamp(args.aptosConfig, args.timeDeltaMs);
+
+  const rawTxn = new RawTransaction(
+    AccountAddress.from(args.sender),
+    // If replay nonce is provided, use it as the sequence number
+    // This is an unused value, so it's specifically to show that the sequence number is not used
+    BigInt("0xdeadbeef"),
+    convertPayloadToInnerPayload(txnPayload, args.replayProtectionNonce),
+    // @Todo: Use gasPriceManager to get the max gas amount [as defaultMaxGasAmount might be very high number]
+    BigInt(args.aptosConfig.getDefaultMaxGasAmount()),
+    BigInt(args.gasUnitPrice),
+    BigInt(expireTimestamp),
+    new ChainId(args.chainId),
+  );
+
+  return new SimpleTransaction(rawTxn, args.withFeePayer ? AccountAddress.ZERO : undefined);
+}
+
+const parseMoveFnAbiToEntryFnABI = (functionAbi: MoveFunction): EntryFunctionABI => {
+  // Remove the signer arguments
+  const numSigners = findFirstNonSignerArg(functionAbi);
+
+  const params: TypeTag[] = [];
+  for (let i = numSigners; i < functionAbi.params.length; i += 1) {
+    const param = functionAbi.params[i];
+    if (!param) continue;
+    params.push(parseTypeTag(param, { allowGenerics: true }));
+  }
+
+  return {
+    signers: numSigners,
+    typeParameters: functionAbi.generic_type_params,
+    parameters: params,
+  };
+};
+
+export const generateExpireTimestamp = (aptosConfig: AptosConfig, timeDeltaMs = 0) =>
+  Math.floor((Date.now() + timeDeltaMs) / 1000) + aptosConfig.getDefaultTxnExpirySecFromNow();

package/src/utils.ts

@@ -0,0 +1,255 @@
+import {
+  AccountAddress,
+  CommittedTransactionResponse,
+  createObjectAddress,
+  MoveString,
+} from "@aptos-labs/ts-sdk";
+import { z, ZodError } from "zod/v4";
+
+import { QUERY_PARAM_KEYS } from "./constants";
+import { PageParams, SearchTermParams, SortParams } from "./read";
+
+export function getMarketAddr(name: string, perpEngineGlobalAddr: string) {
+  const marketNameBytes = new MoveString(name).bcsToBytes();
+  return createObjectAddress(AccountAddress.fromString(perpEngineGlobalAddr), marketNameBytes);
+}
+
+export type FetchOptions = Omit<RequestInit, "method" | "body">;
+
+export interface PostRequestArgs<TResponseData> {
+  schema: z.ZodType<TResponseData>;
+  url: string;
+  body?: unknown;
+  options?: FetchOptions;
+  apiKey?: string;
+}
+
+export async function postRequest<TResponseData>({
+  schema,
+  url,
+  body,
+  options = {},
+  apiKey,
+}: PostRequestArgs<TResponseData>) {
+  return baseRequest({
+    schema,
+    url,
+    method: "POST",
+    body,
+    options,
+    setJsonContentType: true,
+    apiKey,
+  });
+}
+
+export interface PatchRequestArgs<TResponseData> {
+  schema: z.ZodType<TResponseData>;
+  url: string;
+  body?: unknown;
+  options?: FetchOptions;
+  apiKey?: string;
+}
+
+export async function patchRequest<TResponseData>({
+  schema,
+  url,
+  body,
+  options = {},
+  apiKey,
+}: PatchRequestArgs<TResponseData>) {
+  return baseRequest({
+    schema,
+    url,
+    method: "PATCH",
+    body,
+    options,
+    setJsonContentType: true,
+    apiKey,
+  });
+}
+
+export interface GetRequestArgs<TResponseData> {
+  schema: z.ZodType<TResponseData>;
+  url: string;
+  queryParams?: ConstructorParameters<typeof URLSearchParams>[0];
+  options?: FetchOptions;
+  apiKey?: string;
+}
+
+export async function getRequest<TResponseData>({
+  schema,
+  url,
+  queryParams,
+  options = {},
+  apiKey,
+}: GetRequestArgs<TResponseData>) {
+  return baseRequest({
+    schema,
+    url,
+    method: "GET",
+    queryParams,
+    options,
+    apiKey,
+  });
+}
+
+interface BaseRequestArgs<TResponseData> {
+  schema: z.ZodType<TResponseData>;
+  url: string;
+  method: "GET" | "POST" | "PATCH";
+  options?: FetchOptions;
+  body?: unknown;
+  queryParams?: ConstructorParameters<typeof URLSearchParams>[0];
+  setJsonContentType?: boolean;
+  apiKey?: string;
+}
+
+async function baseRequest<TResponseData>({
+  schema,
+  url,
+  method,
+  options = {},
+  body,
+  queryParams,
+  setJsonContentType = false,
+  apiKey,
+}: BaseRequestArgs<TResponseData>) {
+  const { headers: argHeaders, credentials, ...restOptions } = options;
+
+  const headers = new Headers(argHeaders);
+  if (setJsonContentType) {
+    headers.set("Content-Type", "application/json");
+  }
+  if (apiKey) {
+    headers.set("Authorization", `Bearer ${apiKey}`);
+  }
+
+  const queryString = queryParams ? `?${new URLSearchParams(queryParams).toString()}` : "";
+  const fullUrl = `${url}${queryString}`;
+
+  const fetchInit: RequestInit = {
+    method,
+    headers,
+    credentials,
+    ...restOptions,
+  };
+
+  if (body !== undefined) {
+    fetchInit.body = JSON.stringify(body);
+  }
+
+  const response = await fetch(fullUrl, fetchInit);
+  const { status, statusText } = response;
+
+  if (!response.ok) {
+    const message = await response.text();
+    throw new Error(`HTTP Error ${status} (${statusText}): ${message}`);
+  }
+
+  const textData = await response.text();
+  try {
+    const data = schema.parse(JSON.parse(textData, bigIntReviver));
+    return { data, status, statusText };
+  } catch (e) {
+    throw prettifyMaybeZodError(e);
+  }
+}
+
+export function prettifyMaybeZodError(e: unknown) {
+  if (e instanceof ZodError) {
+    return new Error(z.prettifyError(e), { cause: e });
+  }
+  return e;
+}
+
+export function bigIntReviver(key: string, value: unknown) {
+  if (
+    value &&
+    typeof value === "object" &&
+    "$bigint" in value &&
+    typeof value.$bigint === "string"
+  ) {
+    return BigInt(value.$bigint);
+  }
+  return value;
+}
+
+export function getPrimarySubaccountAddr(addr: AccountAddress | string) {
+  const account = typeof addr === "string" ? AccountAddress.fromString(addr) : addr;
+  const seed = new TextEncoder().encode("decibel_dex_primary");
+  return createObjectAddress(account, seed).toString();
+}
+
+export function getVaultShareAddress(vaultAddress: string) {
+  const seed = new TextEncoder().encode("vault_share_asset");
+  return createObjectAddress(AccountAddress.fromString(vaultAddress), seed).toString();
+}
+
+type KnownQueryParams = Partial<PageParams & SearchTermParams & SortParams<string>>;
+
+export const PARAM_MAP: Record<keyof KnownQueryParams, string> = {
+  limit: QUERY_PARAM_KEYS.limit,
+  offset: QUERY_PARAM_KEYS.offset,
+  sortKey: QUERY_PARAM_KEYS.sortKey,
+  sortDir: QUERY_PARAM_KEYS.sortDir,
+  searchTerm: QUERY_PARAM_KEYS.searchTerm,
+};
+
+/**
+ * Construct query params from an args object, supporting optional PageParams, SearchTermParams, and generic SortParams.
+ * @param args - The argument object, which may include page, search, and sort params.
+ * @returns URLSearchParams instance with the constructed query parameters.
+ */
+export function constructKnownQueryParams(args: KnownQueryParams): URLSearchParams {
+  const queryParams = new URLSearchParams();
+
+  Object.keys(args).forEach((_argKey) => {
+    const argKey = _argKey as keyof KnownQueryParams;
+
+    const value = args[argKey];
+
+    const paramKey = PARAM_MAP[argKey];
+
+    if (paramKey && value !== undefined && !(typeof value === "string" && value.trim() === "")) {
+      queryParams.set(paramKey, String(value));
+    }
+  });
+
+  return queryParams;
+}
+
+export function generateRandomReplayProtectionNonce() {
+  const buf = new Uint32Array(2);
+
+  crypto.getRandomValues(buf);
+
+  const valueAtIndex0 = buf[0];
+
+  const valueAtIndex1 = buf[1];
+
+  if (!valueAtIndex0 || !valueAtIndex1) return null;
+
+  // combine two 32-bit parts into a single 64-bit bigint
+  return (BigInt(valueAtIndex0) << BigInt(32)) | BigInt(valueAtIndex1);
+}
+
+export const extractVaultAddressFromCreateTx = (createVaultTx: CommittedTransactionResponse) => {
+  // Extract vault address from transaction events
+  let vaultAddress: string | { inner: string } | null = null;
+  if ("events" in createVaultTx && Array.isArray(createVaultTx.events)) {
+    for (const event of createVaultTx.events) {
+      if (event.type.includes("::vault::VaultCreatedEvent")) {
+        const eventData = event.data as { vault: string | { inner: string } };
+        vaultAddress = eventData.vault;
+        break;
+      }
+    }
+  }
+
+  if (!vaultAddress) throw new Error("Unable to extract vault address from transaction");
+
+  vaultAddress =
+    typeof vaultAddress === "object" && "inner" in vaultAddress ? vaultAddress.inner : vaultAddress;
+
+  return vaultAddress;
+};